Client-side functions: Difference between revisions

From RAGE Multiplayer Wiki
(Undo revision 486 by SalwadoR (talk))
No edit summary
Line 47: Line 47:


==App==
==App==
**App::appGetFloat(property);
**[[App::appGetFloat|App::appGetFloat(property)]]
**App::appSetFloat(property, value);
**[[App::appSetFloat|App::appSetFloat(property, value)]]
**App::appSetBlock(blockName);
**[[App::appSetBlock|App::appSetBlock(blockName)]]
**App::appSetString(property, value);
**[[App::appSetString|App::appSetString(property, value)]]
**App::appDeleteAppData(appName);
**[[App::appDeleteAppData|App::appDeleteAppData(appName)]]
**App::appSetInt(property, value);
**[[App::appSetInt|App::appSetInt(property, value)]]
**App::appGetString(property);
**[[App::appGetString|App::appGetString(property)]]
**App::appHasSyncedData(appName);
**[[App::appHasSyncedData|App::appHasSyncedData(appName)]]
**App::appSetApp(appName);
**[[App::appSetApp|App::appSetApp(appName)]]
**App::appGetInt(property);
**[[App::appGetInt|App::appGetInt(property)]]


==Audio==
==Audio==
**Audio::startAudioScene(sceneName);
**[[Audio::startAudioScene|Audio::startAudioScene(sceneName)]]
**Audio::isAmbientZoneEnabled(ambientZone);
**[[Audio::isAmbientZoneEnabled|Audio::isAmbientZoneEnabled(ambientZone)]]
**Audio::getVehicleDefaultHorn(veh);
**[[Audio::getVehicleDefaultHorn|Audio::getVehicleDefaultHorn(veh)]]
**Audio::prepareSynchronizedAudioEventForScene(p0, p1);
**[[Audio::prepareSynchronizedAudioEventForScene|Audio::prepareSynchronizedAudioEventForScene(p0, p1)]]
**Audio::startAlarm(alarmName, p2);
**[[Audio::startAlarm|Audio::startAlarm(alarmName, p2)]]
**Audio::setMobileRadioEnabledDuringGameplay(Toggle);
**[[Audio::setMobileRadioEnabledDuringGameplay|Audio::setMobileRadioEnabledDuringGameplay(Toggle)]]
**Audio::clearAmbientZoneListState(p0, p1);
**[[Audio::clearAmbientZoneListState|Audio::clearAmbientZoneListState(p0, p1)]]
**Audio::overrideTrevorRage(p0);
**[[Audio::overrideTrevorRage|Audio::overrideTrevorRage(p0)]]
**Audio::setUserRadioControlEnabled(p0);
**[[Audio::setUserRadioControlEnabled|Audio::setUserRadioControlEnabled(p0)]]
**Audio::setAmbientZoneStatePersistent(ambientZone, p1, p2);
**[[Audio::setAmbientZoneStatePersistent|Audio::setAmbientZoneStatePersistent(ambientZone, p1, p2)]]
**Audio::prepareMusicEvent(eventName);
**[[Audio::prepareMusicEvent|Audio::prepareMusicEvent(eventName)]]
**Audio::loadStream(streamName, soundSet);
**[[Audio::loadStream|Audio::loadStream(streamName, soundSet)]]
**Audio::specialFrontendEqual(x, y, z);
**[[Audio::specialFrontendEqual|Audio::specialFrontendEqual(x, y, z)]]
**Audio::clearAmbientZoneState(p0, p1);
**[[Audio::clearAmbientZoneState|Audio::clearAmbientZoneState(p0, p1)]]
**Audio::isAlarmPlaying(alarmName);
**[[Audio::isAlarmPlaying|Audio::isAlarmPlaying(alarmName)]]
**Audio::startScriptPhoneConversation(p0, p1);
**[[Audio::startScriptPhoneConversation|Audio::startScriptPhoneConversation(p0, p1)]]
**Audio::getNetworkIdFromSoundId(soundId);
**[[Audio::getNetworkIdFromSoundId|Audio::getNetworkIdFromSoundId(soundId)]]
**Audio::stopAllAlarms(stop);
**[[Audio::stopAllAlarms|Audio::stopAllAlarms(stop)]]
**Audio::requestScriptAudioBank(p0, p1);
**[[Audio::requestScriptAudioBank|Audio::requestScriptAudioBank(p0, p1)]]
**Audio::setVariableOnStream(p0, p1);
**[[Audio::setVariableOnStream|Audio::setVariableOnStream(p0, p1)]]
**Audio::freezeRadioStation(radioStation);
**[[Audio::freezeRadioStation|Audio::freezeRadioStation(radioStation)]]
**Audio::playAmbientSpeechWithVoice(p0, speechName, voiceName, speechParam, p4);
**[[Audio::playAmbientSpeechWithVoice|Audio::playAmbientSpeechWithVoice(p0, speechName, voiceName, speechParam, p4)]]
**Audio::releaseSoundId(soundId);
**[[Audio::releaseSoundId|Audio::releaseSoundId(soundId)]]
**Audio::setAggressiveHorns(toggle);
**[[Audio::setAggressiveHorns|Audio::setAggressiveHorns(toggle)]]
**Audio::setStaticEmitterEnabled(emitterName, toggle);
**[[Audio::setStaticEmitterEnabled|Audio::setStaticEmitterEnabled(emitterName, toggle)]]
**Audio::preloadScriptConversation(p0, p1, p2, p3);
**[[Audio::preloadScriptConversation|Audio::preloadScriptConversation(p0, p1, p2, p3)]]
**Audio::setCutsceneAudioOverride(p0);
**[[Audio::setCutsceneAudioOverride|Audio::setCutsceneAudioOverride(p0)]]
**Audio::setGpsActive(active);
**[[Audio::setGpsActive|Audio::setGpsActive(active)]]
**Audio::loadStreamWithStartOffset(streamName, startOffset, soundSet);
**[[Audio::loadStreamWithStartOffset|Audio::loadStreamWithStartOffset(streamName, startOffset, soundSet)]]
**Audio::cancelMusicEvent(eventName);
**[[Audio::cancelMusicEvent|Audio::cancelMusicEvent(eventName)]]
**Audio::preloadScriptPhoneConversation(p0, p1);
**[[Audio::preloadScriptPhoneConversation|Audio::preloadScriptPhoneConversation(p0, p1)]]
**Audio::getNumberOfPassengerVoiceVariations(p0);
**[[Audio::getNumberOfPassengerVoiceVariations|Audio::getNumberOfPassengerVoiceVariations(p0)]]
**Audio::playSoundFrontend(soundId, audioName, audioRef, p3);
**[[Audio::playSoundFrontend|Audio::playSoundFrontend(soundId, audioName, audioRef, p3)]]
**Audio::startScriptConversation(p0, p1, p2, p3);
**[[Audio::startScriptConversation|Audio::startScriptConversation(p0, p1, p2, p3)]]
**Audio::triggerMusicEvent(eventName);
**[[Audio::triggerMusicEvent|Audio::triggerMusicEvent(eventName)]]
**Audio::requestMissionAudioBank(p0, p1);
**[[Audio::requestMissionAudioBank|Audio::requestMissionAudioBank(p0, p1)]]
**Audio::getSoundIdFromNetworkId(netId);
**[[Audio::getSoundIdFromNetworkId|Audio::getSoundIdFromNetworkId(netId)]]
**Audio::releaseNamedScriptAudioBank(audioBank);
**[[Audio::releaseNamedScriptAudioBank|Audio::releaseNamedScriptAudioBank(audioBank)]]
**Audio::playSound(soundId, audioName, audioRef, p3, p4, p5);
**[[Audio::playSound|Audio::playSound(soundId, audioName, audioRef, p3, p4, p5)]]
**Audio::pauseScriptedConversation(p0);
**[[Audio::pauseScriptedConversation|Audio::pauseScriptedConversation(p0)]]
**Audio::setInitialPlayerStation(radioStation);
**[[Audio::setInitialPlayerStation|Audio::setInitialPlayerStation(radioStation)]]
**Audio::playSynchronizedAudioEvent(p0);
**[[Audio::playSynchronizedAudioEvent|Audio::playSynchronizedAudioEvent(p0)]]
**Audio::findRadioStationIndex(station);
**[[Audio::findRadioStationIndex|Audio::findRadioStationIndex(station)]]
**Audio::playSoundFromCoord(soundId, audioName, x, y, z, audioRef, p6, p7, p8);
**[[Audio::playSoundFromCoord|Audio::playSoundFromCoord(soundId, audioName, x, y, z, audioRef, p6, p7, p8)]]
**Audio::hintAmbientAudioBank(p0, p1);
**[[Audio::hintAmbientAudioBank|Audio::hintAmbientAudioBank(p0, p1)]]
**Audio::isAmbientSpeechPlaying(p0);
**[[Audio::isAmbientSpeechPlaying|Audio::isAmbientSpeechPlaying(p0)]]
**Audio::stopSynchronizedAudioEvent(p0);
**[[Audio::stopSynchronizedAudioEvent|Audio::stopSynchronizedAudioEvent(p0)]]
**Audio::setSynchronizedAudioEventPositionThisFrame(p0, p1);
**[[Audio::setSynchronizedAudioEventPositionThisFrame|Audio::setSynchronizedAudioEventPositionThisFrame(p0, p1)]]
**Audio::addPedToConversation(p0, p1, p2);
**[[Audio::addPedToConversation|Audio::addPedToConversation(p0, p1, p2)]]
**Audio::setAmbientZoneListState(p0, p1, p2);
**[[Audio::setAmbientZoneListState|Audio::setAmbientZoneListState(p0, p1, p2)]]
**Audio::prepareAlarm(alarmName);
**[[Audio::prepareAlarm|Audio::prepareAlarm(alarmName)]]
**Audio::interruptConversation(p0, p1, p2);
**[[Audio::interruptConversation|Audio::interruptConversation(p0, p1, p2)]]
**Audio::stopAlarm(alarmName, toggle);
**[[Audio::stopAlarm|Audio::stopAlarm(alarmName, toggle)]]
**Audio::stopSound(soundId);
**[[Audio::stopSound|Audio::stopSound(soundId)]]
**Audio::setRadioToStationIndex(radioStation);
**[[Audio::setRadioToStationIndex|Audio::setRadioToStationIndex(radioStation)]]
**Audio::setEmitterRadioStation(emitterName, radioStation);
**[[Audio::setEmitterRadioStation|Audio::setEmitterRadioStation(emitterName, radioStation)]]
**Audio::setVariableOnSound(soundId, p1, p2);
**[[Audio::setVariableOnSound|Audio::setVariableOnSound(soundId, p1, p2)]]
**Audio::playMissionCompleteAudio(audioName);
**[[Audio::playMissionCompleteAudio|Audio::playMissionCompleteAudio(audioName)]]
**Audio::unlockMissionNewsStory(newsStory);
**[[Audio::unlockMissionNewsStory|Audio::unlockMissionNewsStory(newsStory)]]
**Audio::getRadioStationName(radioStation);
**[[Audio::getRadioStationName|Audio::getRadioStationName(radioStation)]]
**Audio::setRadioTrack(radioStation, radioTrack);
**[[Audio::setRadioTrack|Audio::setRadioTrack(radioStation, radioTrack)]]
**Audio::isAudioSceneActive(scene);
**[[Audio::isAudioSceneActive|Audio::isAudioSceneActive(scene)]]
**Audio::setMicrophonePosition(p0, x1, y1, z1, x2, y2, z2, x3, y3, z3);
**[[Audio::setMicrophonePosition|Audio::setMicrophonePosition(p0, x1, y1, z1, x2, y2, z2, x3, y3, z3)]]
**Audio::stopCurrentPlayingAmbientSpeech(p0);
**[[Audio::stopCurrentPlayingAmbientSpeech|Audio::stopCurrentPlayingAmbientSpeech(p0)]]
**Audio::setAudioFlag(flagName, toggle);
**[[Audio::setAudioFlag|Audio::setAudioFlag(flagName, toggle)]]
**Audio::playPain(painID, p1, p2);
**[[Audio::playPain|Audio::playPain(painID, p1, p2)]]
**Audio::getPlayerHeadsetSoundAlternate(p0, p1);
**[[Audio::getPlayerHeadsetSoundAlternate|Audio::getPlayerHeadsetSoundAlternate(p0, p1)]]
**Audio::setAmbientZoneState(p0, p1, p2);
**[[Audio::setAmbientZoneState|Audio::setAmbientZoneState(p0, p1, p2)]]
**Audio::setMobilePhoneRadioState(state);
**[[Audio::setMobilePhoneRadioState|Audio::setMobilePhoneRadioState(state)]]
**Audio::setRadioAutoUnfreeze(p0);
**[[Audio::setRadioAutoUnfreeze|Audio::setRadioAutoUnfreeze(p0)]]
**Audio::addLineToConversation(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
**[[Audio::addLineToConversation|Audio::addLineToConversation(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)]]
**Audio::setRadioToStationName(stationName);
**[[Audio::setRadioToStationName|Audio::setRadioToStationName(stationName)]]
**Audio::registerScriptWithAudio(p0);
**[[Audio::registerScriptWithAudio|Audio::registerScriptWithAudio(p0)]]
**Audio::prepareSynchronizedAudioEvent(p0, p1);
**[[Audio::prepareSynchronizedAudioEvent|Audio::prepareSynchronizedAudioEvent(p0, p1)]]
**Audio::setAnimalMood(p0, p1);
**[[Audio::setAnimalMood|Audio::setAnimalMood(p0, p1)]]
**Audio::isScriptedSpeechPlaying(p0);
**[[Audio::isScriptedSpeechPlaying|Audio::isScriptedSpeechPlaying(p0)]]
**Audio::playEndCreditsMusic(play);
**[[Audio::playEndCreditsMusic|Audio::playEndCreditsMusic(play)]]
**Audio::stopScriptedConversation(p0);
**[[Audio::stopScriptedConversation|Audio::stopScriptedConversation(p0)]]
**Audio::stopAudioScene(scene);
**[[Audio::stopAudioScene|Audio::stopAudioScene(scene)]]
**Audio::playPoliceReport(name, p1);
**[[Audio::playPoliceReport|Audio::playPoliceReport(name, p1)]]
**Audio::playSoundFromEntity(soundId, audioName, entity, audioRef, p4, p5);
**[[Audio::playSoundFromEntity|Audio::playSoundFromEntity(soundId, audioName, entity, audioRef, p4, p5)]]
**Audio::setPlayerAngry(playerPed, disabled);
**[[Audio::setPlayerAngry|Audio::setPlayerAngry(playerPed, disabled)]]
**Audio::playStreamFromObject(object);
**[[Audio::playStreamFromObject|Audio::playStreamFromObject(object)]]
**Audio::playAmbientSpeechAtCoords(p0, p1, p2, p3, p4, p5);
**[[Audio::playAmbientSpeechAtCoords|Audio::playAmbientSpeechAtCoords(p0, p1, p2, p3, p4, p5)]]
**Audio::setAudioSceneVariable(p0, p1, p2);
**[[Audio::setAudioSceneVariable|Audio::setAudioSceneVariable(p0, p1, p2)]]
**Audio::overrideUnderwaterStream(p0, p1);
**[[Audio::overrideUnderwaterStream|Audio::overrideUnderwaterStream(p0, p1)]]
**Audio::setAmbientZoneListStatePersistent(ambientZone, p1, p2);
**[[Audio::setAmbientZoneListStatePersistent|Audio::setAmbientZoneListStatePersistent(ambientZone, p1, p2)]]
**Audio::resetPedAudioFlags(p0);
**[[Audio::resetPedAudioFlags|Audio::resetPedAudioFlags(p0)]]
**Audio::setFrontendRadioActive(active);
**[[Audio::setFrontendRadioActive|Audio::setFrontendRadioActive(active)]]
**Audio::playPedRingtone(ringtoneName, ped, p2);
**[[Audio::playPedRingtone|Audio::playPedRingtone(ringtoneName, ped, p2)]]
**Audio::hintScriptAudioBank(p0, p1);
**[[Audio::hintScriptAudioBank|Audio::hintScriptAudioBank(p0, p1)]]
**Audio::unfreezeRadioStation(radioStation);
**[[Audio::unfreezeRadioStation|Audio::unfreezeRadioStation(radioStation)]]
**Audio::hasSoundFinished(soundId);
**[[Audio::hasSoundFinished|Audio::hasSoundFinished(soundId)]]
**Audio::requestAmbientAudioBank(p0, p1);
**[[Audio::requestAmbientAudioBank|Audio::requestAmbientAudioBank(p0, p1)]]


==Brain==
==Brain==
**Brain::registerObjectScriptBrain(scriptName, p1, p2, p3, p4, p5);
**[[Brain::registerObjectScriptBrain|Brain::registerObjectScriptBrain(scriptName, p1, p2, p3, p4, p5)]]
**Brain::disableScriptBrainSet(brainSet);
**[[Brain::disableScriptBrainSet|Brain::disableScriptBrainSet(brainSet)]]
**Brain::registerWorldPointScriptBrain(p0, p1, p2);
**[[Brain::registerWorldPointScriptBrain|Brain::registerWorldPointScriptBrain(p0, p1, p2)]]
**Brain::addScriptToRandomPed(name, model, p2, p3);
**[[Brain::addScriptToRandomPed|Brain::addScriptToRandomPed(name, model, p2, p3)]]
**Brain::enableScriptBrainSet(brainSet);
**[[Brain::enableScriptBrainSet|Brain::enableScriptBrainSet(brainSet)]]
**Brain::isObjectWithinBrainActivationRange(object);
**[[Brain::isObjectWithinBrainActivationRange|Brain::isObjectWithinBrainActivationRange(object)]]


==Cam==
==Cam==
**Cam::isCamSplinePaused(p0);
**[[Cam::isCamSplinePaused|Cam::isCamSplinePaused(p0)]]
**Cam::renderScriptCams(render, ease, easeTime, p3, p4);
**[[Cam::renderScriptCams|Cam::renderScriptCams(render, ease, easeTime, p3, p4)]]
**Cam::stopGameplayCamShaking(p0);
**[[Cam::stopGameplayCamShaking|Cam::stopGameplayCamShaking(p0)]]
**Cam::setGameplayCamRawYaw(yaw);
**[[Cam::setGameplayCamRawYaw|Cam::setGameplayCamRawYaw(yaw)]]
**Cam::setCamSplineDuration(cam, timeDuration);
**[[Cam::setCamSplineDuration|Cam::setCamSplineDuration(cam, timeDuration)]]
**Cam::setGameplayEntityHint(p0, p1, p2, p3, p4, p5, p6, p7, p8);
**[[Cam::setGameplayEntityHint|Cam::setGameplayEntityHint(p0, p1, p2, p3, p4, p5, p6, p7, p8)]]
**Cam::setFollowVehicleCamZoomLevel(zoomLevel);
**[[Cam::setFollowVehicleCamZoomLevel|Cam::setFollowVehicleCamZoomLevel(zoomLevel)]]
**Cam::stopCinematicCamShaking(p0);
**[[Cam::stopCinematicCamShaking|Cam::stopCinematicCamShaking(p0)]]
**Cam::setCamSplinePhase(cam, p1);
**[[Cam::setCamSplinePhase|Cam::setCamSplinePhase(cam, p1)]]
**Cam::setGameplayPedHint(p0, x1, y1, z1, p4, p5, p6, p7);
**[[Cam::setGameplayPedHint|Cam::setGameplayPedHint(p0, x1, y1, z1, p4, p5, p6, p7)]]
**Cam::overrideCamSplineVelocity(cam, p1, p2, p3);
**[[Cam::overrideCamSplineVelocity|Cam::overrideCamSplineVelocity(cam, p1, p2, p3)]]
**Cam::setFollowPedCamCutsceneChat(p0, p1);
**[[Cam::setFollowPedCamCutsceneChat|Cam::setFollowPedCamCutsceneChat(p0, p1)]]
**Cam::setGameplayHintFov(FOV);
**[[Cam::setGameplayHintFov|Cam::setGameplayHintFov(FOV)]]
**Cam::setCinematicButtonActive(p0);
**[[Cam::setCinematicButtonActive|Cam::setCinematicButtonActive(p0)]]
**Cam::setFollowPedCamViewMode(viewMode);
**[[Cam::setFollowPedCamViewMode|Cam::setFollowPedCamViewMode(viewMode)]]
**Cam::getGameplayCamRot(p0);
**[[Cam::getGameplayCamRot|Cam::getGameplayCamRot(p0)]]
**Cam::createCamera(camHash, p1);
**[[Cam::createCamera|Cam::createCamera(camHash, p1)]]
**Cam::createCameraWithParams(camHash, posX, posY, posZ, rotX, rotY, rotZ, fov, p8, p9);
**[[Cam::createCameraWithParams|Cam::createCameraWithParams(camHash, posX, posY, posZ, rotX, rotY, rotZ, fov, p8, p9)]]
**Cam::setGameplayCamRelativePitch(x, Value2);
**[[Cam::setGameplayCamRelativePitch|Cam::setGameplayCamRelativePitch(x, Value2)]]
**Cam::createCinematicShot(p0, p1, p2, entity);
**[[Cam::createCinematicShot|Cam::createCinematicShot(p0, p1, p2, entity)]]
**Cam::setGameplayCamRawPitch(pitch);
**[[Cam::setGameplayCamRawPitch|Cam::setGameplayCamRawPitch(pitch)]]
**Cam::stopCinematicShot(p0);
**[[Cam::stopCinematicShot|Cam::stopCinematicShot(p0)]]
**Cam::overrideCamSplineMotionBlur(p0, p1, p2, p3);
**[[Cam::overrideCamSplineMotionBlur|Cam::overrideCamSplineMotionBlur(p0, p1, p2, p3)]]
**Cam::setCamEffect(p0);
**[[Cam::setCamEffect|Cam::setCamEffect(p0)]]
**Cam::getGameplayCamRot(p0);
**[[Cam::getGameplayCamRot|Cam::getGameplayCamRot(p0)]]
**Cam::setGameplayObjectHint(p0, p1, p2, p3, p4, p5, p6, p7);
**[[Cam::setGameplayObjectHint|Cam::setGameplayObjectHint(p0, p1, p2, p3, p4, p5, p6, p7)]]
**Cam::addCamSplineNode(camera, x, y, z, xRot, yRot, zRot, length, p8, p9);
**[[Cam::addCamSplineNode|Cam::addCamSplineNode(camera, x, y, z, xRot, yRot, zRot, length, p8, p9)]]
**Cam::doScreenFadeOut(duration);
**[[Cam::doScreenFadeOut|Cam::doScreenFadeOut(duration)]]
**Cam::destroyAllCams(destroy);
**[[Cam::destroyAllCams|Cam::destroyAllCams(destroy)]]
**Cam::clampGameplayCamYaw(minimum, maximum);
**[[Cam::clampGameplayCamYaw|Cam::clampGameplayCamYaw(minimum, maximum)]]
**Cam::setTimeIdleDrop(p0, p1);
**[[Cam::setTimeIdleDrop|Cam::setTimeIdleDrop(p0, p1)]]
**Cam::setGameplayVehicleHint(p0, p1, p2, p3, p4, p5, p6, p7);
**[[Cam::setGameplayVehicleHint|Cam::setGameplayVehicleHint(p0, p1, p2, p3, p4, p5, p6, p7)]]
**Cam::clampGameplayCamPitch(minimum, maximum);
**[[Cam::clampGameplayCamPitch|Cam::clampGameplayCamPitch(minimum, maximum)]]
**Cam::setGameplayCamShakeAmplitude(amplitude);
**[[Cam::setGameplayCamShakeAmplitude|Cam::setGameplayCamShakeAmplitude(amplitude)]]
**Cam::setFollowVehicleCamViewMode(viewMode);
**[[Cam::setFollowVehicleCamViewMode|Cam::setFollowVehicleCamViewMode(viewMode)]]
**Cam::getCamSplineNodeIndex(cam);
**[[Cam::getCamSplineNodeIndex|Cam::getCamSplineNodeIndex(cam)]]
**Cam::setGameplayCamRelativeHeading(heading);
**[[Cam::setGameplayCamRelativeHeading|Cam::setGameplayCamRelativeHeading(heading)]]
**Cam::createCamWithParams(camName, posX, posY, posZ, rotX, rotY, rotZ, fov, p8, p9);
**[[Cam::createCamWithParams|Cam::createCamWithParams(camName, posX, posY, posZ, rotX, rotY, rotZ, fov, p8, p9)]]
**Cam::createCam(camName, p1);
**[[Cam::createCam|Cam::createCam(camName, p1)]]
**Cam::setCinematicCamShakeAmplitude(p0);
**[[Cam::setCinematicCamShakeAmplitude|Cam::setCinematicCamShakeAmplitude(p0)]]
**Cam::isCinematicShotActive(p0);
**[[Cam::isCinematicShotActive|Cam::isCinematicShotActive(p0)]]
**Cam::doScreenFadeIn(duration);
**[[Cam::doScreenFadeIn|Cam::doScreenFadeIn(duration)]]
**Cam::setGameplayCoordHint(p0, p1, p2, p3, p4, p5, p6);
**[[Cam::setGameplayCoordHint|Cam::setGameplayCoordHint(p0, p1, p2, p3, p4, p5, p6)]]
**Cam::getCamSplineNodePhase(p0);
**[[Cam::getCamSplineNodePhase|Cam::getCamSplineNodePhase(p0)]]
**Cam::setWidescreenBorders(p0, p1);
**[[Cam::setWidescreenBorders|Cam::setWidescreenBorders(p0, p1)]]
**Cam::shakeCinematicCam(p0, p1);
**[[Cam::shakeCinematicCam|Cam::shakeCinematicCam(p0, p1)]]
**Cam::setCinematicModeActive(p0);
**[[Cam::setCinematicModeActive|Cam::setCinematicModeActive(p0)]]
**Cam::animateGameplayCamZoom(p0, distance);
**[[Cam::animateGameplayCamZoom|Cam::animateGameplayCamZoom(p0, distance)]]
**Cam::playSynchronizedCamAnim(p0, p1, animName, animDictionary);
**[[Cam::playSynchronizedCamAnim|Cam::playSynchronizedCamAnim(p0, p1, animName, animDictionary)]]
**Cam::isSphereVisible(x, y, z, radius);
**[[Cam::isSphereVisible|Cam::isSphereVisible(x, y, z, radius)]]
**Cam::getIsMultiplayerBrief(p0);
**[[Cam::getIsMultiplayerBrief|Cam::getIsMultiplayerBrief(p0)]]
**Cam::stopGameplayHint(p0);
**[[Cam::stopGameplayHint|Cam::stopGameplayHint(p0)]]
**Cam::shakeGameplayCam(shakeName, intensity);
**[[Cam::shakeGameplayCam|Cam::shakeGameplayCam(shakeName, intensity)]]


==Controls==
==Controls==
**Controls::getControlActionName(inputGroup, control, p2);
**[[Controls::getControlActionName|Controls::getControlActionName(inputGroup, control, p2)]]
**Controls::getDisabledControlNormal(inputGroup, control);
**[[Controls::getDisabledControlNormal|Controls::getDisabledControlNormal(inputGroup, control)]]
**Controls::isInputJustDisabled(inputGroup);
**[[Controls::isInputJustDisabled|Controls::isInputJustDisabled(inputGroup)]]
**Controls::isControlEnabled(inputGroup, control);
**[[Controls::isControlEnabled|Controls::isControlEnabled(inputGroup, control)]]
**Controls::isDisabledControlJustReleased(inputGroup, control);
**[[Controls::isDisabledControlJustReleased|Controls::isDisabledControlJustReleased(inputGroup, control)]]
**Controls::enableControlAction(inputGroup, control, enable);
**[[Controls::enableControlAction|Controls::enableControlAction(inputGroup, control, enable)]]
**Controls::stopPadShake(p0);
**[[Controls::stopPadShake|Controls::stopPadShake(p0)]]
**Controls::setPadShake(p0, duration, frequency);
**[[Controls::setPadShake|Controls::setPadShake(p0, duration, frequency)]]
**Controls::isControlJustReleased(inputGroup, control);
**[[Controls::isControlJustReleased|Controls::isControlJustReleased(inputGroup, control)]]
**Controls::isControlJustPressed(inputGroup, control);
**[[Controls::isControlJustPressed|Controls::isControlJustPressed(inputGroup, control)]]
**Controls::disableAllControlActions(inputGroup);
**[[Controls::disableAllControlActions|Controls::disableAllControlActions(inputGroup)]]
**Controls::isControlReleased(inputGroup, control);
**[[Controls::isControlReleased|Controls::isControlReleased(inputGroup, control)]]
**Controls::setPlayerpadShakesWhenControllerDisabled(toggle);
**[[Controls::setPlayerpadShakesWhenControllerDisabled|Controls::setPlayerpadShakesWhenControllerDisabled(toggle)]]
**Controls::isDisabledControlJustPressed(inputGroup, control);
**[[Controls::isDisabledControlJustPressed|Controls::isDisabledControlJustPressed(inputGroup, control)]]
**Controls::isInputDisabled(inputGroup);
**[[Controls::isInputDisabled|Controls::isInputDisabled(inputGroup)]]
**Controls::enableAllControlActions(inputGroup);
**[[Controls::enableAllControlActions|Controls::enableAllControlActions(inputGroup)]]
**Controls::getControlValue(inputGroup, control);
**[[Controls::getControlValue|Controls::getControlValue(inputGroup, control)]]
**Controls::isDisabledControlPressed(inputGroup, control);
**[[Controls::isDisabledControlPressed|Controls::isDisabledControlPressed(inputGroup, control)]]
**Controls::setControlNormal(inputGroup, control, amount);
**[[Controls::setControlNormal|Controls::setControlNormal(inputGroup, control, amount)]]
**Controls::getControlNormal(inputGroup, control);
**[[Controls::getControlNormal|Controls::getControlNormal(inputGroup, control)]]
**Controls::setInputExclusive(inputGroup, control);
**[[Controls::setInputExclusive|Controls::setInputExclusive(inputGroup, control)]]
**Controls::isControlPressed(inputGroup, control);
**[[Controls::isControlPressed|Controls::isControlPressed(inputGroup, control)]]
**Controls::disableControlAction(inputGroup, control, disable);
**[[Controls::disableControlAction|Controls::disableControlAction(inputGroup, control, disable)]]


==Cutscene==
==Cutscene==
**Cutscene::setCutscenePedPropVariation(cutsceneEntName, p1, p2, p3, modelHash);
**[[Cutscene::setCutscenePedPropVariation|Cutscene::setCutscenePedPropVariation(cutsceneEntName, p1, p2, p3, modelHash)]]
**Cutscene::getEntityIndexOfCutsceneEntity(cutsceneEntName, modelHash);
**[[Cutscene::getEntityIndexOfCutsceneEntity|Cutscene::getEntityIndexOfCutsceneEntity(cutsceneEntName, modelHash)]]
**Cutscene::startCutscene(p0);
**[[Cutscene::startCutscene|Cutscene::startCutscene(p0)]]
**Cutscene::startCutsceneAtCoords(x, y, z, p3);
**[[Cutscene::startCutsceneAtCoords|Cutscene::startCutsceneAtCoords(x, y, z, p3)]]
**Cutscene::hasThisCutsceneLoaded(cutsceneName);
**[[Cutscene::hasThisCutsceneLoaded|Cutscene::hasThisCutsceneLoaded(cutsceneName)]]
**Cutscene::doesCutsceneEntityExist(cutsceneEntName, modelHash);
**[[Cutscene::doesCutsceneEntityExist|Cutscene::doesCutsceneEntityExist(cutsceneEntName, modelHash)]]
**Cutscene::canSetExitStateForRegisteredEntity(cutsceneEntName, modelHash);
**[[Cutscene::canSetExitStateForRegisteredEntity|Cutscene::canSetExitStateForRegisteredEntity(cutsceneEntName, modelHash)]]
**Cutscene::canSetEnterStateForRegisteredEntity(cutsceneEntName, modelHash);
**[[Cutscene::canSetEnterStateForRegisteredEntity|Cutscene::canSetEnterStateForRegisteredEntity(cutsceneEntName, modelHash)]]
**Cutscene::requestCutscene(cutsceneName, p1);
**[[Cutscene::requestCutscene|Cutscene::requestCutscene(cutsceneName, p1)]]
**Cutscene::setCutsceneFadeValues(p0, p1, p2, p3);
**[[Cutscene::setCutsceneFadeValues|Cutscene::setCutsceneFadeValues(p0, p1, p2, p3)]]
**Cutscene::setCutsceneTriggerArea(p0, p1, p2, p3, p4, p5);
**[[Cutscene::setCutsceneTriggerArea|Cutscene::setCutsceneTriggerArea(p0, p1, p2, p3, p4, p5)]]
**Cutscene::canSetExitStateForCamera(p0);
**[[Cutscene::canSetExitStateForCamera|Cutscene::canSetExitStateForCamera(p0)]]
**Cutscene::setCutsceneOrigin(p0, p1, p2, p3, p4);
**[[Cutscene::setCutsceneOrigin|Cutscene::setCutsceneOrigin(p0, p1, p2, p3, p4)]]
**Cutscene::setCutscenePedComponentVariation(cutsceneEntName, p1, p2, p3, modelHash);
**[[Cutscene::setCutscenePedComponentVariation|Cutscene::setCutscenePedComponentVariation(cutsceneEntName, p1, p2, p3, modelHash)]]
**Cutscene::getEntityIndexOfRegisteredEntity(cutsceneEntName, modelHash);
**[[Cutscene::getEntityIndexOfRegisteredEntity|Cutscene::getEntityIndexOfRegisteredEntity(cutsceneEntName, modelHash)]]
**Cutscene::requestCutscene2(cutsceneName, p1, p2);
**[[Cutscene::requestCutscene2|Cutscene::requestCutscene2(cutsceneName, p1, p2)]]
**Cutscene::stopCutscene(p0);
**[[Cutscene::stopCutscene|Cutscene::stopCutscene(p0)]]
**Cutscene::registerEntityForCutscene(cutscenePed, cutsceneEntName, p2, modelHash, p4);
**[[Cutscene::registerEntityForCutscene|Cutscene::registerEntityForCutscene(cutscenePed, cutsceneEntName, p2, modelHash, p4)]]


==Datafile==
==Datafile==
**Datafile::objectValueGetType(objectData, key);
**[[Datafile::objectValueGetType|Datafile::objectValueGetType(objectData, key)]]
**Datafile::arrayValueGetSize(arrayData);
**[[Datafile::arrayValueGetSize|Datafile::arrayValueGetSize(arrayData)]]
**Datafile::objectValueGetFloat(objectData, key);
**[[Datafile::objectValueGetFloat|Datafile::objectValueGetFloat(objectData, key)]]
**Datafile::objectValueGetBoolean(objectData, key);
**[[Datafile::objectValueGetBoolean|Datafile::objectValueGetBoolean(objectData, key)]]
**Datafile::arrayValueAddString(arrayData, value);
**[[Datafile::arrayValueAddString|Datafile::arrayValueAddString(arrayData, value)]]
**Datafile::objectValueAddBoolean(objectData, key, value);
**[[Datafile::objectValueAddBoolean|Datafile::objectValueAddBoolean(objectData, key, value)]]
**Datafile::arrayValueGetType(arrayData, arrayIndex);
**[[Datafile::arrayValueGetType|Datafile::arrayValueGetType(arrayData, arrayIndex)]]
**Datafile::objectValueGetString(objectData, key);
**[[Datafile::objectValueGetString|Datafile::objectValueGetString(objectData, key)]]
**Datafile::arrayValueGetInteger(arrayData, arrayIndex);
**[[Datafile::arrayValueGetInteger|Datafile::arrayValueGetInteger(arrayData, arrayIndex)]]
**Datafile::arrayValueAddVector3(arrayData, valueX, valueY, valueZ);
**[[Datafile::arrayValueAddVector3|Datafile::arrayValueAddVector3(arrayData, valueX, valueY, valueZ)]]
**Datafile::objectValueGetVector3(objectData, key);
**[[Datafile::objectValueGetVector3|Datafile::objectValueGetVector3(objectData, key)]]
**Datafile::objectValueAddVector3(objectData, key, valueX, valueY, valueZ);
**[[Datafile::objectValueAddVector3|Datafile::objectValueAddVector3(objectData, key, valueX, valueY, valueZ)]]
**Datafile::arrayValueGetBoolean(arrayData, arrayIndex);
**[[Datafile::arrayValueGetBoolean|Datafile::arrayValueGetBoolean(arrayData, arrayIndex)]]
**Datafile::arrayValueAddFloat(arrayData, value);
**[[Datafile::arrayValueAddFloat|Datafile::arrayValueAddFloat(arrayData, value)]]
**Datafile::objectValueAddArray(objectData, key);
**[[Datafile::objectValueAddArray|Datafile::objectValueAddArray(objectData, key)]]
**Datafile::arrayValueAddObject(arrayData);
**[[Datafile::arrayValueAddObject|Datafile::arrayValueAddObject(arrayData)]]
**Datafile::objectValueGetInteger(objectData, key);
**[[Datafile::objectValueGetInteger|Datafile::objectValueGetInteger(objectData, key)]]
**Datafile::objectValueGetArray(objectData, key);
**[[Datafile::objectValueGetArray|Datafile::objectValueGetArray(objectData, key)]]
**Datafile::arrayValueGetObject(arrayData, arrayIndex);
**[[Datafile::arrayValueGetObject|Datafile::arrayValueGetObject(arrayData, arrayIndex)]]
**Datafile::arrayValueGetVector3(arrayData, arrayIndex);
**[[Datafile::arrayValueGetVector3|Datafile::arrayValueGetVector3(arrayData, arrayIndex)]]
**Datafile::objectValueAddString(objectData, key, value);
**[[Datafile::objectValueAddString|Datafile::objectValueAddString(objectData, key, value)]]
**Datafile::objectValueAddObject(objectData, key);
**[[Datafile::objectValueAddObject|Datafile::objectValueAddObject(objectData, key)]]
**Datafile::objectValueGetObject(objectData, key);
**[[Datafile::objectValueGetObject|Datafile::objectValueGetObject(objectData, key)]]
**Datafile::arrayValueGetFloat(arrayData, arrayIndex);
**[[Datafile::arrayValueGetFloat|Datafile::arrayValueGetFloat(arrayData, arrayIndex)]]
**Datafile::objectValueAddFloat(objectData, key, value);
**[[Datafile::objectValueAddFloat|Datafile::objectValueAddFloat(objectData, key, value)]]
**Datafile::loadUgcFile(filename);
**[[Datafile::loadUgcFile|Datafile::loadUgcFile(filename)]]
**Datafile::arrayValueAddInteger(arrayData, value);
**[[Datafile::arrayValueAddInteger|Datafile::arrayValueAddInteger(arrayData, value)]]
**Datafile::arrayValueGetString(arrayData, arrayIndex);
**[[Datafile::arrayValueGetString|Datafile::arrayValueGetString(arrayData, arrayIndex)]]
**Datafile::objectValueAddInteger(objectData, key, value);
**[[Datafile::objectValueAddInteger|Datafile::objectValueAddInteger(objectData, key, value)]]
**Datafile::arrayValueAddBoolean(arrayData, value);
**[[Datafile::arrayValueAddBoolean|Datafile::arrayValueAddBoolean(arrayData, value)]]


==Decisionevent==
==Decisionevent==
**Decisionevent::isShockingEventInSphere(type, x, y, z, radius);
**[[Decisionevent::isShockingEventInSphere|Decisionevent::isShockingEventInSphere(type, x, y, z, radius)]]
**Decisionevent::removeShockingEvent(event);
**[[Decisionevent::removeShockingEvent|Decisionevent::removeShockingEvent(event)]]
**Decisionevent::suppressShockingEventTypeNextFrame(type);
**[[Decisionevent::suppressShockingEventTypeNextFrame|Decisionevent::suppressShockingEventTypeNextFrame(type)]]
**Decisionevent::clearDecisionMakerEventResponse(name, type);
**[[Decisionevent::clearDecisionMakerEventResponse|Decisionevent::clearDecisionMakerEventResponse(name, type)]]
**Decisionevent::addShockingEventForEntity(type, entity, duration);
**[[Decisionevent::addShockingEventForEntity|Decisionevent::addShockingEventForEntity(type, entity, duration)]]
**Decisionevent::unblockDecisionMakerEvent(name, type);
**[[Decisionevent::unblockDecisionMakerEvent|Decisionevent::unblockDecisionMakerEvent(name, type)]]
**Decisionevent::addShockingEventAtPosition(type, x, y, z, duration);
**[[Decisionevent::addShockingEventAtPosition|Decisionevent::addShockingEventAtPosition(type, x, y, z, duration)]]
**Decisionevent::blockDecisionMakerEvent(name, type);
**[[Decisionevent::blockDecisionMakerEvent|Decisionevent::blockDecisionMakerEvent(name, type)]]
**Decisionevent::removeAllShockingEvents(p0);
**[[Decisionevent::removeAllShockingEvents|Decisionevent::removeAllShockingEvents(p0)]]


==Decorator==
==Decorator==
**Decorator::decorIsRegisteredAsType(propertyName, type);
**[[Decorator::decorIsRegisteredAsType|Decorator::decorIsRegisteredAsType(propertyName, type)]]
**Decorator::decorRegister(propertyName, type);
**[[Decorator::decorRegister|Decorator::decorRegister(propertyName, type)]]


==Dlc1==
==Dlc1==
**Dlc1::getPropFromOutfit(outfit, slot, item);
**[[Dlc1::getPropFromOutfit|Dlc1::getPropFromOutfit(outfit, slot, item)]]
**Dlc1::initShopPedComponent(outComponent);
**[[Dlc1::initShopPedComponent|Dlc1::initShopPedComponent(outComponent)]]
**Dlc1::getShopPedQueryComponent(componentId, outComponent);
**[[Dlc1::getShopPedQueryComponent|Dlc1::getShopPedQueryComponent(componentId, outComponent)]]
**Dlc1::getDlcVehicleData(dlcVehicleIndex, outData);
**[[Dlc1::getDlcVehicleData|Dlc1::getDlcVehicleData(dlcVehicleIndex, outData)]]
**Dlc1::getNumDlcWeaponComponents(dlcWeaponIndex);
**[[Dlc1::getNumDlcWeaponComponents|Dlc1::getNumDlcWeaponComponents(dlcWeaponIndex)]]
**Dlc1::getDlcVehicleFlags(p0);
**[[Dlc1::getDlcVehicleFlags|Dlc1::getDlcVehicleFlags(p0)]]
**Dlc1::getForcedComponent(componentHash, componentId, p2, p3, p4);
**[[Dlc1::getForcedComponent|Dlc1::getForcedComponent(componentHash, componentId, p2, p3, p4)]]
**Dlc1::getDlcWeaponComponentData(p0, p1, ComponentDataPtr);
**[[Dlc1::getDlcWeaponComponentData|Dlc1::getDlcWeaponComponentData(p0, p1, ComponentDataPtr)]]
**Dlc1::getShopPedQueryOutfit(p0, outfit);
**[[Dlc1::getShopPedQueryOutfit|Dlc1::getShopPedQueryOutfit(p0, outfit)]]
**Dlc1::getVariantComponent(componentHash, componentId, p2, p3, p4);
**[[Dlc1::getVariantComponent|Dlc1::getVariantComponent(componentHash, componentId, p2, p3, p4)]]
**Dlc1::getShopPedComponent(p0, p1);
**[[Dlc1::getShopPedComponent|Dlc1::getShopPedComponent(p0, p1)]]
**Dlc1::getDlcWeaponData(dlcWeaponIndex, outData);
**[[Dlc1::getDlcWeaponData|Dlc1::getDlcWeaponData(dlcWeaponIndex, outData)]]
**Dlc1::getNumPropsFromOutfit(character, p1, p2, p3, p4, componentId);
**[[Dlc1::getNumPropsFromOutfit|Dlc1::getNumPropsFromOutfit(character, p1, p2, p3, p4, componentId)]]
**Dlc1::getShopPedOutfit(p0, p1);
**[[Dlc1::getShopPedOutfit|Dlc1::getShopPedOutfit(p0, p1)]]
**Dlc1::getNumForcedComponents(componentHash);
**[[Dlc1::getNumForcedComponents|Dlc1::getNumForcedComponents(componentHash)]]
**Dlc1::isDlcDataEmpty(dlcData);
**[[Dlc1::isDlcDataEmpty|Dlc1::isDlcDataEmpty(dlcData)]]
**Dlc1::getShopPedQueryProp(p0, p1);
**[[Dlc1::getShopPedQueryProp|Dlc1::getShopPedQueryProp(p0, p1)]]
**Dlc1::initShopPedProp(outProp);
**[[Dlc1::initShopPedProp|Dlc1::initShopPedProp(outProp)]]
**Dlc1::getDlcVehicleModel(dlcVehicleIndex);
**[[Dlc1::getDlcVehicleModel|Dlc1::getDlcVehicleModel(dlcVehicleIndex)]]


==Dlc2==
==Dlc2==
**Dlc2::nullify(variable, unused);
**[[Dlc2::nullify|Dlc2::nullify(variable, unused)]]
**Dlc2::isDlcPresent(DlcHash);
**[[Dlc2::isDlcPresent|Dlc2::isDlcPresent(DlcHash)]]


==Entity==
==Entity==
**Entity::removeModelSwap(x, y, z, radius, originalModel, newModel, p6);
**[[Entity::removeModelSwap|Entity::removeModelSwap(x, y, z, radius, originalModel, newModel, p6)]]
**Entity::findAnimEventPhase(animDictionary, animName, p2, p3, p4);
**[[Entity::findAnimEventPhase|Entity::findAnimEventPhase(animDictionary, animName, p2, p3, p4)]]
**Entity::stopSynchronizedMapEntityAnim(p0, p1, p2, p3, p4, p5);
**[[Entity::stopSynchronizedMapEntityAnim|Entity::stopSynchronizedMapEntityAnim(p0, p1, p2, p3, p4, p5)]]
**Entity::createForcedObject(x, y, z, p3, modelHash, p5);
**[[Entity::createForcedObject|Entity::createForcedObject(x, y, z, p3, modelHash, p5)]]
**Entity::createModelHideExcludingScriptObjects(x, y, z, radius, model, p5);
**[[Entity::createModelHideExcludingScriptObjects|Entity::createModelHideExcludingScriptObjects(x, y, z, radius, model, p5)]]
**Entity::setObjectAsNoLongerNeeded(object);
**[[Entity::setObjectAsNoLongerNeeded|Entity::setObjectAsNoLongerNeeded(object)]]
**Entity::removeForcedObject(p0, p1, p2, p3, p4);
**[[Entity::removeForcedObject|Entity::removeForcedObject(p0, p1, p2, p3, p4)]]
**Entity::isAnEntity(handle);
**[[Entity::isAnEntity|Entity::isAnEntity(handle)]]
**Entity::createModelHide(x, y, z, radius, model, p5);
**[[Entity::createModelHide|Entity::createModelHide(x, y, z, radius, model, p5)]]
**Entity::createModelSwap(x, y, z, radius, originalModel, newModel, p6);
**[[Entity::createModelSwap|Entity::createModelSwap(x, y, z, radius, originalModel, newModel, p6)]]
**Entity::playSynchronizedMapEntityAnim(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
**[[Entity::playSynchronizedMapEntityAnim|Entity::playSynchronizedMapEntityAnim(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)]]
**Entity::removeModelHide(p0, p1, p2, p3, p4, p5);
**[[Entity::removeModelHide|Entity::removeModelHide(p0, p1, p2, p3, p4, p5)]]
**Entity::wouldEntityBeOccluded(hash, x, y, z, p4);
**[[Entity::wouldEntityBeOccluded|Entity::wouldEntityBeOccluded(hash, x, y, z, p4)]]
**Entity::getEntityAnimDuration(animDict, animName);
**[[Entity::getEntityAnimDuration|Entity::getEntityAnimDuration(animDict, animName)]]


==Fire==
==Fire==
**Fire::stopFireInRange(x, y, z, radius);
**[[Fire::stopFireInRange|Fire::stopFireInRange(x, y, z, radius)]]
**Fire::getPedInsideExplosionArea(explosionType, x1, y1, z1, x2, y2, z2, radius);
**[[Fire::getPedInsideExplosionArea|Fire::getPedInsideExplosionArea(explosionType, x1, y1, z1, x2, y2, z2, radius)]]
**Fire::isExplosionInArea(explosionType, x1, y1, z1, x2, y2, z2);
**[[Fire::isExplosionInArea|Fire::isExplosionInArea(explosionType, x1, y1, z1, x2, y2, z2)]]
**Fire::getClosestFirePos(outPosition, x, y, z);
**[[Fire::getClosestFirePos|Fire::getClosestFirePos(outPosition, x, y, z)]]
**Fire::addSpecfxExplosion(x, y, z, explosionType, explosionFx, damageScale, isAudible, isInvisible, cameraShake);
**[[Fire::addSpecfxExplosion|Fire::addSpecfxExplosion(x, y, z, explosionType, explosionFx, damageScale, isAudible, isInvisible, cameraShake)]]
**Fire::getNumberOfFiresInRange(x, y, z, radius);
**[[Fire::getNumberOfFiresInRange|Fire::getNumberOfFiresInRange(x, y, z, radius)]]
**Fire::startScriptFire(X, Y, Z, maxChildren, isGasFire);
**[[Fire::startScriptFire|Fire::startScriptFire(X, Y, Z, maxChildren, isGasFire)]]
**Fire::removeScriptFire(fireHandle);
**[[Fire::removeScriptFire|Fire::removeScriptFire(fireHandle)]]
**Fire::isExplosionInAngledArea(explosionType, x1, y1, z1, x2, y2, z2, angle);
**[[Fire::isExplosionInAngledArea|Fire::isExplosionInAngledArea(explosionType, x1, y1, z1, x2, y2, z2, angle)]]
**Fire::isExplosionInSphere(explosionType, x, y, z, radius);
**[[Fire::isExplosionInSphere|Fire::isExplosionInSphere(explosionType, x, y, z, radius)]]
**Fire::addExplosion(x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake);
**[[Fire::addExplosion|Fire::addExplosion(x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake)]]


==Gameplay==
==Gameplay==
**Gameplay::displayOnscreenKeyboard(p0, windowTitle, p2, defaultText, defaultConcat1, defaultConcat2, defaultConcat3, maxInputLength);
**[[Gameplay::displayOnscreenKeyboard|Gameplay::displayOnscreenKeyboard(p0, windowTitle, p2, defaultText, defaultConcat1, defaultConcat2, defaultConcat3, maxInputLength)]]
**Gameplay::clearAreaOfVehicles(x, y, z, radius, p4, p5, p6, p7, p8);
**[[Gameplay::clearAreaOfVehicles|Gameplay::clearAreaOfVehicles(x, y, z, radius, p4, p5, p6, p7, p8)]]
**Gameplay::getModelDimensions(modelHash, minimum, maximum);
**[[Gameplay::getModelDimensions|Gameplay::getModelDimensions(modelHash, minimum, maximum)]]
**Gameplay::clearAreaOfCops(x, y, z, radius, flags);
**[[Gameplay::clearAreaOfCops|Gameplay::clearAreaOfCops(x, y, z, radius, flags)]]
**Gameplay::createIncidentWithEntity(p0, p1, p2, p3, outIncident);
**[[Gameplay::createIncidentWithEntity|Gameplay::createIncidentWithEntity(p0, p1, p2, p3, outIncident)]]
**Gameplay::hasButtonCombinationJustBeenEntered(hash, amount);
**[[Gameplay::hasButtonCombinationJustBeenEntered|Gameplay::hasButtonCombinationJustBeenEntered(hash, amount)]]
**Gameplay::clearAreaOfProjectiles(x, y, z, radius, flags);
**[[Gameplay::clearAreaOfProjectiles|Gameplay::clearAreaOfProjectiles(x, y, z, radius, flags)]]
**Gameplay::areStringsEqual(string1, string2);
**[[Gameplay::areStringsEqual|Gameplay::areStringsEqual(string1, string2)]]
**Gameplay::registerEnumToSave(p0, name);
**[[Gameplay::registerEnumToSave|Gameplay::registerEnumToSave(p0, name)]]
**Gameplay::overrideSaveHouse(p0, p1, p2, p3, p4, p5, p6, p7);
**[[Gameplay::overrideSaveHouse|Gameplay::overrideSaveHouse(p0, p1, p2, p3, p4, p5, p6, p7)]]
**Gameplay::setFireAmmoThisFrame(player);
**[[Gameplay::setFireAmmoThisFrame|Gameplay::setFireAmmoThisFrame()]]
**Gameplay::clearAngledAreaOfVehicles(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
**[[Gameplay::clearAngledAreaOfVehicles|Gameplay::clearAngledAreaOfVehicles(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)]]
**Gameplay::setFakeWantedLevel(fakeWantedLevel);
**[[Gameplay::setFakeWantedLevel|Gameplay::setFakeWantedLevel(fakeWantedLevel)]]
**Gameplay::getAngleBetween2dVectors(x1, y1, x2, y2);
**[[Gameplay::getAngleBetween2dVectors|Gameplay::getAngleBetween2dVectors(x1, y1, x2, y2)]]
**Gameplay::setMinigameInProgress(toggle);
**[[Gameplay::setMinigameInProgress|Gameplay::setMinigameInProgress(toggle)]]
**Gameplay::isBulletInAngledArea(p0, p1, p2, p3, p4, p5, p6, p7);
**[[Gameplay::isBulletInAngledArea|Gameplay::isBulletInAngledArea(p0, p1, p2, p3, p4, p5, p6, p7)]]
**Gameplay::addStuntJump(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
**[[Gameplay::addStuntJump|Gameplay::addStuntJump(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16)]]
**Gameplay::acos(p0);
**[[Gameplay::acos|Gameplay::acos(p0)]]
**Gameplay::setTimeScale(time);
**[[Gameplay::setTimeScale|Gameplay::setTimeScale(time)]]
**Gameplay::setFadeOutAfterArrest(toggle);
**[[Gameplay::setFadeOutAfterArrest|Gameplay::setFadeOutAfterArrest(toggle)]]
**Gameplay::compareStrings(str1, str2, matchCase, maxLength);
**[[Gameplay::compareStrings|Gameplay::compareStrings(str1, str2, matchCase, maxLength)]]
**Gameplay::addHospitalRestart(x, y, z, p3, p4);
**[[Gameplay::addHospitalRestart|Gameplay::addHospitalRestart(x, y, z, p3, p4)]]
**Gameplay::ignoreNextRestart(toggle);
**[[Gameplay::ignoreNextRestart|Gameplay::ignoreNextRestart(toggle)]]
**Gameplay::disablePoliceRestart(policeIndex, toggle);
**[[Gameplay::disablePoliceRestart|Gameplay::disablePoliceRestart(policeIndex, toggle)]]
**Gameplay::removeDispatchSpawnBlockingArea(p0);
**[[Gameplay::removeDispatchSpawnBlockingArea|Gameplay::removeDispatchSpawnBlockingArea(p0)]]
**Gameplay::setWeatherTypeNow(weatherType);
**[[Gameplay::setWeatherTypeNow|Gameplay::setWeatherTypeNow(weatherType)]]
**Gameplay::disableAutomaticRespawn(disableRespawn);
**[[Gameplay::disableAutomaticRespawn|Gameplay::disableAutomaticRespawn(disableRespawn)]]
**Gameplay::isProjectileTypeInArea(x1, y1, z1, x2, y2, z2, type, p7);
**[[Gameplay::isProjectileTypeInArea|Gameplay::isProjectileTypeInArea(x1, y1, z1, x2, y2, z2, type, p7)]]
**Gameplay::isNextWeatherType(weatherType);
**[[Gameplay::isNextWeatherType|Gameplay::isNextWeatherType(weatherType)]]
**Gameplay::getHeadingFromVector2d(dx, dy);
**[[Gameplay::getHeadingFromVector2d|Gameplay::getHeadingFromVector2d(dx, dy)]]
**Gameplay::getRandomFloatInRange(startRange, endRange);
**[[Gameplay::getRandomFloatInRange|Gameplay::getRandomFloatInRange(startRange, endRange)]]
**Gameplay::registerIntToSave(p0, name);
**[[Gameplay::registerIntToSave|Gameplay::registerIntToSave(p0, name)]]
**Gameplay::isBulletInArea(p0, p1, p2, p3, p4);
**[[Gameplay::isBulletInArea|Gameplay::isBulletInArea(p0, p1, p2, p3, p4)]]
**Gameplay::createIncident(p0, p2, p3, p4, p5, p6, outIncident);
**[[Gameplay::createIncident|Gameplay::createIncident(p0, p2, p3, p4, p5, p6, outIncident)]]
**Gameplay::setRandomSeed(time);
**[[Gameplay::setRandomSeed|Gameplay::setRandomSeed(time)]]
**Gameplay::isPrevWeatherType(weatherType);
**[[Gameplay::isPrevWeatherType|Gameplay::isPrevWeatherType(weatherType)]]
**Gameplay::setDispatchTimeBetweenSpawnAttempts(p0, p1);
**[[Gameplay::setDispatchTimeBetweenSpawnAttempts|Gameplay::setDispatchTimeBetweenSpawnAttempts(p0, p1)]]
**Gameplay::addPoliceRestart(p0, p1, p2, p3, p4);
**[[Gameplay::addPoliceRestart|Gameplay::addPoliceRestart(p0, p1, p2, p3, p4)]]
**Gameplay::setDispatchTimeBetweenSpawnAttemptsMultiplier(p0, p1);
**[[Gameplay::setDispatchTimeBetweenSpawnAttemptsMultiplier|Gameplay::setDispatchTimeBetweenSpawnAttemptsMultiplier(p0, p1)]]
**Gameplay::setFadeOutAfterDeath(toggle);
**[[Gameplay::setFadeOutAfterDeath|Gameplay::setFadeOutAfterDeath(toggle)]]
**Gameplay::setSaveHouse(p0, p1, p2);
**[[Gameplay::setSaveHouse|Gameplay::setSaveHouse(p0, p1, p2)]]
**Gameplay::isProjectileInArea(x1, y1, z1, x2, y2, z2, ownedByPlayer);
**[[Gameplay::isProjectileInArea|Gameplay::isProjectileInArea(x1, y1, z1, x2, y2, z2, ownedByPlayer)]]
**Gameplay::getBitsInRange(var, rangeStart, rangeEnd);
**[[Gameplay::getBitsInRange|Gameplay::getBitsInRange(var, rangeStart, rangeEnd)]]
**Gameplay::deleteIncident(incidentId);
**[[Gameplay::deleteIncident|Gameplay::deleteIncident(incidentId)]]
**Gameplay::hasCheatStringJustBeenEntered(hash);
**[[Gameplay::hasCheatStringJustBeenEntered|Gameplay::hasCheatStringJustBeenEntered(hash)]]
**Gameplay::setGamePaused(toggle);
**[[Gameplay::setGamePaused|Gameplay::setGamePaused(toggle)]]
**Gameplay::setWeatherTypeTransition(sourceWeather, targetWeather, transitionTime);
**[[Gameplay::setWeatherTypeTransition|Gameplay::setWeatherTypeTransition(sourceWeather, targetWeather, transitionTime)]]
**Gameplay::setSuperJumpThisFrame(player);
**[[Gameplay::setSuperJumpThisFrame|Gameplay::setSuperJumpThisFrame()]]
**Gameplay::stringToInt(string, outInteger);
**[[Gameplay::stringToInt|Gameplay::stringToInt(string, outInteger)]]
**Gameplay::startSaveArray(p0, p1, arrayName);
**[[Gameplay::startSaveArray|Gameplay::startSaveArray(p0, p1, arrayName)]]
**Gameplay::tan(p0);
**[[Gameplay::tan|Gameplay::tan(p0)]]
**Gameplay::setRainFxIntensity(intensity);
**[[Gameplay::setRainFxIntensity|Gameplay::setRainFxIntensity(intensity)]]
**Gameplay::findSpawnPointInDirection(x1, y1, z1, x2, y2, z2, distance, spawnPoint);
**[[Gameplay::findSpawnPointInDirection|Gameplay::findSpawnPointInDirection(x1, y1, z1, x2, y2, z2, distance, spawnPoint)]]
**Gameplay::setDispatchIdealSpawnDistance(p0);
**[[Gameplay::setDispatchIdealSpawnDistance|Gameplay::setDispatchIdealSpawnDistance(p0)]]
**Gameplay::setWeatherTypePersist(weatherType);
**[[Gameplay::setWeatherTypePersist|Gameplay::setWeatherTypePersist(weatherType)]]
**Gameplay::absf(value);
**[[Gameplay::absf|Gameplay::absf(value)]]
**Gameplay::setGravityLevel(level);
**[[Gameplay::setGravityLevel|Gameplay::setGravityLevel(level)]]
**Gameplay::registerFloatToSave(p0, name);
**[[Gameplay::registerFloatToSave|Gameplay::registerFloatToSave(p0, name)]]
**Gameplay::shootSingleBulletBetweenCoords(x1, y1, z1, x2, y2, z2, damage, p7, weaponHash, ownerPed, isAudible, isInvisible, speed);
**[[Gameplay::shootSingleBulletBetweenCoords|Gameplay::shootSingleBulletBetweenCoords(x1, y1, z1, x2, y2, z2, damage, p7, weaponHash, ownerPed, isAudible, isInvisible, speed)]]
**Gameplay::atan2(p0, p1);
**[[Gameplay::atan2|Gameplay::atan2(p0, p1)]]
**Gameplay::setBitsInRange(var, rangeStart, rangeEnd, p3);
**[[Gameplay::setBitsInRange|Gameplay::setBitsInRange(var, rangeStart, rangeEnd, p3)]]
**Gameplay::setBit(address, offset);
**[[Gameplay::setBit|Gameplay::setBit(address, offset)]]
**Gameplay::clearAreaOfEverything(x, y, z, radius, p4, p5, p6, p7);
**[[Gameplay::clearAreaOfEverything|Gameplay::clearAreaOfEverything(x, y, z, radius, p4, p5, p6, p7)]]
**Gameplay::setRandomEventFlag(p0);
**[[Gameplay::setRandomEventFlag|Gameplay::setRandomEventFlag(p0)]]
**Gameplay::hasBulletImpactedInArea(p0, p1, p2, p3, p4, p5);
**[[Gameplay::hasBulletImpactedInArea|Gameplay::hasBulletImpactedInArea(p0, p1, p2, p3, p4, p5)]]
**Gameplay::enableMpDlcMaps(toggle);
**[[Gameplay::enableMpDlcMaps|Gameplay::enableMpDlcMaps(toggle)]]
**Gameplay::terminateAllScriptsWithThisName(scriptName);
**[[Gameplay::terminateAllScriptsWithThisName|Gameplay::terminateAllScriptsWithThisName(scriptName)]]
**Gameplay::setOverrideWeather(weatherType);
**[[Gameplay::setOverrideWeather|Gameplay::setOverrideWeather(weatherType)]]
**Gameplay::disableStuntJumpSet(p0);
**[[Gameplay::disableStuntJumpSet|Gameplay::disableStuntJumpSet(p0)]]
**Gameplay::clearArea(X, Y, Z, radius, p4, ignoreCopCars, ignoreObjects, p7);
**[[Gameplay::clearArea|Gameplay::clearArea(X, Y, Z, radius, p4, ignoreCopCars, ignoreObjects, p7)]]
**Gameplay::isAreaOccupied(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
**[[Gameplay::isAreaOccupied|Gameplay::isAreaOccupied(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)]]
**Gameplay::setExplosiveAmmoThisFrame(player);
**[[Gameplay::setExplosiveAmmoThisFrame|Gameplay::setExplosiveAmmoThisFrame()]]
**Gameplay::isBitSet(address, offset);
**[[Gameplay::isBitSet|Gameplay::isBitSet(address, offset)]]
**Gameplay::startSaveData(p0, p1, p2);
**[[Gameplay::startSaveData|Gameplay::startSaveData(p0, p1, p2)]]
**Gameplay::atan(p0);
**[[Gameplay::atan|Gameplay::atan(p0)]]
**Gameplay::setThisScriptCanBePaused(toggle);
**[[Gameplay::setThisScriptCanBePaused|Gameplay::setThisScriptCanBePaused(toggle)]]
**Gameplay::setWind(p0);
**[[Gameplay::setWind|Gameplay::setWind(p0)]]
**Gameplay::isPositionOccupied(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
**[[Gameplay::isPositionOccupied|Gameplay::isPositionOccupied(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)]]
**Gameplay::setCreditsActive(toggle);
**[[Gameplay::setCreditsActive|Gameplay::setCreditsActive(toggle)]]
**Gameplay::setThisScriptCanRemoveBlipsCreatedByAnyScript(toggle);
**[[Gameplay::setThisScriptCanRemoveBlipsCreatedByAnyScript|Gameplay::setThisScriptCanRemoveBlipsCreatedByAnyScript(toggle)]]
**Gameplay::addStuntJumpAngled(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
**[[Gameplay::addStuntJumpAngled|Gameplay::addStuntJumpAngled(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18)]]
**Gameplay::clearAreaOfPeds(x, y, z, radius, flags);
**[[Gameplay::clearAreaOfPeds|Gameplay::clearAreaOfPeds(x, y, z, radius, flags)]]
**Gameplay::startSaveStruct(p0, p1, structName);
**[[Gameplay::startSaveStruct|Gameplay::startSaveStruct(p0, p1, structName)]]
**Gameplay::registerSaveHouse(p0, p1, p2, p3, p4, p5, p6);
**[[Gameplay::registerSaveHouse|Gameplay::registerSaveHouse(p0, p1, p2, p3, p4, p5, p6)]]
**Gameplay::setMissionFlag(toggle);
**[[Gameplay::setMissionFlag|Gameplay::setMissionFlag(toggle)]]
**Gameplay::getProfileSetting(profileSetting);
**[[Gameplay::getProfileSetting|Gameplay::getProfileSetting(profileSetting)]]
**Gameplay::setUnkMapFlag(flag);
**[[Gameplay::setUnkMapFlag|Gameplay::setUnkMapFlag(flag)]]
**Gameplay::asin(p0);
**[[Gameplay::asin|Gameplay::asin(p0)]]
**Gameplay::disableHospitalRestart(hospitalIndex, toggle);
**[[Gameplay::disableHospitalRestart|Gameplay::disableHospitalRestart(hospitalIndex, toggle)]]
**Gameplay::isIncidentValid(incidentId);
**[[Gameplay::isIncidentValid|Gameplay::isIncidentValid(incidentId)]]
**Gameplay::registerBoolToSave(p0, name);
**[[Gameplay::registerBoolToSave|Gameplay::registerBoolToSave(p0, name)]]
**Gameplay::getGroundZFor3dCoord(x, y, z, groundZ, unk);
**[[Gameplay::getGroundZFor3dCoord|Gameplay::getGroundZFor3dCoord(x, y, z, groundZ, unk)]]
**Gameplay::setSaveMenuActive(unk);
**[[Gameplay::setSaveMenuActive|Gameplay::setSaveMenuActive(unk)]]
**Gameplay::isStringNullOrEmpty(string);
**[[Gameplay::isStringNullOrEmpty|Gameplay::isStringNullOrEmpty(string)]]
**Gameplay::getHashKey(value);
**[[Gameplay::getHashKey|Gameplay::getHashKey(value)]]
**Gameplay::getRandomIntInRange(startRange, endRange);
**[[Gameplay::getRandomIntInRange|Gameplay::getRandomIntInRange(startRange, endRange)]]
**Gameplay::setFadeInAfterDeathArrest(toggle);
**[[Gameplay::setFadeInAfterDeathArrest|Gameplay::setFadeInAfterDeathArrest(toggle)]]
**Gameplay::enableDispatchService(dispatchType, toggle);
**[[Gameplay::enableDispatchService|Gameplay::enableDispatchService(dispatchType, toggle)]]
**Gameplay::deleteStuntJump(p0);
**[[Gameplay::deleteStuntJump|Gameplay::deleteStuntJump(p0)]]
**Gameplay::hasBulletImpactedInBox(p0, p1, p2, p3, p4, p5, p6, p7);
**[[Gameplay::hasBulletImpactedInBox|Gameplay::hasBulletImpactedInBox(p0, p1, p2, p3, p4, p5, p6, p7)]]
**Gameplay::clearAreaOfObjects(x, y, z, radius, flags);
**[[Gameplay::clearAreaOfObjects|Gameplay::clearAreaOfObjects(x, y, z, radius, flags)]]
**Gameplay::isBulletInBox(p0, p1, p2, p3, p4, p5, p6);
**[[Gameplay::isBulletInBox|Gameplay::isBulletInBox(p0, p1, p2, p3, p4, p5, p6)]]
**Gameplay::beginReplayStats(p0, p1);
**[[Gameplay::beginReplayStats|Gameplay::beginReplayStats(p0, p1)]]
**Gameplay::enableStuntJumpSet(p0);
**[[Gameplay::enableStuntJumpSet|Gameplay::enableStuntJumpSet(p0)]]
**Gameplay::isPointObscuredByAMissionEntity(p0, p1, p2, p3, p4, p5, p6);
**[[Gameplay::isPointObscuredByAMissionEntity|Gameplay::isPointObscuredByAMissionEntity(p0, p1, p2, p3, p4, p5, p6)]]
**Gameplay::clearBit(address, offset);
**[[Gameplay::clearBit|Gameplay::clearBit(address, offset)]]
**Gameplay::setWindDirection(direction);
**[[Gameplay::setWindDirection|Gameplay::setWindDirection(direction)]]
**Gameplay::setWeatherTypeNowPersist(weatherType);
**[[Gameplay::setWeatherTypeNowPersist|Gameplay::setWeatherTypeNowPersist(weatherType)]]
**Gameplay::registerTextLabelToSave(p0, name);
**[[Gameplay::registerTextLabelToSave|Gameplay::registerTextLabelToSave(p0, name)]]
**Gameplay::setWindSpeed(speed);
**[[Gameplay::setWindSpeed|Gameplay::setWindSpeed(speed)]]
**Gameplay::isProjectileTypeInAngledArea(p0, p1, p2, p3, p4, p5, p6, p7, p8);
**[[Gameplay::isProjectileTypeInAngledArea|Gameplay::isProjectileTypeInAngledArea(p0, p1, p2, p3, p4, p5, p6, p7, p8)]]
**Gameplay::absi(value);
**[[Gameplay::absi|Gameplay::absi(value)]]
**Gameplay::usingMissionCreator(toggle);
**[[Gameplay::usingMissionCreator|Gameplay::usingMissionCreator(toggle)]]
**Gameplay::getDistanceBetweenCoords(x1, y1, z1, x2, y2, z2, useZ);
**[[Gameplay::getDistanceBetweenCoords|Gameplay::getDistanceBetweenCoords(x1, y1, z1, x2, y2, z2, useZ)]]
**Gameplay::isStringNull(string);
**[[Gameplay::isStringNull|Gameplay::isStringNull(string)]]
**Gameplay::getWeatherTypeTransition(p0, p1, progress_or_time);
**[[Gameplay::getWeatherTypeTransition|Gameplay::getWeatherTypeTransition(p0, p1, progress_or_time)]]
**Gameplay::setFadeInAfterLoad(toggle);
**[[Gameplay::setFadeInAfterLoad|Gameplay::setFadeInAfterLoad(toggle)]]
**Gameplay::setWeatherTypeOverTime(weatherType, time);
**[[Gameplay::setWeatherTypeOverTime|Gameplay::setWeatherTypeOverTime(weatherType, time)]]
**Gameplay::setCloudHatTransition(type, transitionTime);
**[[Gameplay::setCloudHatTransition|Gameplay::setCloudHatTransition(type, transitionTime)]]
**Gameplay::getFreeStackSlotsCount(stackSize);
**[[Gameplay::getFreeStackSlotsCount|Gameplay::getFreeStackSlotsCount(stackSize)]]
**Gameplay::isSniperBulletInArea(x1, y1, z1, x2, y2, z2);
**[[Gameplay::isSniperBulletInArea|Gameplay::isSniperBulletInArea(x1, y1, z1, x2, y2, z2)]]
**Gameplay::setExplosiveMeleeThisFrame(player);
**[[Gameplay::setExplosiveMeleeThisFrame|Gameplay::setExplosiveMeleeThisFrame()]]


==Graphics==
==Graphics==
**Graphics::createCheckpoint(type, posX1, posY1, posZ1, posX2, posY2, posZ2, radius, colorR, colorG, colorB, alpha, reserved);
**[[Graphics::createCheckpoint|Graphics::createCheckpoint(type, posX1, posY1, posZ1, posX2, posY2, posZ2, radius, colorR, colorG, colorB, alpha, reserved)]]
**Graphics::hasStreamedTextureDictLoaded(textureDict);
**[[Graphics::hasStreamedTextureDictLoaded|Graphics::hasStreamedTextureDictLoaded(textureDict)]]
**Graphics::stopScreenEffect(effectName);
**[[Graphics::stopScreenEffect|Graphics::stopScreenEffect(effectName)]]
**Graphics::drawDebugBox(x1, y1, z1, x2, y2, z2, r, g, b, alpha);
**[[Graphics::drawDebugBox|Graphics::drawDebugBox(x1, y1, z1, x2, y2, z2, r, g, b, alpha)]]
**Graphics::setFlash(p0, p1, fadeIn, duration, fadeOut);
**[[Graphics::setFlash|Graphics::setFlash(p0, p1, fadeIn, duration, fadeOut)]]
**Graphics::loadTvChannel(tvChannel);
**[[Graphics::loadTvChannel|Graphics::loadTvChannel(tvChannel)]]
**Graphics::hasNamedScaleformMovieLoaded(scaleformName);
**[[Graphics::hasNamedScaleformMovieLoaded|Graphics::hasNamedScaleformMovieLoaded(scaleformName)]]
**Graphics::startParticleFxNonLoopedOnEntity(effectName, entity, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, scale, axisX, axisY, axisZ);
**[[Graphics::startParticleFxNonLoopedOnEntity|Graphics::startParticleFxNonLoopedOnEntity(effectName, entity, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, scale, axisX, axisY, axisZ)]]
**Graphics::drawScaleformMovieFullscreen(scaleform, red, green, blue, alpha, unk);
**[[Graphics::drawScaleformMovieFullscreen|Graphics::drawScaleformMovieFullscreen(scaleform, red, green, blue, alpha, unk)]]
**Graphics::startParticleFxNonLoopedOnPedBone(effectName, ped, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, boneIndex, scale, axisX, axisY, axisZ);
**[[Graphics::startParticleFxNonLoopedOnPedBone|Graphics::startParticleFxNonLoopedOnPedBone(effectName, ped, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, boneIndex, scale, axisX, axisY, axisZ)]]
**Graphics::setTvAudioFrontend(toggle);
**[[Graphics::setTvAudioFrontend|Graphics::setTvAudioFrontend(toggle)]]
**Graphics::requestScaleformMovie(scaleformName);
**[[Graphics::requestScaleformMovie|Graphics::requestScaleformMovie(scaleformName)]]
**Graphics::setBlackout(enable);
**[[Graphics::setBlackout|Graphics::setBlackout(enable)]]
**Graphics::setTrackedPointInfo(point, x, y, z, radius);
**[[Graphics::setTrackedPointInfo|Graphics::setTrackedPointInfo(point, x, y, z, radius)]]
**Graphics::setDebugLinesAndSpheresDrawingActive(enabled);
**[[Graphics::setDebugLinesAndSpheresDrawingActive|Graphics::setDebugLinesAndSpheresDrawingActive(enabled)]]
**Graphics::setNightvision(toggle);
**[[Graphics::setNightvision|Graphics::setNightvision(toggle)]]
**Graphics::startParticleFxLoopedOnEntity(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis);
**[[Graphics::startParticleFxLoopedOnEntity|Graphics::startParticleFxLoopedOnEntity(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis)]]
**Graphics::drawScaleformMovie3dNonAdditive(scaleform, posX, posY, posZ, rotX, rotY, rotZ, p7, p8, p9, scaleX, scaleY, scaleZ, p13);
**[[Graphics::drawScaleformMovie3dNonAdditive|Graphics::drawScaleformMovie3dNonAdditive(scaleform, posX, posY, posZ, rotX, rotY, rotZ, p7, p8, p9, scaleX, scaleY, scaleZ, p13)]]
**Graphics::setScaleformMovieAsNoLongerNeeded(scaleformHandle);
**[[Graphics::setScaleformMovieAsNoLongerNeeded|Graphics::setScaleformMovieAsNoLongerNeeded(scaleformHandle)]]
**Graphics::startScreenEffect(effectName, duration, looped);
**[[Graphics::startScreenEffect|Graphics::startScreenEffect(effectName, duration, looped)]]
**Graphics::startParticleFxNonLoopedAtCoord(effectName, xPos, yPos, zPos, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis);
**[[Graphics::startParticleFxNonLoopedAtCoord|Graphics::startParticleFxNonLoopedAtCoord(effectName, xPos, yPos, zPos, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis)]]
**Graphics::setParticleFxNonLoopedColour(r, g, b);
**[[Graphics::setParticleFxNonLoopedColour|Graphics::setParticleFxNonLoopedColour(r, g, b)]]
**Graphics::drawMarker(type, posX, posY, posZ, dirX, dirY, dirZ, rotX, rotY, rotZ, scaleX, scaleY, scaleZ, colorR, colorG, colorB, alpha, bobUpAndDown, faceCamera, p19, rotate, textureDict, textureName, drawOnEnts);
**[[Graphics::drawMarker|Graphics::drawMarker(type, posX, posY, posZ, dirX, dirY, dirZ, rotX, rotY, rotZ, scaleX, scaleY, scaleZ, colorR, colorG, colorB, alpha, bobUpAndDown, faceCamera, p19, rotate, textureDict, textureName, drawOnEnts)]]
**Graphics::setTvVolume(volume);
**[[Graphics::setTvVolume|Graphics::setTvVolume(volume)]]
**Graphics::setTimecycleModifier(modifierName);
**[[Graphics::setTimecycleModifier|Graphics::setTimecycleModifier(modifierName)]]
**Graphics::getDecalWashLevel(decal);
**[[Graphics::getDecalWashLevel|Graphics::getDecalWashLevel(decal)]]
**Graphics::world3dToScreen2d(worldX, worldY, worldZ, screenX, screenY);
**[[Graphics::world3dToScreen2d|Graphics::world3dToScreen2d(worldX, worldY, worldZ, screenX, screenY)]]
**Graphics::getTextureResolution(textureDict, textureName);
**[[Graphics::getTextureResolution|Graphics::getTextureResolution(textureDict, textureName)]]
**Graphics::getScreenEffectIsActive(effectName);
**[[Graphics::getScreenEffectIsActive|Graphics::getScreenEffectIsActive(effectName)]]
**Graphics::drawDebugText(text, x, y, z, r, g, b, alpha);
**[[Graphics::drawDebugText|Graphics::drawDebugText(text, x, y, z, r, g, b, alpha)]]
**Graphics::drawRect(x, y, width, height, r, g, b, a);
**[[Graphics::drawRect|Graphics::drawRect(x, y, width, height, r, g, b, a)]]
**Graphics::setTransitionTimecycleModifier(modifierName, transition);
**[[Graphics::setTransitionTimecycleModifier|Graphics::setTransitionTimecycleModifier(modifierName, transition)]]
**Graphics::setForceVehicleTrails(toggle);
**[[Graphics::setForceVehicleTrails|Graphics::setForceVehicleTrails(toggle)]]
**Graphics::addPetrolDecal(x, y, z, groundLvl, width, transparency);
**[[Graphics::addPetrolDecal|Graphics::addPetrolDecal(x, y, z, groundLvl, width, transparency)]]
**Graphics::callScaleformMovieFunctionStringParams(scaleform, functionName, param1, param2, param3, param4, param5);
**[[Graphics::callScaleformMovieFunctionStringParams|Graphics::callScaleformMovieFunctionStringParams(scaleform, functionName, param1, param2, param3, param4, param5)]]
**Graphics::drawScaleformMovie(scaleformHandle, x, y, width, height, red, green, blue, alpha, p9);
**[[Graphics::drawScaleformMovie|Graphics::drawScaleformMovie(scaleformHandle, x, y, width, height, red, green, blue, alpha, p9)]]
**Graphics::drawSpotLightWithShadow(posX, posY, posZ, dirX, dirY, dirZ, colorR, colorG, colorB, distance, brightness, roundness, radius, falloff, shadow);
**[[Graphics::drawSpotLightWithShadow|Graphics::drawSpotLightWithShadow(posX, posY, posZ, dirX, dirY, dirZ, colorR, colorG, colorB, distance, brightness, roundness, radius, falloff, shadow)]]
**Graphics::removeDecalsInRange(x, y, z, range);
**[[Graphics::removeDecalsInRange|Graphics::removeDecalsInRange(x, y, z, range)]]
**Graphics::setParticleFxLoopedEvolution(ptfxHandle, propertyName, amount, Id);
**[[Graphics::setParticleFxLoopedEvolution|Graphics::setParticleFxLoopedEvolution(ptfxHandle, propertyName, amount, Id)]]
**Graphics::setParticleFxBloodScale(p0);
**[[Graphics::setParticleFxBloodScale|Graphics::setParticleFxBloodScale(p0)]]
**Graphics::set2dLayer(layer);
**[[Graphics::set2dLayer|Graphics::set2dLayer(layer)]]
**Graphics::drawLine(x1, y1, z1, x2, y2, z2, r, g, b, alpha);
**[[Graphics::drawLine|Graphics::drawLine(x1, y1, z1, x2, y2, z2, r, g, b, alpha)]]
**Graphics::setPtfxAssetNextCall(name);
**[[Graphics::setPtfxAssetNextCall|Graphics::setPtfxAssetNextCall(name)]]
**Graphics::setScaleformMovieToUseSystemTime(scaleform, toggle);
**[[Graphics::setScaleformMovieToUseSystemTime|Graphics::setScaleformMovieToUseSystemTime(scaleform, toggle)]]
**Graphics::startParticleFxLoopedOnEntity2(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis);
**[[Graphics::startParticleFxLoopedOnEntity2|Graphics::startParticleFxLoopedOnEntity2(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis)]]
**Graphics::setParticleFxLoopedAlpha(ptfxHandle, alpha);
**[[Graphics::setParticleFxLoopedAlpha|Graphics::setParticleFxLoopedAlpha(ptfxHandle, alpha)]]
**Graphics::drawDebugCross(x, y, z, size, r, g, b, alpha);
**[[Graphics::drawDebugCross|Graphics::drawDebugCross(x, y, z, size, r, g, b, alpha)]]
**Graphics::doesParticleFxLoopedExist(ptfxHandle);
**[[Graphics::doesParticleFxLoopedExist|Graphics::doesParticleFxLoopedExist(ptfxHandle)]]
**Graphics::setParticleFxNonLoopedAlpha(alpha);
**[[Graphics::setParticleFxNonLoopedAlpha|Graphics::setParticleFxNonLoopedAlpha(alpha)]]
**Graphics::setSeethrough(toggle);
**[[Graphics::setSeethrough|Graphics::setSeethrough(toggle)]]
**Graphics::setParticleFxLoopedColour(ptfxHandle, r, g, b, p4);
**[[Graphics::setParticleFxLoopedColour|Graphics::setParticleFxLoopedColour(ptfxHandle, r, g, b, p4)]]
**Graphics::drawDebugLine(x1, y1, z1, x2, y2, z2, r, g, b, alpha);
**[[Graphics::drawDebugLine|Graphics::drawDebugLine(x1, y1, z1, x2, y2, z2, r, g, b, alpha)]]
**Graphics::beginTextComponent(componentType);
**[[Graphics::beginTextComponent|Graphics::beginTextComponent(componentType)]]
**Graphics::setFarShadowsSuppressed(toggle);
**[[Graphics::setFarShadowsSuppressed|Graphics::setFarShadowsSuppressed(toggle)]]
**Graphics::hasScaleformContainerMovieLoadedIntoParent(scaleformHandle);
**[[Graphics::hasScaleformContainerMovieLoadedIntoParent|Graphics::hasScaleformContainerMovieLoadedIntoParent(scaleformHandle)]]
**Graphics::setTimecycleModifierStrength(strength);
**[[Graphics::setTimecycleModifierStrength|Graphics::setTimecycleModifierStrength(strength)]]
**Graphics::moveVehicleDecals(p0, p1);
**[[Graphics::moveVehicleDecals|Graphics::moveVehicleDecals(p0, p1)]]
**Graphics::hasScaleformMovieLoaded(scaleformHandle);
**[[Graphics::hasScaleformMovieLoaded|Graphics::hasScaleformMovieLoaded(scaleformHandle)]]
**Graphics::getScreenActiveResolution(x, y);
**[[Graphics::getScreenActiveResolution|Graphics::getScreenActiveResolution(x, y)]]
**Graphics::enableMovieSubtitles(toggle);
**[[Graphics::enableMovieSubtitles|Graphics::enableMovieSubtitles(toggle)]]
**Graphics::drawScaleformMovie3d(scaleform, posX, posY, posZ, rotX, rotY, rotZ, p7, p8, p9, scaleX, scaleY, scaleZ, p13);
**[[Graphics::drawScaleformMovie3d|Graphics::drawScaleformMovie3d(scaleform, posX, posY, posZ, rotX, rotY, rotZ, p7, p8, p9, scaleX, scaleY, scaleZ, p13)]]
**Graphics::getScreenResolution(x, y);
**[[Graphics::getScreenResolution|Graphics::getScreenResolution(x, y)]]
**Graphics::stopParticleFxLooped(ptfxHandle, p1);
**[[Graphics::stopParticleFxLooped|Graphics::stopParticleFxLooped(ptfxHandle, p1)]]
**Graphics::requestHudScaleform(hudComponent);
**[[Graphics::requestHudScaleform|Graphics::requestHudScaleform(hudComponent)]]
**Graphics::setParticleFxShootoutBoat(p0);
**[[Graphics::setParticleFxShootoutBoat|Graphics::setParticleFxShootoutBoat(p0)]]
**Graphics::pushScaleformMovieFunctionFromHudComponent(hudComponent, functionName);
**[[Graphics::pushScaleformMovieFunctionFromHudComponent|Graphics::pushScaleformMovieFunctionFromHudComponent(hudComponent, functionName)]]
**Graphics::washDecalsInRange(p0, p1, p2, p3, p4);
**[[Graphics::washDecalsInRange|Graphics::washDecalsInRange(p0, p1, p2, p3, p4)]]
**Graphics::enableAlienBloodVfx(toggle);
**[[Graphics::enableAlienBloodVfx|Graphics::enableAlienBloodVfx(toggle)]]
**Graphics::transitionToBlurred(transitionTime);
**[[Graphics::transitionToBlurred|Graphics::transitionToBlurred(transitionTime)]]
**Graphics::drawDebugText2d(text, x, y, z, r, g, b, alpha);
**[[Graphics::drawDebugText2d|Graphics::drawDebugText2d(text, x, y, z, r, g, b, alpha)]]
**Graphics::startParticleFxNonLoopedOnPedBone2(effectName, ped, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, boneIndex, scale, axisX, axisY, axisZ);
**[[Graphics::startParticleFxNonLoopedOnPedBone2|Graphics::startParticleFxNonLoopedOnPedBone2(effectName, ped, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, boneIndex, scale, axisX, axisY, axisZ)]]
**Graphics::removeDecalsFromObjectFacing(obj, x, y, z);
**[[Graphics::removeDecalsFromObjectFacing|Graphics::removeDecalsFromObjectFacing(obj, x, y, z)]]
**Graphics::setDrawOrigin(x, y, z, p3);
**[[Graphics::setDrawOrigin|Graphics::setDrawOrigin(x, y, z, p3)]]
**Graphics::drawDebugSphere(x, y, z, radius, r, g, b, alpha);
**[[Graphics::drawDebugSphere|Graphics::drawDebugSphere(x, y, z, radius, r, g, b, alpha)]]
**Graphics::pushScaleformMovieFunctionN(functionName);
**[[Graphics::pushScaleformMovieFunctionN|Graphics::pushScaleformMovieFunctionN(functionName)]]
**Graphics::drawPoly(x1, y1, z1, x2, y2, z2, x3, y3, z3, r, g, b, alpha);
**[[Graphics::drawPoly|Graphics::drawPoly(x1, y1, z1, x2, y2, z2, x3, y3, z3, r, g, b, alpha)]]
**Graphics::setParticleFxCamInsideNonplayerVehicle(p0, p1);
**[[Graphics::setParticleFxCamInsideNonplayerVehicle|Graphics::setParticleFxCamInsideNonplayerVehicle(p0, p1)]]
**Graphics::setForcePedFootstepsTracks(toggle);
**[[Graphics::setForcePedFootstepsTracks|Graphics::setForcePedFootstepsTracks(toggle)]]
**Graphics::destroyTrackedPoint(point);
**[[Graphics::destroyTrackedPoint|Graphics::destroyTrackedPoint(point)]]
**Graphics::addDecal(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
**[[Graphics::addDecal|Graphics::addDecal(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19)]]
**Graphics::setParticleFxLoopedScale(ptfxHandle, scale);
**[[Graphics::setParticleFxLoopedScale|Graphics::setParticleFxLoopedScale(ptfxHandle, scale)]]
**Graphics::loadMovieMeshSet(movieMeshSetName);
**[[Graphics::loadMovieMeshSet|Graphics::loadMovieMeshSet(movieMeshSetName)]]
**Graphics::setScreenDrawPosition(x, y);
**[[Graphics::setScreenDrawPosition|Graphics::setScreenDrawPosition(x, y)]]
**Graphics::pushScaleformMovieFunctionParameterString(value);
**[[Graphics::pushScaleformMovieFunctionParameterString|Graphics::pushScaleformMovieFunctionParameterString(value)]]
**Graphics::setTvChannel(channel);
**[[Graphics::setTvChannel|Graphics::setTvChannel(channel)]]
**Graphics::requestScaleformMovie3(scaleformName);
**[[Graphics::requestScaleformMovie3|Graphics::requestScaleformMovie3(scaleformName)]]
**Graphics::setStreamedTextureDictAsNoLongerNeeded(textureDict);
**[[Graphics::setStreamedTextureDictAsNoLongerNeeded|Graphics::setStreamedTextureDictAsNoLongerNeeded(textureDict)]]
**Graphics::pushScaleformMovieFunctionParameterInt(value);
**[[Graphics::pushScaleformMovieFunctionParameterInt|Graphics::pushScaleformMovieFunctionParameterInt(value)]]
**Graphics::removeParticleFx(ptfxHandle, p1);
**[[Graphics::removeParticleFx|Graphics::removeParticleFx(ptfxHandle, p1)]]
**Graphics::isTrackedPointVisible(point);
**[[Graphics::isTrackedPointVisible|Graphics::isTrackedPointVisible(point)]]
**Graphics::requestScaleformMovieInstance(scaleformName);
**[[Graphics::requestScaleformMovieInstance|Graphics::requestScaleformMovieInstance(scaleformName)]]
**Graphics::pushScaleformMovieFunctionParameterBool(value);
**[[Graphics::pushScaleformMovieFunctionParameterBool|Graphics::pushScaleformMovieFunctionParameterBool(value)]]
**Graphics::isDecalAlive(decal);
**[[Graphics::isDecalAlive|Graphics::isDecalAlive(decal)]]
**Graphics::startParticleFxLoopedOnEntityBone(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, boneIndex, scale, xAxis, yAxis, zAxis);
**[[Graphics::startParticleFxLoopedOnEntityBone|Graphics::startParticleFxLoopedOnEntityBone(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, boneIndex, scale, xAxis, yAxis, zAxis)]]
**Graphics::startParticleFxNonLoopedOnEntity2(effectName, entity, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, scale, axisX, axisY, axisZ);
**[[Graphics::startParticleFxNonLoopedOnEntity2|Graphics::startParticleFxNonLoopedOnEntity2(effectName, entity, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, scale, axisX, axisY, axisZ)]]
**Graphics::disableVehicleDistantlights(toggle);
**[[Graphics::disableVehicleDistantlights|Graphics::disableVehicleDistantlights(toggle)]]
**Graphics::setNoisinessoveride(value);
**[[Graphics::setNoisinessoveride|Graphics::setNoisinessoveride(value)]]
**Graphics::removeDecalsFromObject(obj);
**[[Graphics::removeDecalsFromObject|Graphics::removeDecalsFromObject(obj)]]
**Graphics::drawScaleformMovieFullscreenMasked(scaleform1, scaleform2, red, green, blue, alpha);
**[[Graphics::drawScaleformMovieFullscreenMasked|Graphics::drawScaleformMovieFullscreenMasked(scaleform1, scaleform2, red, green, blue, alpha)]]
**Graphics::callScaleformMovieFunctionFloatParams(scaleform, functionName, param1, param2, param3, param4, param5);
**[[Graphics::callScaleformMovieFunctionFloatParams|Graphics::callScaleformMovieFunctionFloatParams(scaleform, functionName, param1, param2, param3, param4, param5)]]
**Graphics::drawSpotLight(posX, posY, posZ, dirX, dirY, dirZ, colorR, colorG, colorB, distance, brightness, roundness, radius, falloff);
**[[Graphics::drawSpotLight|Graphics::drawSpotLight(posX, posY, posZ, dirX, dirY, dirZ, colorR, colorG, colorB, distance, brightness, roundness, radius, falloff)]]
**Graphics::drawBox(x1, y1, z1, x2, y2, z2, r, g, b, alpha);
**[[Graphics::drawBox|Graphics::drawBox(x1, y1, z1, x2, y2, z2, r, g, b, alpha)]]
**Graphics::pushScaleformMovieFunctionParameterFloat(value);
**[[Graphics::pushScaleformMovieFunctionParameterFloat|Graphics::pushScaleformMovieFunctionParameterFloat(value)]]
**Graphics::fadeDecalsInRange(p0, p1, p2, p3, p4);
**[[Graphics::fadeDecalsInRange|Graphics::fadeDecalsInRange(p0, p1, p2, p3, p4)]]
**Graphics::enableClownBloodVfx(toggle);
**[[Graphics::enableClownBloodVfx|Graphics::enableClownBloodVfx(toggle)]]
**Graphics::drawDebugLineWithTwoColours(x1, y1, z1, x2, y2, z2, r1, g1, b1, r2, g2, b2, alpha1, alpha2);
**[[Graphics::drawDebugLineWithTwoColours|Graphics::drawDebugLineWithTwoColours(x1, y1, z1, x2, y2, z2, r1, g1, b1, r2, g2, b2, alpha1, alpha2)]]
**Graphics::setParticleFxLoopedRange(ptfxHandle, range);
**[[Graphics::setParticleFxLoopedRange|Graphics::setParticleFxLoopedRange(ptfxHandle, range)]]
**Graphics::removeParticleFxInRange(X, Y, Z, radius);
**[[Graphics::removeParticleFxInRange|Graphics::removeParticleFxInRange(X, Y, Z, radius)]]
**Graphics::startParticleFxLoopedOnEntityBone2(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, boneIndex, scale, xAxis, yAxis, zAxis);
**[[Graphics::startParticleFxLoopedOnEntityBone2|Graphics::startParticleFxLoopedOnEntityBone2(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, boneIndex, scale, xAxis, yAxis, zAxis)]]
**Graphics::hasHudScaleformLoaded(hudComponent);
**[[Graphics::hasHudScaleformLoaded|Graphics::hasHudScaleformLoaded(hudComponent)]]
**Graphics::requestStreamedTextureDict(textureDict, p1);
**[[Graphics::requestStreamedTextureDict|Graphics::requestStreamedTextureDict(textureDict, p1)]]
**Graphics::setFrozenRenderingDisabled(enabled);
**[[Graphics::setFrozenRenderingDisabled|Graphics::setFrozenRenderingDisabled(enabled)]]
**Graphics::startParticleFxLoopedAtCoord(effectName, x, y, z, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis, p11);
**[[Graphics::startParticleFxLoopedAtCoord|Graphics::startParticleFxLoopedAtCoord(effectName, x, y, z, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis, p11)]]
**Graphics::sittingTv(scaleform);
**[[Graphics::sittingTv|Graphics::sittingTv(scaleform)]]
**Graphics::setNoiseoveride(toggle);
**[[Graphics::setNoiseoveride|Graphics::setNoiseoveride(toggle)]]
**Graphics::drawSprite(textureDict, textureName, screenX, screenY, scaleX, scaleY, heading, colorR, colorG, colorB, alpha);
**[[Graphics::drawSprite|Graphics::drawSprite(textureDict, textureName, screenX, screenY, scaleX, scaleY, heading, colorR, colorG, colorB, alpha)]]
**Graphics::setPtfxAssetOldToNew(oldAsset, newAsset);
**[[Graphics::setPtfxAssetOldToNew|Graphics::setPtfxAssetOldToNew(oldAsset, newAsset)]]
**Graphics::releaseMovieMeshSet(movieMeshSet);
**[[Graphics::releaseMovieMeshSet|Graphics::releaseMovieMeshSet(movieMeshSet)]]
**Graphics::removeDecal(decal);
**[[Graphics::removeDecal|Graphics::removeDecal(decal)]]
**Graphics::setParticleFxCamInsideVehicle(p0);
**[[Graphics::setParticleFxCamInsideVehicle|Graphics::setParticleFxCamInsideVehicle(p0)]]
**Graphics::callScaleformMovieFunctionMixedParams(scaleform, functionName, floatParam1, floatParam2, floatParam3, floatParam4, floatParam5, stringParam1, stringParam2, stringParam3, stringParam4, stringParam5);
**[[Graphics::callScaleformMovieFunctionMixedParams|Graphics::callScaleformMovieFunctionMixedParams(scaleform, functionName, floatParam1, floatParam2, floatParam3, floatParam4, floatParam5, stringParam1, stringParam2, stringParam3, stringParam4, stringParam5)]]
**Graphics::transitionFromBlurred(transitionTime);
**[[Graphics::transitionFromBlurred|Graphics::transitionFromBlurred(transitionTime)]]
**Graphics::getScreenAspectRatio(b);
**[[Graphics::getScreenAspectRatio|Graphics::getScreenAspectRatio(b)]]
**Graphics::startParticleFxLoopedOnPedBone(effectName, ped, xOffset, yOffset, zOffset, xRot, yRot, zRot, boneIndex, scale, xAxis, yAxis, zAxis);
**[[Graphics::startParticleFxLoopedOnPedBone|Graphics::startParticleFxLoopedOnPedBone(effectName, ped, xOffset, yOffset, zOffset, xRot, yRot, zRot, boneIndex, scale, xAxis, yAxis, zAxis)]]
**Graphics::drawLightWithRange(posX, posY, posZ, colorR, colorG, colorB, range, intensity);
**[[Graphics::drawLightWithRange|Graphics::drawLightWithRange(posX, posY, posZ, colorR, colorG, colorB, range, intensity)]]
**Graphics::drawLightWithRangeAndShadow(x, y, z, r, g, b, range, intensity, shadow);
**[[Graphics::drawLightWithRangeAndShadow|Graphics::drawLightWithRangeAndShadow(x, y, z, r, g, b, range, intensity, shadow)]]
**Graphics::startParticleFxNonLoopedAtCoord2(effectName, xPos, yPos, zPos, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis);
**[[Graphics::startParticleFxNonLoopedAtCoord2|Graphics::startParticleFxNonLoopedAtCoord2(effectName, xPos, yPos, zPos, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis)]]
**Graphics::pushScaleformMovieFunction(scaleform, functionName);
**[[Graphics::pushScaleformMovieFunction|Graphics::pushScaleformMovieFunction(scaleform, functionName)]]
**Graphics::setParticleFxLoopedOffsets(ptfxHandle, x, y, z, rotX, rotY, rotZ);
**[[Graphics::setParticleFxLoopedOffsets|Graphics::setParticleFxLoopedOffsets(ptfxHandle, x, y, z, rotX, rotY, rotZ)]]
**Graphics::callScaleformMovieMethod(scaleform, method);
**[[Graphics::callScaleformMovieMethod|Graphics::callScaleformMovieMethod(scaleform, method)]]
**Graphics::drawTvChannel(xPos, yPos, xScale, yScale, rotation, r, g, b, alpha);
**[[Graphics::drawTvChannel|Graphics::drawTvChannel(xPos, yPos, xScale, yScale, rotation, r, g, b, alpha)]]


==Interior==
==Interior==
**Interior::getInteriorAtCoordsWithType(x, y, z, interiorType);
**[[Interior::getInteriorAtCoordsWithType|Interior::getInteriorAtCoordsWithType(x, y, z, interiorType)]]
**Interior::unpinInterior(interiorID);
**[[Interior::unpinInterior|Interior::unpinInterior(interiorID)]]
**Interior::isValidInterior(interiorID);
**[[Interior::isValidInterior|Interior::isValidInterior(interiorID)]]
**Interior::isInteriorPropEnabled(interiorID, propName);
**[[Interior::isInteriorPropEnabled|Interior::isInteriorPropEnabled(interiorID, propName)]]
**Interior::addPickupToInteriorRoomByName(pickup, roomName);
**[[Interior::addPickupToInteriorRoomByName|Interior::addPickupToInteriorRoomByName(pickup, roomName)]]
**Interior::refreshInterior(interiorID);
**[[Interior::refreshInterior|Interior::refreshInterior(interiorID)]]
**Interior::disableInteriorProp(interiorID, propName);
**[[Interior::disableInteriorProp|Interior::disableInteriorProp(interiorID, propName)]]
**Interior::enableInteriorProp(interiorID, propName);
**[[Interior::enableInteriorProp|Interior::enableInteriorProp(interiorID, propName)]]
**Interior::disableInterior(interiorID, toggle);
**[[Interior::disableInterior|Interior::disableInterior(interiorID, toggle)]]
**Interior::isInteriorReady(interiorID);
**[[Interior::isInteriorReady|Interior::isInteriorReady(interiorID)]]
**Interior::isInteriorCapped(interiorID);
**[[Interior::isInteriorCapped|Interior::isInteriorCapped(interiorID)]]
**Interior::getOffsetFromInteriorInWorldCoords(interiorID, x, y, z);
**[[Interior::getOffsetFromInteriorInWorldCoords|Interior::getOffsetFromInteriorInWorldCoords(interiorID, x, y, z)]]
**Interior::hideMapObjectThisFrame(mapObjectHash);
**[[Interior::hideMapObjectThisFrame|Interior::hideMapObjectThisFrame(mapObjectHash)]]
**Interior::getInteriorAtCoords(x, y, z);
**[[Interior::getInteriorAtCoords|Interior::getInteriorAtCoords(x, y, z)]]
**Interior::isInteriorDisabled(interiorID);
**[[Interior::isInteriorDisabled|Interior::isInteriorDisabled(interiorID)]]
**Interior::capInterior(interiorID, toggle);
**[[Interior::capInterior|Interior::capInterior(interiorID, toggle)]]
**Interior::getInteriorGroupId(interiorID);
**[[Interior::getInteriorGroupId|Interior::getInteriorGroupId(interiorID)]]
**Interior::getInteriorFromCollision(x, y, z);
**[[Interior::getInteriorFromCollision|Interior::getInteriorFromCollision(x, y, z)]]
**Interior::areCoordsCollidingWithExterior(x, y, z);
**[[Interior::areCoordsCollidingWithExterior|Interior::areCoordsCollidingWithExterior(x, y, z)]]
**Interior::unkGetInteriorAtCoords(x, y, z, unk);
**[[Interior::unkGetInteriorAtCoords|Interior::unkGetInteriorAtCoords(x, y, z, unk)]]


==Itemset==
==Itemset==
**Itemset::removeFromItemset(p0, p1);
**[[Itemset::removeFromItemset|Itemset::removeFromItemset(p0, p1)]]
**Itemset::isInItemset(p0, p1);
**[[Itemset::isInItemset|Itemset::isInItemset(p0, p1)]]
**Itemset::createItemset(p0);
**[[Itemset::createItemset|Itemset::createItemset(p0)]]
**Itemset::cleanItemset(p0);
**[[Itemset::cleanItemset|Itemset::cleanItemset(p0)]]
**Itemset::getIndexedItemInItemset(p0, p1);
**[[Itemset::getIndexedItemInItemset|Itemset::getIndexedItemInItemset(p0, p1)]]
**Itemset::isItemsetValid(p0);
**[[Itemset::isItemsetValid|Itemset::isItemsetValid(p0)]]
**Itemset::getItemsetSize(p0);
**[[Itemset::getItemsetSize|Itemset::getItemsetSize(p0)]]
**Itemset::destroyItemset(p0);
**[[Itemset::destroyItemset|Itemset::destroyItemset(p0)]]
**Itemset::addToItemset(p0, p1);
**[[Itemset::addToItemset|Itemset::addToItemset(p0, p1)]]


==Mobile==
==Mobile==
**Mobile::getMobilePhoneRotation(rotation, p1);
**[[Mobile::getMobilePhoneRotation|Mobile::getMobilePhoneRotation(rotation, p1)]]
**Mobile::setPhoneLean(Toggle);
**[[Mobile::setPhoneLean|Mobile::setPhoneLean(Toggle)]]
**Mobile::getMobilePhonePosition(position);
**[[Mobile::getMobilePhonePosition|Mobile::getMobilePhonePosition(position)]]
**Mobile::setMobilePhonePosition(posX, posY, posZ);
**[[Mobile::setMobilePhonePosition|Mobile::setMobilePhonePosition(posX, posY, posZ)]]
**Mobile::moveFinger(direction);
**[[Mobile::moveFinger|Mobile::moveFinger(direction)]]
**Mobile::createMobilePhone(phoneType);
**[[Mobile::createMobilePhone|Mobile::createMobilePhone(phoneType)]]
**Mobile::getMobilePhoneRenderId(renderId);
**[[Mobile::getMobilePhoneRenderId|Mobile::getMobilePhoneRenderId(renderId)]]
**Mobile::setMobilePhoneRotation(rotX, rotY, rotZ, p3);
**[[Mobile::setMobilePhoneRotation|Mobile::setMobilePhoneRotation(rotX, rotY, rotZ, p3)]]
**Mobile::setMobilePhoneScale(scale);
**[[Mobile::setMobilePhoneScale|Mobile::setMobilePhoneScale(scale)]]
**Mobile::scriptIsMovingMobilePhoneOffscreen(toggle);
**[[Mobile::scriptIsMovingMobilePhoneOffscreen|Mobile::scriptIsMovingMobilePhoneOffscreen(toggle)]]
**Mobile::cellCamActivate(p0, p1);
**[[Mobile::cellCamActivate|Mobile::cellCamActivate(p0, p1)]]


==Object==
==Object==
**Object::createMoneyPickups(x, y, z, value, amount, model);
**[[Object::createMoneyPickups|Object::createMoneyPickups(x, y, z, value, amount, model)]]
**Object::createPortablePickup2(pickupHash, x, y, z, placeOnGround, modelHash);
**[[Object::createPortablePickup2|Object::createPortablePickup2(pickupHash, x, y, z, placeOnGround, modelHash)]]
**Object::getObjectOffsetFromCoords(xPos, yPos, zPos, heading, xOffset, yOffset, zOffset);
**[[Object::getObjectOffsetFromCoords|Object::getObjectOffsetFromCoords(xPos, yPos, zPos, heading, xOffset, yOffset, zOffset)]]
**Object::getPickupCoords(p0);
**[[Object::getPickupCoords|Object::getPickupCoords(p0)]]
**Object::removeAllPickupsOfType(p0);
**[[Object::removeAllPickupsOfType|Object::removeAllPickupsOfType(p0)]]
**Object::isPointInAngledArea(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
**[[Object::isPointInAngledArea|Object::isPointInAngledArea(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)]]
**Object::createPortablePickup(pickupHash, x, y, z, placeOnGround, modelHash);
**[[Object::createPortablePickup|Object::createPortablePickup(pickupHash, x, y, z, placeOnGround, modelHash)]]
**Object::removePickup(pickup);
**[[Object::removePickup|Object::removePickup(pickup)]]
**Object::highlightPlacementCoords(x, y, z, colorIndex);
**[[Object::highlightPlacementCoords|Object::highlightPlacementCoords(x, y, z, colorIndex)]]
**Object::isAnyObjectNearPoint(x, y, z, range, p4);
**[[Object::isAnyObjectNearPoint|Object::isAnyObjectNearPoint(x, y, z, range, p4)]]
**Object::removeDoorFromSystem(doorHash);
**[[Object::removeDoorFromSystem|Object::removeDoorFromSystem(doorHash)]]
**Object::createObject(modelHash, x, y, z, networkHandle, createHandle, dynamic);
**[[Object::createObject|Object::createObject(modelHash, x, y, z, networkHandle, createHandle, dynamic)]]
**Object::deleteObject(object);
**[[Object::deleteObject|Object::deleteObject(object)]]
**Object::setTeamPickupObject(p0, p1, p2);
**[[Object::setTeamPickupObject|Object::setTeamPickupObject(p0, p1, p2)]]
**Object::createAmbientPickup(pickupHash, posX, posY, posZ, p4, value, modelHash, p7, p8);
**[[Object::createAmbientPickup|Object::createAmbientPickup(pickupHash, posX, posY, posZ, p4, value, modelHash, p7, p8)]]
**Object::setDoorAccelerationLimit(doorHash, limit, p2, p3);
**[[Object::setDoorAccelerationLimit|Object::setDoorAccelerationLimit(doorHash, limit, p2, p3)]]
**Object::getSafePickupCoords(x, y, z, p3, p4);
**[[Object::getSafePickupCoords|Object::getSafePickupCoords(x, y, z, p3, p4)]]
**Object::addDoorToSystem(doorHash, modelHash, x, y, z, p5, p6, p7);
**[[Object::addDoorToSystem|Object::addDoorToSystem(doorHash, modelHash, x, y, z, p5, p6, p7)]]
**Object::hasClosestObjectOfTypeBeenBroken(p0, p1, p2, p3, modelHash, p5);
**[[Object::hasClosestObjectOfTypeBeenBroken|Object::hasClosestObjectOfTypeBeenBroken(p0, p1, p2, p3, modelHash, p5)]]
**Object::setPickupRegenerationTime(p0, p1);
**[[Object::setPickupRegenerationTime|Object::setPickupRegenerationTime(p0, p1)]]
**Object::hasPickupBeenCollected(p0);
**[[Object::hasPickupBeenCollected|Object::hasPickupBeenCollected(p0)]]
**Object::createPickupRotate(pickupHash, posX, posY, posZ, rotX, rotY, rotZ, flag, amount, p9, p10, modelHash);
**[[Object::createPickupRotate|Object::createPickupRotate(pickupHash, posX, posY, posZ, rotX, rotY, rotZ, flag, amount, p9, p10, modelHash)]]
**Object::isObjectNearPoint(objectHash, x, y, z, range);
**[[Object::isObjectNearPoint|Object::isObjectNearPoint(objectHash, x, y, z, range)]]
**Object::isGarageEmpty(garage, p1, p2);
**[[Object::isGarageEmpty|Object::isGarageEmpty(garage, p1, p2)]]
**Object::createObjectNoOffset(modelHash, x, y, z, networkHandle, createHandle, dynamic);
**[[Object::createObjectNoOffset|Object::createObjectNoOffset(modelHash, x, y, z, networkHandle, createHandle, dynamic)]]
**Object::doorControl(doorHash, x, y, z, locked, p5, p6, p7);
**[[Object::doorControl|Object::doorControl(doorHash, x, y, z, locked, p5, p6, p7)]]
**Object::doesPickupExist(p0);
**[[Object::doesPickupExist|Object::doesPickupExist(p0)]]
**Object::trackObjectVisibility(p0);
**[[Object::trackObjectVisibility|Object::trackObjectVisibility(p0)]]
**Object::setDoorAjarAngle(doorHash, ajar, p2, p3);
**[[Object::setDoorAjarAngle|Object::setDoorAjarAngle(doorHash, ajar, p2, p3)]]
**Object::getObjectFragmentDamageHealth(p0, p1);
**[[Object::getObjectFragmentDamageHealth|Object::getObjectFragmentDamageHealth(p0, p1)]]
**Object::doesObjectOfTypeExistAtCoords(x, y, z, radius, hash, p5);
**[[Object::doesObjectOfTypeExistAtCoords|Object::doesObjectOfTypeExistAtCoords(x, y, z, radius, hash, p5)]]
**Object::doesDoorExist(doorHash);
**[[Object::doesDoorExist|Object::doesDoorExist(doorHash)]]
**Object::isDoorClosed(door);
**[[Object::isDoorClosed|Object::isDoorClosed(door)]]
**Object::doesPickupObjectExist(p0);
**[[Object::doesPickupObjectExist|Object::doesPickupObjectExist(p0)]]
**Object::getClosestObjectOfType(x, y, z, radius, modelHash, isMission, p6, p7);
**[[Object::getClosestObjectOfType|Object::getClosestObjectOfType(x, y, z, radius, modelHash, isMission, p6, p7)]]
**Object::getStateOfClosestDoorOfType(type, x, y, z, locked, heading);
**[[Object::getStateOfClosestDoorOfType|Object::getStateOfClosestDoorOfType(type, x, y, z, locked, heading)]]
**Object::setForceObjectThisFrame(p0, p1, p2, p3);
**[[Object::setForceObjectThisFrame|Object::setForceObjectThisFrame(p0, p1, p2, p3)]]
**Object::setStateOfClosestDoorOfType(type, x, y, z, locked, heading, p6);
**[[Object::setStateOfClosestDoorOfType|Object::setStateOfClosestDoorOfType(type, x, y, z, locked, heading, p6)]]
**Object::isPickupWithinRadius(pickupHash, x, y, z, radius);
**[[Object::isPickupWithinRadius|Object::isPickupWithinRadius(pickupHash, x, y, z, radius)]]
**Object::createPickup(pickupHash, posX, posY, posZ, p4, value, p6, modelHash);
**[[Object::createPickup|Object::createPickup(pickupHash, posX, posY, posZ, p4, value, p6, modelHash)]]


==Pathfind==
==Pathfind==
**Pathfind::setRoadsBackToOriginalInAngledArea(x1, y1, z1, x2, y2, z2, p6);
**[[Pathfind::setRoadsBackToOriginalInAngledArea|Pathfind::setRoadsBackToOriginalInAngledArea(x1, y1, z1, x2, y2, z2, p6)]]
**Pathfind::getVehicleNodeProperties(x, y, z, density, flags);
**[[Pathfind::getVehicleNodeProperties|Pathfind::getVehicleNodeProperties(x, y, z, density, flags)]]
**Pathfind::updateNavmeshBlockingObject(p0, p1, p2, p3, p4, p5, p6, p7, p8);
**[[Pathfind::updateNavmeshBlockingObject|Pathfind::updateNavmeshBlockingObject(p0, p1, p2, p3, p4, p5, p6, p7, p8)]]
**Pathfind::isPointOnRoad(x, y, z, vehicle);
**[[Pathfind::isPointOnRoad|Pathfind::isPointOnRoad(x, y, z, vehicle)]]
**Pathfind::getClosestRoad(x, y, z, p3, p4, p5, p6, p7, p8, p9, p10);
**[[Pathfind::getClosestRoad|Pathfind::getClosestRoad(x, y, z, p3, p4, p5, p6, p7, p8, p9, p10)]]
**Pathfind::setRoadsInAngledArea(x1, y1, z1, x2, y2, z2, angle, unknown1, unknown2, unknown3);
**[[Pathfind::setRoadsInAngledArea|Pathfind::setRoadsInAngledArea(x1, y1, z1, x2, y2, z2, angle, unknown1, unknown2, unknown3)]]
**Pathfind::isVehicleNodeIdValid(vehicleNodeId);
**[[Pathfind::isVehicleNodeIdValid|Pathfind::isVehicleNodeIdValid(vehicleNodeId)]]
**Pathfind::setRoadsBackToOriginal(p0, p1, p2, p3, p4, p5);
**[[Pathfind::setRoadsBackToOriginal|Pathfind::setRoadsBackToOriginal(p0, p1, p2, p3, p4, p5)]]
**Pathfind::getNthClosestVehicleNodeId(x, y, z, nth, nodetype, p5, p6);
**[[Pathfind::getNthClosestVehicleNodeId|Pathfind::getNthClosestVehicleNodeId(x, y, z, nth, nodetype, p5, p6)]]
**Pathfind::getClosestVehicleNode(x, y, z, outPosition, nodeType, p5, p6);
**[[Pathfind::getClosestVehicleNode|Pathfind::getClosestVehicleNode(x, y, z, outPosition, nodeType, p5, p6)]]
**Pathfind::getClosestMajorVehicleNode(x, y, z, outPosition, unknown1, unknown2);
**[[Pathfind::getClosestMajorVehicleNode|Pathfind::getClosestMajorVehicleNode(x, y, z, outPosition, unknown1, unknown2)]]
**Pathfind::getStreetNameAtCoord(x, y, z, streetName, crossingRoad);
**[[Pathfind::getStreetNameAtCoord|Pathfind::getStreetNameAtCoord(x, y, z, streetName, crossingRoad)]]
**Pathfind::setPedPathsInArea(x1, y1, z1, x2, y2, z2, unknown);
**[[Pathfind::setPedPathsInArea|Pathfind::setPedPathsInArea(x1, y1, z1, x2, y2, z2, unknown)]]
**Pathfind::addNavmeshRequiredRegion(p0, p1, p2);
**[[Pathfind::addNavmeshRequiredRegion|Pathfind::addNavmeshRequiredRegion(p0, p1, p2)]]
**Pathfind::getNthClosestVehicleNodeFavourDirection(x, y, z, desiredX, desiredY, desiredZ, nthClosest, outPosition, outHeading, nodetype, p10, p11);
**[[Pathfind::getNthClosestVehicleNodeFavourDirection|Pathfind::getNthClosestVehicleNodeFavourDirection(x, y, z, desiredX, desiredY, desiredZ, nthClosest, outPosition, outHeading, nodetype, p10, p11)]]
**Pathfind::removeNavmeshBlockingObject(p0);
**[[Pathfind::removeNavmeshBlockingObject|Pathfind::removeNavmeshBlockingObject(p0)]]
**Pathfind::disableNavmeshInArea(p0, p1, p2, p3, p4, p5, p6);
**[[Pathfind::disableNavmeshInArea|Pathfind::disableNavmeshInArea(p0, p1, p2, p3, p4, p5, p6)]]
**Pathfind::getIsSlowRoadFlag(nodeID);
**[[Pathfind::getIsSlowRoadFlag|Pathfind::getIsSlowRoadFlag(nodeID)]]
**Pathfind::getNthClosestVehicleNodeIdWithHeading(x, y, z, nthClosest, outPosition, outHeading, p6, p7, p8);
**[[Pathfind::getNthClosestVehicleNodeIdWithHeading|Pathfind::getNthClosestVehicleNodeIdWithHeading(x, y, z, nthClosest, outPosition, outHeading, p6, p7, p8)]]
**Pathfind::getVehicleNodePosition(nodeId, outPosition);
**[[Pathfind::getVehicleNodePosition|Pathfind::getVehicleNodePosition(nodeId, outPosition)]]
**Pathfind::setIgnoreNoGpsFlag(ignore);
**[[Pathfind::setIgnoreNoGpsFlag|Pathfind::setIgnoreNoGpsFlag(ignore)]]
**Pathfind::getNthClosestVehicleNodeWithHeading(x, y, z, nthClosest, outPosition, heading, unknown1, unknown2, unknown3, unknown4);
**[[Pathfind::getNthClosestVehicleNodeWithHeading|Pathfind::getNthClosestVehicleNodeWithHeading(x, y, z, nthClosest, outPosition, heading, unknown1, unknown2, unknown3, unknown4)]]
**Pathfind::loadAllPathNodes(keepInMemory);
**[[Pathfind::loadAllPathNodes|Pathfind::loadAllPathNodes(keepInMemory)]]
**Pathfind::getRandomVehicleNode(x, y, z, radius, p4, p5, p6, outPosition, heading);
**[[Pathfind::getRandomVehicleNode|Pathfind::getRandomVehicleNode(x, y, z, radius, p4, p5, p6, outPosition, heading)]]
**Pathfind::getSupportsGpsRouteFlag(nodeID);
**[[Pathfind::getSupportsGpsRouteFlag|Pathfind::getSupportsGpsRouteFlag(nodeID)]]
**Pathfind::calculateTravelDistanceBetweenPoints(x1, y1, z1, x2, y2, z2);
**[[Pathfind::calculateTravelDistanceBetweenPoints|Pathfind::calculateTravelDistanceBetweenPoints(x1, y1, z1, x2, y2, z2)]]
**Pathfind::getSafeCoordForPed(x, y, z, onGround, outPosition, flags);
**[[Pathfind::getSafeCoordForPed|Pathfind::getSafeCoordForPed(x, y, z, onGround, outPosition, flags)]]
**Pathfind::setRoadsInArea(x1, y1, z1, x2, y2, z2, unknown1, unknown2);
**[[Pathfind::setRoadsInArea|Pathfind::setRoadsInArea(x1, y1, z1, x2, y2, z2, unknown1, unknown2)]]
**Pathfind::setGpsDisabledZone(p0, p1, p2, p3, p4, p5);
**[[Pathfind::setGpsDisabledZone|Pathfind::setGpsDisabledZone(p0, p1, p2, p3, p4, p5)]]
**Pathfind::setPedPathsBackToOriginal(p0, p1, p2, p3, p4, p5);
**[[Pathfind::setPedPathsBackToOriginal|Pathfind::setPedPathsBackToOriginal(p0, p1, p2, p3, p4, p5)]]
**Pathfind::getNthClosestVehicleNode(x, y, z, nthClosest, outPosition, unknown1, unknown2, unknown3);
**[[Pathfind::getNthClosestVehicleNode|Pathfind::getNthClosestVehicleNode(x, y, z, nthClosest, outPosition, unknown1, unknown2, unknown3)]]
**Pathfind::isNavmeshLoadedInArea(x1, y1, z1, x2, y2, z2);
**[[Pathfind::isNavmeshLoadedInArea|Pathfind::isNavmeshLoadedInArea(x1, y1, z1, x2, y2, z2)]]
**Pathfind::generateDirectionsToCoord(x, y, z, p3, p4, vehicle, p6);
**[[Pathfind::generateDirectionsToCoord|Pathfind::generateDirectionsToCoord(x, y, z, p3, p4, vehicle, p6)]]
**Pathfind::addNavmeshBlockingObject(p0, p1, p2, p3, p4, p5, p6, p7, p8);
**[[Pathfind::addNavmeshBlockingObject|Pathfind::addNavmeshBlockingObject(p0, p1, p2, p3, p4, p5, p6, p7, p8)]]
**Pathfind::getClosestVehicleNodeWithHeading(x, y, z, outPosition, outHeading, nodeType, p6, p7);
**[[Pathfind::getClosestVehicleNodeWithHeading|Pathfind::getClosestVehicleNodeWithHeading(x, y, z, outPosition, outHeading, nodeType, p6, p7)]]


==Ped==
==Ped==
**Ped::isAValidLipstickColor(colorID);
**[[Ped::isAValidLipstickColor|Ped::isAValidLipstickColor(colorID)]]
**Ped::isAnyPedNearPoint(x, y, z, radius);
**[[Ped::isAnyPedNearPoint|Ped::isAnyPedNearPoint(x, y, z, radius)]]
**Ped::setCreateRandomCops(toggle);
**[[Ped::setCreateRandomCops|Ped::setCreateRandomCops(toggle)]]
**Ped::removeActionModeAsset(asset);
**[[Ped::removeActionModeAsset|Ped::removeActionModeAsset(asset)]]
**Ped::setScenarioPedsToBeReturnedByNextCommand(value);
**[[Ped::setScenarioPedsToBeReturnedByNextCommand|Ped::setScenarioPedsToBeReturnedByNextCommand(value)]]
**Ped::isCopPedInArea3d(x1, y1, z1, x2, y2, z2);
**[[Ped::isCopPedInArea3d|Ped::isCopPedInArea3d(x1, y1, z1, x2, y2, z2)]]
**Ped::setAiWeaponDamageModifier(value);
**[[Ped::setAiWeaponDamageModifier|Ped::setAiWeaponDamageModifier(value)]]
**Ped::addScenarioBlockingArea(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
**[[Ped::addScenarioBlockingArea|Ped::addScenarioBlockingArea(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)]]
**Ped::setGroupFormationSpacing(groupId, p1, p2, p3);
**[[Ped::setGroupFormationSpacing|Ped::setGroupFormationSpacing(groupId, p1, p2, p3)]]
**Ped::isSynchronizedSceneRunning(sceneId);
**[[Ped::isSynchronizedSceneRunning|Ped::isSynchronizedSceneRunning(sceneId)]]
**Ped::attachSynchronizedSceneToEntity(sceneID, entity, boneIndex);
**[[Ped::attachSynchronizedSceneToEntity|Ped::attachSynchronizedSceneToEntity(sceneID, entity, boneIndex)]]
**Ped::setScenarioPedsSpawnInSphereArea(p0, p1, p2, p3, p4);
**[[Ped::setScenarioPedsSpawnInSphereArea|Ped::setScenarioPedsSpawnInSphereArea(p0, p1, p2, p3, p4)]]
**Ped::requestActionModeAsset(asset);
**[[Ped::requestActionModeAsset|Ped::requestActionModeAsset(asset)]]
**Ped::requestStealthModeAsset(asset);
**[[Ped::requestStealthModeAsset|Ped::requestStealthModeAsset(asset)]]
**Ped::removeScenarioBlockingArea(p0, p1);
**[[Ped::removeScenarioBlockingArea|Ped::removeScenarioBlockingArea(p0, p1)]]
**Ped::canCreateRandomPed(unk);
**[[Ped::canCreateRandomPed|Ped::canCreateRandomPed(unk)]]
**Ped::setGroupSeparationRange(groupHandle, separationRange);
**[[Ped::setGroupSeparationRange|Ped::setGroupSeparationRange(groupHandle, separationRange)]]
**Ped::createNmMessage(startImmediately, messageId);
**[[Ped::createNmMessage|Ped::createNmMessage(startImmediately, messageId)]]
**Ped::setCreateRandomCopsOnScenarios(toggle);
**[[Ped::setCreateRandomCopsOnScenarios|Ped::setCreateRandomCopsOnScenarios(toggle)]]
**Ped::getAnimInitialOffsetRotation(animDict, animName, x, y, z, xRot, yRot, zRot, p8, p9);
**[[Ped::getAnimInitialOffsetRotation|Ped::getAnimInitialOffsetRotation(animDict, animName, x, y, z, xRot, yRot, zRot, p8, p9)]]
**Ped::setScriptedConversionCoordThisFrame(x, y, z);
**[[Ped::setScriptedConversionCoordThisFrame|Ped::setScriptedConversionCoordThisFrame(x, y, z)]]
**Ped::getPedAsGroupMember(groupID, memberNumber);
**[[Ped::getPedAsGroupMember|Ped::getPedAsGroupMember(groupID, memberNumber)]]
**Ped::getPedAsGroupLeader(groupID);
**[[Ped::getPedAsGroupLeader|Ped::getPedAsGroupLeader(groupID)]]
**Ped::clearRelationshipBetweenGroups(relationship, group1, group2);
**[[Ped::clearRelationshipBetweenGroups|Ped::clearRelationshipBetweenGroups(relationship, group1, group2)]]
**Ped::getNumParentPedsOfType(type);
**[[Ped::getNumParentPedsOfType|Ped::getNumParentPedsOfType(type)]]
**Ped::isAValidBlushColor(colorID);
**[[Ped::isAValidBlushColor|Ped::isAValidBlushColor(colorID)]]
**Ped::isSynchronizedSceneLooped(sceneID);
**[[Ped::isSynchronizedSceneLooped|Ped::isSynchronizedSceneLooped(sceneID)]]
**Ped::isPedRespondingToEvent(p0, p1);
**[[Ped::isPedRespondingToEvent|Ped::isPedRespondingToEvent(p0, p1)]]
**Ped::resetGroupFormationDefaultSpacing(groupHandle);
**[[Ped::resetGroupFormationDefaultSpacing|Ped::resetGroupFormationDefaultSpacing(groupHandle)]]
**Ped::setAiMeleeWeaponDamageModifier(modifier);
**[[Ped::setAiMeleeWeaponDamageModifier|Ped::setAiMeleeWeaponDamageModifier(modifier)]]
**Ped::getFirstParentIdForPedType(type);
**[[Ped::getFirstParentIdForPedType|Ped::getFirstParentIdForPedType(type)]]
**Ped::setSynchronizedSceneOrigin(sceneID, x, y, z, roll, pitch, yaw, p7);
**[[Ped::setSynchronizedSceneOrigin|Ped::setSynchronizedSceneOrigin(sceneID, x, y, z, roll, pitch, yaw, p7)]]
**Ped::setPedAlternateWalkAnim(p0, p1, p2, p3, p4);
**[[Ped::setPedAlternateWalkAnim|Ped::setPedAlternateWalkAnim(p0, p1, p2, p3, p4)]]
**Ped::detachSynchronizedScene(sceneID);
**[[Ped::detachSynchronizedScene|Ped::detachSynchronizedScene(sceneID)]]
**Ped::isPedheadshotReady(handle);
**[[Ped::isPedheadshotReady|Ped::isPedheadshotReady(handle)]]
**Ped::setSynchronizedScenePhase(sceneID, phase);
**[[Ped::setSynchronizedScenePhase|Ped::setSynchronizedScenePhase(sceneID, phase)]]
**Ped::setScenarioPedDensityMultiplierThisFrame(p0, p1);
**[[Ped::setScenarioPedDensityMultiplierThisFrame|Ped::setScenarioPedDensityMultiplierThisFrame(p0, p1)]]
**Ped::doesGroupExist(groupId);
**[[Ped::doesGroupExist|Ped::doesGroupExist(groupId)]]
**Ped::hasPedReceivedEvent(p0, p1);
**[[Ped::hasPedReceivedEvent|Ped::hasPedReceivedEvent(p0, p1)]]
**Ped::getRandomPedAtCoord(x, y, z, xRadius, yRadius, zRadius, pedType);
**[[Ped::getRandomPedAtCoord|Ped::getRandomPedAtCoord(x, y, z, xRadius, yRadius, zRadius, pedType)]]
**Ped::clearPedAlternateWalkAnim(p0, p1);
**[[Ped::clearPedAlternateWalkAnim|Ped::clearPedAlternateWalkAnim(p0, p1)]]
**Ped::setCreateRandomCopsNotOnScenarios(toggle);
**[[Ped::setCreateRandomCopsNotOnScenarios|Ped::setCreateRandomCopsNotOnScenarios(toggle)]]
**Ped::createSynchronizedScene(x, y, z, roll, pitch, yaw, p6);
**[[Ped::createSynchronizedScene|Ped::createSynchronizedScene(x, y, z, roll, pitch, yaw, p6)]]
**Ped::getGroupSize(groupID, unknown, sizeInMembers);
**[[Ped::getGroupSize|Ped::getGroupSize(groupID, unknown, sizeInMembers)]]
**Ped::removeGroup(groupId);
**[[Ped::removeGroup|Ped::removeGroup(groupId)]]
**Ped::createGroup(unused);
**[[Ped::createGroup|Ped::createGroup(unused)]]
**Ped::removeStealthModeAsset(asset);
**[[Ped::removeStealthModeAsset|Ped::removeStealthModeAsset(asset)]]
**Ped::setPedDensityMultiplierThisFrame(multiplier);
**[[Ped::setPedDensityMultiplierThisFrame|Ped::setPedDensityMultiplierThisFrame(multiplier)]]
**Ped::getRelationshipBetweenGroups(group1, group2);
**[[Ped::getRelationshipBetweenGroups|Ped::getRelationshipBetweenGroups(group1, group2)]]
**Ped::getTattooZone(collection, overlay);
**[[Ped::getTattooZone|Ped::getTattooZone(collection, overlay)]]
**Ped::isPedheadshotValid(handle);
**[[Ped::isPedheadshotValid|Ped::isPedheadshotValid(handle)]]
**Ped::isAnyPedShootingInArea(x1, y1, z1, x2, y2, z2, p6, p7);
**[[Ped::isAnyPedShootingInArea|Ped::isAnyPedShootingInArea(x1, y1, z1, x2, y2, z2, p6, p7)]]
**Ped::createRandomPed(posX, posY, posZ);
**[[Ped::createRandomPed|Ped::createRandomPed(posX, posY, posZ)]]
**Ped::removeRelationshipGroup(groupHash);
**[[Ped::removeRelationshipGroup|Ped::removeRelationshipGroup(groupHash)]]
**Ped::setSynchronizedSceneRate(sceneID, rate);
**[[Ped::setSynchronizedSceneRate|Ped::setSynchronizedSceneRate(sceneID, rate)]]
**Ped::getAnimInitialOffsetPosition(animDict, animName, x, y, z, xRot, yRot, zRot, p8, p9);
**[[Ped::getAnimInitialOffsetPosition|Ped::getAnimInitialOffsetPosition(animDict, animName, x, y, z, xRot, yRot, zRot, p8, p9)]]
**Ped::setRelationshipBetweenGroups(relationship, group1, group2);
**[[Ped::setRelationshipBetweenGroups|Ped::setRelationshipBetweenGroups(relationship, group1, group2)]]
**Ped::getClosestPed(x, y, z, radius, p4, p5, outPed, p7, p8, pedType);
**[[Ped::getClosestPed|Ped::getClosestPed(x, y, z, radius, p4, p5, outPed, p7, p8, pedType)]]
**Ped::disposeSynchronizedScene(scene);
**[[Ped::disposeSynchronizedScene|Ped::disposeSynchronizedScene(scene)]]
**Ped::setGroupFormation(groupId, formationType);
**[[Ped::setGroupFormation|Ped::setGroupFormation(groupId, formationType)]]
**Ped::getNumHeadOverlayValues(overlayID);
**[[Ped::getNumHeadOverlayValues|Ped::getNumHeadOverlayValues(overlayID)]]
**Ped::createPed(pedType, modelHash, x, y, z, heading, networkHandle, pedHandle);
**[[Ped::createPed|Ped::createPed(pedType, modelHash, x, y, z, heading, networkHandle, pedHandle)]]
**Ped::setPedToRagdollWithFall(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
**[[Ped::setPedToRagdollWithFall|Ped::setPedToRagdollWithFall(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)]]
**Ped::getSynchronizedSceneRate(sceneID);
**[[Ped::getSynchronizedSceneRate|Ped::getSynchronizedSceneRate(sceneID)]]
**Ped::setSynchronizedSceneLooped(sceneID, toggle);
**[[Ped::setSynchronizedSceneLooped|Ped::setSynchronizedSceneLooped(sceneID, toggle)]]
**Ped::getPedheadshotTxdString(handle);
**[[Ped::getPedheadshotTxdString|Ped::getPedheadshotTxdString(handle)]]
**Ped::isAValidHairColor(colorID);
**[[Ped::isAValidHairColor|Ped::isAValidHairColor(colorID)]]
**Ped::getSynchronizedScenePhase(sceneID);
**[[Ped::getSynchronizedScenePhase|Ped::getSynchronizedScenePhase(sceneID)]]
**Ped::hasActionModeAssetLoaded(asset);
**[[Ped::hasActionModeAssetLoaded|Ped::hasActionModeAssetLoaded(asset)]]
**Ped::setPedReserveParachuteTintIndex(p0, p1);
**[[Ped::setPedReserveParachuteTintIndex|Ped::setPedReserveParachuteTintIndex(p0, p1)]]
**Ped::hasStealthModeAssetLoaded(asset);
**[[Ped::hasStealthModeAssetLoaded|Ped::hasStealthModeAssetLoaded(asset)]]
**Ped::setPedNonCreationArea(x1, y1, z1, x2, y2, z2);
**[[Ped::setPedNonCreationArea|Ped::setPedNonCreationArea(x1, y1, z1, x2, y2, z2)]]
**Ped::addRelationshipGroup(name, groupHash);
**[[Ped::addRelationshipGroup|Ped::addRelationshipGroup(name, groupHash)]]
**Ped::setTimeExclusiveDisplayTexture(p0, p1);
**[[Ped::setTimeExclusiveDisplayTexture|Ped::setTimeExclusiveDisplayTexture(p0, p1)]]


==Player==
==Player==
**Player::setModel(model);
**[[Player::setPlayerModel|Player::setPlayerModel(model)]]
**Player::setWantedLevelMultiplier(multiplier);
**[[Player::setWantedLevelMultiplier|Player::setWantedLevelMultiplier(multiplier)]]
**Player::setTeam(team);
**[[Player::setPlayerTeam|Player::setPlayerTeam(team)]]
**Player::changePed(ped, b2, b3);
**[[Player::changePlayerPed|Player::changePlayerPed(pedb2b3)]]
**Player::setAllRandomPedsFlee(toggle);
**[[Player::setAllRandomPedsFlee|Player::setAllRandomPedsFlee(toggle)]]
**Player::isSpecialAbilityMeterFull();
**[[Player::isSpecialAbilityMeterFull|Player::isSpecialAbilityMeterFull()]]
**Player::getWantedLevelRadius();
**[[Player::getWantedLevelRadius|Player::getWantedLevelRadius()]]
**Player::areStarsGreyedOut();
**[[Player::arePlayerStarsGreyedOut|Player::arePlayerStarsGreyedOut()]]
**Player::getWantedCentrePosition();
**[[Player::getPlayerWantedCentrePosition|Player::getPlayerWantedCentrePosition()]]
**Player::getGroup();
**[[Player::getPlayerGroup|Player::getPlayerGroup()]]
**Player::clearParachuteVariationOverride();
**[[Player::clearPlayerParachuteVariationOverride|Player::clearPlayerParachuteVariationOverride()]]
**Player::setForcedAim(toggle);
**[[Player::setPlayerForcedAim|Player::setPlayerForcedAim(toggle)]]
**Player::clearParachutePackModelOverride();
**[[Player::clearPlayerParachutePackModelOverride|Player::clearPlayerParachutePackModelOverride()]]
**Player::setResetFlagPreferRearSeats(flags);
**[[Player::setPlayerResetFlagPreferRearSeats|Player::setPlayerResetFlagPreferRearSeats(flags)]]
**Player::getTargetEntity(entity);
**[[Player::getPlayerTargetEntity|Player::getPlayerTargetEntity(entity)]]
**Player::setClothLockCounter(value);
**[[Player::setPlayerClothLockCounter|Player::setPlayerClothLockCounter(value)]]
**Player::enableSpecialAbility(toggle);
**[[Player::enableSpecialAbility|Player::enableSpecialAbility(toggle)]]
**Player::getSprintTimeRemaining();
**[[Player::getPlayerSprintTimeRemaining|Player::getPlayerSprintTimeRemaining()]]
**Player::resetInputGait();
**[[Player::resetPlayerInputGait|Player::resetPlayerInputGait()]]
**Player::specialAbilityDepleteMeter(p1);
**[[Player::specialAbilityDepleteMeter|Player::specialAbilityDepleteMeter(p1)]]
**Player::setMayNotEnterAnyVehicle();
**[[Player::setPlayerMayNotEnterAnyVehicle|Player::setPlayerMayNotEnterAnyVehicle()]]
**Player::hasDamagedAtLeastOnePed();
**[[Player::hasPlayerDamagedAtLeastOnePed|Player::hasPlayerDamagedAtLeastOnePed()]]
**Player::isWantedLevelGreater(wantedLevel);
**[[Player::isPlayerWantedLevelGreater|Player::isPlayerWantedLevelGreater(wantedLevel)]]
**Player::setInvincible(toggle);
**[[Player::setPlayerInvincible|Player::setPlayerInvincible(toggle)]]
**Player::getEntityIsFreeAimingAt(entity);
**[[Player::getEntityPlayerIsFreeAimingAt|Player::getEntityPlayerIsFreeAimingAt(entity)]]
**Player::setLockonRangeOverride(range);
**[[Player::setPlayerLockonRangeOverride|Player::setPlayerLockonRangeOverride(range)]]
**Player::resetArrestState();
**[[Player::resetPlayerArrestState|Player::resetPlayerArrestState()]]
**Player::setWeaponDefenseModifier(modifier);
**[[Player::setPlayerWeaponDefenseModifier|Player::setPlayerWeaponDefenseModifier(modifier)]]
**Player::isFreeAiming();
**[[Player::isPlayerFreeAiming|Player::isPlayerFreeAiming()]]
**Player::specialAbilityChargeSmall(p1, p2);
**[[Player::specialAbilityChargeSmall|Player::specialAbilityChargeSmall(p1p2)]]
**Player::setDisableAmbientMeleeMove(toggle);
**[[Player::setDisableAmbientMeleeMove|Player::setDisableAmbientMeleeMove(toggle)]]
**Player::getCurrentStealthNoise();
**[[Player::getPlayerCurrentStealthNoise|Player::getPlayerCurrentStealthNoise()]]
**Player::setPoliceIgnore(toggle);
**[[Player::setPoliceIgnorePlayer|Player::setPoliceIgnorePlayer(toggle)]]
**Player::setWantedLevelNoDrop(wantedLevelp2);
**[[Player::setPlayerWantedLevelNoDrop|Player::setPlayerWantedLevelNoDrop(wantedLevelp2)]]
**Player::getTeam();
**[[Player::getPlayerTeam|Player::getPlayerTeam()]]
**Player::specialAbilityReset();
**[[Player::specialAbilityReset|Player::specialAbilityReset()]]
**Player::isBeingArrested(atArresting);
**[[Player::isPlayerBeingArrested|Player::isPlayerBeingArrested(atArresting)]]
**Player::setWantedLevel(wantedLevel, disableNoMission);
**[[Player::setPlayerWantedLevel|Player::setPlayerWantedLevel(wantedLeveldisableNoMission)]]
**Player::isFreeAimingAtEntity(entity);
**[[Player::isPlayerFreeAimingAtEntity|Player::isPlayerFreeAimingAtEntity(entity)]]
**Player::giveRagdollControl(toggle);
**[[Player::givePlayerRagdollControl|Player::givePlayerRagdollControl(toggle)]]
**Player::specialAbilityFillMeter(p1);
**[[Player::specialAbilityFillMeter|Player::specialAbilityFillMeter(p1)]]
**Player::isSpecialAbilityActive();
**[[Player::isSpecialAbilityActive|Player::isSpecialAbilityActive()]]
**Player::getSprintStaminaRemaining();
**[[Player::getPlayerSprintStaminaRemaining|Player::getPlayerSprintStaminaRemaining()]]
**Player::intToindex(value);
**[[Player::intToPlayerindex|Player::intToPlayerindex(value)]]
**Player::isDead();
**[[Player::isPlayerDead|Player::isPlayerDead()]]
**Player::setPoliceRadarBlips(toggle);
**[[Player::setPoliceRadarBlips|Player::setPoliceRadarBlips(toggle)]]
**Player::getPed();
**[[Player::getPlayerPed|Player::getPlayerPed()]]
**Player::setAllRandomPedsFleeThisFrame();
**[[Player::setAllRandomPedsFleeThisFrame|Player::setAllRandomPedsFleeThisFrame()]]
**Player::simulateInputGait(amount, gaitType, speed, p4, p5);
**[[Player::simulatePlayerInputGait|Player::simulatePlayerInputGait(amountgaitTypespeedp4p5)]]
**Player::isControlOn();
**[[Player::isPlayerControlOn|Player::isPlayerControlOn()]]
**Player::setMeleeWeaponDamageModifier(modifier);
**[[Player::setPlayerMeleeWeaponDamageModifier|Player::setPlayerMeleeWeaponDamageModifier(modifier)]]
**Player::clearHasDamagedAtLeastOneNonAnimalPed();
**[[Player::clearPlayerHasDamagedAtLeastOneNonAnimalPed|Player::clearPlayerHasDamagedAtLeastOneNonAnimalPed()]]
**Player::setVehicleDefenseModifier(modifier);
**[[Player::setPlayerVehicleDefenseModifier|Player::setPlayerVehicleDefenseModifier(modifier)]]
**Player::forceCleanupForAllThreadsWithThisName(name, cleanupFlags);
**[[Player::forceCleanupForAllThreadsWithThisName|Player::forceCleanupForAllThreadsWithThisName(name, cleanupFlags)]]
**Player::setStealthPerceptionModifier(value);
**[[Player::setPlayerStealthPerceptionModifier|Player::setPlayerStealthPerceptionModifier(value)]]
**Player::isRidingTrain();
**[[Player::isPlayerRidingTrain|Player::isPlayerRidingTrain()]]
**Player::getPedScriptIndex();
**[[Player::getPlayerPedScriptIndex|Player::getPlayerPedScriptIndex()]]
**Player::setWantedCentrePosition(xyz);
**[[Player::setPlayerWantedCentrePosition|Player::setPlayerWantedCentrePosition(xyz)]]
**Player::setIgnoreLowPriorityShockingEvents(toggle);
**[[Player::setIgnoreLowPriorityShockingEvents|Player::setIgnoreLowPriorityShockingEvents(toggle)]]
**Player::setLockon(toggle);
**[[Player::setPlayerLockon|Player::setPlayerLockon(toggle)]]
**Player::getTimeSinceHitVehicle();
**[[Player::getTimeSincePlayerHitVehicle|Player::getTimeSincePlayerHitVehicle()]]
**Player::setHealthRechargeMultiplier(regenRate);
**[[Player::setPlayerHealthRechargeMultiplier|Player::setPlayerHealthRechargeMultiplier(regenRate)]]
**Player::getHasReserveParachute();
**[[Player::getPlayerHasReserveParachute|Player::getPlayerHasReserveParachute()]]
**Player::disableFiring(toggle);
**[[Player::disablePlayerFiring|Player::disablePlayerFiring(toggle)]]
**Player::isPlaying();
**[[Player::isPlayerPlaying|Player::isPlayerPlaying()]]
**Player::specialAbilityLock(playerModel);
**[[Player::specialAbilityLock|Player::specialAbilityLock(playerModel)]]
**Player::getName();
**[[Player::getPlayerName|Player::getPlayerName()]]
**Player::setRunSprintMultiplierFor(multiplier);
**[[Player::setRunSprintMultiplierForPlayer|Player::setRunSprintMultiplierForPlayer(multiplier)]]
**Player::setCanDoDriveBy(toggle);
**[[Player::setPlayerCanDoDriveBy|Player::setPlayerCanDoDriveBy(toggle)]]
**Player::getParachutePackTintIndex(tintIndex);
**[[Player::getPlayerParachutePackTintIndex|Player::getPlayerParachutePackTintIndex(tintIndex)]]
**Player::setClothPinFrames(toggle);
**[[Player::setPlayerClothPinFrames|Player::setPlayerClothPinFrames(toggle)]]
**Player::getParachuteTintIndex(tintIndex);
**[[Player::getPlayerParachuteTintIndex|Player::getPlayerParachuteTintIndex(tintIndex)]]
**Player::setForcedZoom(toggle);
**[[Player::setPlayerForcedZoom|Player::setPlayerForcedZoom(toggle)]]
**Player::setForceSkipAimIntro(toggle);
**[[Player::setPlayerForceSkipAimIntro|Player::setPlayerForceSkipAimIntro(toggle)]]
**Player::setMaxArmour(value);
**[[Player::setPlayerMaxArmour|Player::setPlayerMaxArmour(value)]]
**Player::isTargettingAnything();
**[[Player::isPlayerTargettingAnything|Player::isPlayerTargettingAnything()]]
**Player::isTargettingEntity(entity);
**[[Player::isPlayerTargettingEntity|Player::isPlayerTargettingEntity(entity)]]
**Player::setHasReserveParachute();
**[[Player::setPlayerHasReserveParachute|Player::setPlayerHasReserveParachute()]]
**Player::setMayOnlyEnterThisVehicle(vehicle);
**[[Player::setPlayerMayOnlyEnterThisVehicle|Player::setPlayerMayOnlyEnterThisVehicle(vehicle)]]
**Player::setParachuteSmokeTrailColor(r, g, b);
**[[Player::setPlayerParachuteSmokeTrailColor|Player::setPlayerParachuteSmokeTrailColor(rgb)]]
**Player::hasAchievementBeenPassed(achievement);
**[[Player::hasAchievementBeenPassed|Player::hasAchievementBeenPassed(achievement)]]
**Player::clearParachuteModelOverride();
**[[Player::clearPlayerParachuteModelOverride|Player::clearPlayerParachuteModelOverride()]]
**Player::isScriptControlOn();
**[[Player::isPlayerScriptControlOn|Player::isPlayerScriptControlOn()]]
**Player::setControl(togglepossiblyFlags);
**[[Player::setPlayerControl|Player::setPlayerControl(togglepossiblyFlags)]]
**Player::setEveryoneIgnore(toggle);
**[[Player::setEveryoneIgnorePlayer|Player::setEveryoneIgnorePlayer(toggle)]]
**Player::isReadyForCutscene();
**[[Player::isPlayerReadyForCutscene|Player::isPlayerReadyForCutscene()]]
**Player::getMaxArmour();
**[[Player::getPlayerMaxArmour|Player::getPlayerMaxArmour()]]
**Player::setParachutePackTintIndex(tintIndex);
**[[Player::setPlayerParachutePackTintIndex|Player::setPlayerParachutePackTintIndex(tintIndex)]]
**Player::displaySystemSigninUi(unk);
**[[Player::displaySystemSigninUi|Player::displaySystemSigninUi(unk)]]
**Player::isClimbing();
**[[Player::isPlayerClimbing|Player::isPlayerClimbing()]]
**Player::setParachuteModelOverride(model);
**[[Player::setPlayerParachuteModelOverride|Player::setPlayerParachuteModelOverride(model)]]
**Player::reserveEntityExplodesOnHighExplosionCombo(p1);
**[[Player::reserveEntityExplodesOnHighExplosionCombo|Player::reserveEntityExplodesOnHighExplosionCombo(p1)]]
**Player::setWantedLevelDifficulty(difficulty);
**[[Player::setWantedLevelDifficulty|Player::setWantedLevelDifficulty(difficulty)]]
**Player::specialAbilityDeactivateFast();
**[[Player::specialAbilityDeactivateFast|Player::specialAbilityDeactivateFast()]]
**Player::intToParticipantindex(value);
**[[Player::intToParticipantindex|Player::intToParticipantindex(value)]]
**Player::setAutoGiveParachuteWhenEnterPlane(toggle);
**[[Player::setAutoGiveParachuteWhenEnterPlane|Player::setAutoGiveParachuteWhenEnterPlane(toggle)]]
**Player::setClothPackageIndex(index);
**[[Player::setPlayerClothPackageIndex|Player::setPlayerClothPackageIndex(index)]]
**Player::setSprint(toggle);
**[[Player::setPlayerSprint|Player::setPlayerSprint(toggle)]]
**Player::specialAbilityChargeNormalized(normalizedValue, p2);
**[[Player::specialAbilityChargeNormalized|Player::specialAbilityChargeNormalized(normalizedValuep2)]]
**Player::getUnderwaterTimeRemaining();
**[[Player::getPlayerUnderwaterTimeRemaining|Player::getPlayerUnderwaterTimeRemaining()]]
**Player::restoreStamina(p1);
**[[Player::restorePlayerStamina|Player::restorePlayerStamina(p1)]]
**Player::setParachuteTintIndex(tintIndex);
**[[Player::setPlayerParachuteTintIndex|Player::setPlayerParachuteTintIndex(tintIndex)]]
**Player::setSpecialAbilityMultiplier(multiplier);
**[[Player::setSpecialAbilityMultiplier|Player::setSpecialAbilityMultiplier(multiplier)]]
**Player::setVehicleDamageModifier(damageAmount);
**[[Player::setPlayerVehicleDamageModifier|Player::setPlayerVehicleDamageModifier(damageAmount)]]
**Player::resetStamina();
**[[Player::resetPlayerStamina|Player::resetPlayerStamina()]]
**Player::setSwimMultiplierFor(multiplier);
**[[Player::setSwimMultiplierForPlayer|Player::setSwimMultiplierForPlayer(multiplier)]]
**Player::setMaxWantedLevel(maxWantedLevel);
**[[Player::setMaxWantedLevel|Player::setMaxWantedLevel(maxWantedLevel)]]
**Player::startTeleport(x, y, z, heading, p5, p6, p7);
**[[Player::startPlayerTeleport|Player::startPlayerTeleport(xyzheadingp5p6p7)]]
**Player::setMeleeWeaponDefenseModifier(modifier);
**[[Player::setPlayerMeleeWeaponDefenseModifier|Player::setPlayerMeleeWeaponDefenseModifier(modifier)]]
**Player::setReserveParachuteTintIndex(index);
**[[Player::setPlayerReserveParachuteTintIndex|Player::setPlayerReserveParachuteTintIndex(index)]]
**Player::areFlashingStarsAboutToDrop();
**[[Player::arePlayerFlashingStarsAboutToDrop|Player::arePlayerFlashingStarsAboutToDrop()]]
**Player::setTargetingMode(targetMode);
**[[Player::setPlayerTargetingMode|Player::setPlayerTargetingMode(targetMode)]]
**Player::isSpecialAbilityEnabled();
**[[Player::isSpecialAbilityEnabled|Player::isSpecialAbilityEnabled()]]
**Player::setSneakingNoiseMultiplier(multiplier);
**[[Player::setPlayerSneakingNoiseMultiplier|Player::setPlayerSneakingNoiseMultiplier(multiplier)]]
**Player::clearWantedLevel();
**[[Player::clearPlayerWantedLevel|Player::clearPlayerWantedLevel()]]
**Player::getInvincible();
**[[Player::getPlayerInvincible|Player::getPlayerInvincible()]]
**Player::specialAbilityChargeAbsolute(p1, p2);
**[[Player::specialAbilityChargeAbsolute|Player::specialAbilityChargeAbsolute(p1p2)]]
**Player::resetWantedLevelDifficulty();
**[[Player::resetWantedLevelDifficulty|Player::resetWantedLevelDifficulty()]]
**Player::forceCleanup(cleanupFlags);
**[[Player::forceCleanup|Player::forceCleanup(cleanupFlags)]]
**Player::giveAchievementTo(achievement);
**[[Player::giveAchievementToPlayer|Player::giveAchievementToPlayer(achievement)]]
**Player::startFiringAmnesty(duration);
**[[Player::startFiringAmnesty|Player::startFiringAmnesty(duration)]]
**Player::disableVehicleRewards();
**[[Player::disablePlayerVehicleRewards|Player::disablePlayerVehicleRewards()]]
**Player::setAreasGeneratorOrientation();
**[[Player::setAreasGeneratorOrientation|Player::setAreasGeneratorOrientation()]]
**Player::setSimulateAiming(toggle);
**[[Player::setPlayerSimulateAiming|Player::setPlayerSimulateAiming(toggle)]]
**Player::isSpecialAbilityUnlocked(playerModel);
**[[Player::isSpecialAbilityUnlocked|Player::isSpecialAbilityUnlocked(playerModel)]]
**Player::hasForceCleanupOccurred(cleanupFlags);
**[[Player::hasForceCleanupOccurred|Player::hasForceCleanupOccurred(cleanupFlags)]]
**Player::setAirDragMultiplierForsVehicle(multiplier);
**[[Player::setAirDragMultiplierForPlayersVehicle|Player::setAirDragMultiplierForPlayersVehicle(multiplier)]]
**Player::setWeaponDamageModifier(damageAmount);
**[[Player::setPlayerWeaponDamageModifier|Player::setPlayerWeaponDamageModifier(damageAmount)]]
**Player::setCanUseCover(toggle);
**[[Player::setPlayerCanUseCover|Player::setPlayerCanUseCover(toggle)]]
**Player::getTimeSinceDroveOnPavement();
**[[Player::getTimeSincePlayerDroveOnPavement|Player::getTimeSincePlayerDroveOnPavement()]]
**Player::hasLeftTheWorld();
**[[Player::hasPlayerLeftTheWorld|Player::hasPlayerLeftTheWorld()]]
**Player::getReserveParachuteTintIndex(index);
**[[Player::getPlayerReserveParachuteTintIndex|Player::getPlayerReserveParachuteTintIndex(index)]]
**Player::setCanBeHassledByGangs(toggle);
**[[Player::setPlayerCanBeHassledByGangs|Player::setPlayerCanBeHassledByGangs(toggle)]]
**Player::specialAbilityDeactivate();
**[[Player::specialAbilityDeactivate|Player::specialAbilityDeactivate()]]
**Player::hasBeenSpottedInStolenVehicle();
**[[Player::hasPlayerBeenSpottedInStolenVehicle|Player::hasPlayerBeenSpottedInStolenVehicle()]]
**Player::setParachuteVariationOverride(p1, p2, p3, p4);
**[[Player::setPlayerParachuteVariationOverride|Player::setPlayerParachuteVariationOverride(p1p2p3p4)]]
**Player::setDispatchCopsFor(toggle);
**[[Player::setDispatchCopsForPlayer|Player::setDispatchCopsForPlayer(toggle)]]
**Player::getTimeSinceDroveAgainstTraffic();
**[[Player::getTimeSincePlayerDroveAgainstTraffic|Player::getTimeSincePlayerDroveAgainstTraffic()]]
**Player::setNoiseMultiplier(multiplier);
**[[Player::setPlayerNoiseMultiplier|Player::setPlayerNoiseMultiplier(multiplier)]]
**Player::setParachutePackModelOverride(model);
**[[Player::setPlayerParachutePackModelOverride|Player::setPlayerParachutePackModelOverride(model)]]
**Player::isFreeForAmbientTask();
**[[Player::isPlayerFreeForAmbientTask|Player::isPlayerFreeForAmbientTask()]]
**Player::setHudAnimStopLevel(toggle);
**[[Player::setHudAnimStopLevel|Player::setHudAnimStopLevel(toggle)]]
**Player::canStartMission();
**[[Player::canPlayerStartMission|Player::canPlayerStartMission()]]
**Player::setWantedLevelNow(p1);
**[[Player::setPlayerWantedLevelNow|Player::setPlayerWantedLevelNow(p1)]]
**Player::hasTeleportFinished();
**[[Player::hasPlayerTeleportFinished|Player::hasPlayerTeleportFinished()]]
**Player::getWantedLevel();
**[[Player::getPlayerWantedLevel|Player::getPlayerWantedLevel()]]
**Player::getTimeSinceHitPed();
**[[Player::getTimeSincePlayerHitPed|Player::getTimeSincePlayerHitPed()]]
**Player::hasDamagedAtLeastOneNonAnimalPed();
**[[Player::hasPlayerDamagedAtLeastOneNonAnimalPed|Player::hasPlayerDamagedAtLeastOneNonAnimalPed()]]
**Player::getRgbColour(rgb);
**[[Player::getPlayerRgbColour|Player::getPlayerRgbColour(rgb)]]
**Player::reportCrime(crimeTypewantedLvlThresh);
**[[Player::reportCrime|Player::reportCrime(crimeTypewantedLvlThresh)]]
**Player::specialAbilityChargeContinuous(p1);
**[[Player::specialAbilityChargeContinuous|Player::specialAbilityChargeContinuous(p1)]]
**Player::playerAttachVirtualBound(p0, p1, p2, p3, p4, p5, p6, p7);
**[[Player::playerAttachVirtualBound|Player::playerAttachVirtualBound(p0, p1, p2, p3, p4, p5, p6, p7)]]
**Player::getParachuteSmokeTrailColor(r, g, b);
**[[Player::getPlayerParachuteSmokeTrailColor|Player::getPlayerParachuteSmokeTrailColor(rgb)]]
**Player::clearHasDamagedAtLeastOnePed();
**[[Player::clearPlayerHasDamagedAtLeastOnePed|Player::clearPlayerHasDamagedAtLeastOnePed()]]
**Player::specialAbilityChargeMedium(p1, p2);
**[[Player::specialAbilityChargeMedium|Player::specialAbilityChargeMedium(p1p2)]]
**Player::specialAbilityUnlock(playerModel);
**[[Player::specialAbilityUnlock|Player::specialAbilityUnlock(playerModel)]]
**Player::canPedHear(ped);
**[[Player::canPedHearPlayer|Player::canPedHearPlayer(ped)]]
**Player::removeHelmet(p2);
**[[Player::removePlayerHelmet|Player::removePlayerHelmet(p2)]]
**Player::setCanLeaveParachuteSmokeTrail(enabled);
**[[Player::setPlayerCanLeaveParachuteSmokeTrail|Player::setPlayerCanLeaveParachuteSmokeTrail(enabled)]]
**Player::specialAbilityChargeLarge(p1, p2);
**[[Player::specialAbilityChargeLarge|Player::specialAbilityChargeLarge(p1p2)]]
**Player::forceCleanupForThreadWithThisId(id, cleanupFlags);
**[[Player::forceCleanupForThreadWithThisId|Player::forceCleanupForThreadWithThisId(id, cleanupFlags)]]
**Player::isPressingHorn();
**[[Player::isPlayerPressingHorn|Player::isPlayerPressingHorn()]]
**Player::getWantedLevelThreshold(wantedLevel);
**[[Player::getWantedLevelThreshold|Player::getWantedLevelThreshold(wantedLevel)]]


==Rope==
==Rope==
**Rope::setDisableFragDamage(object, toggle);
**[[Rope::setDisableFragDamage|Rope::setDisableFragDamage(object, toggle)]]
**Rope::startRopeWinding(rope);
**[[Rope::startRopeWinding|Rope::startRopeWinding(rope)]]
**Rope::getRopeLastVertexCoord(rope);
**[[Rope::getRopeLastVertexCoord|Rope::getRopeLastVertexCoord(rope)]]
**Rope::pinRopeVertex(rope, vertex, x, y, z);
**[[Rope::pinRopeVertex|Rope::pinRopeVertex(rope, vertex, x, y, z)]]
**Rope::breakEntityGlass(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
**[[Rope::breakEntityGlass|Rope::breakEntityGlass(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)]]
**Rope::getRopeVertexCount(rope);
**[[Rope::getRopeVertexCount|Rope::getRopeVertexCount(rope)]]
**Rope::attachEntitiesToRope(rope, ent1, ent2, ent1_x, ent1_y, ent1_z, ent2_x, ent2_y, ent2_z, length, p10, p11, p12, p13);
**[[Rope::attachEntitiesToRope|Rope::attachEntitiesToRope(rope, ent1, ent2, ent1_x, ent1_y, ent1_z, ent2_x, ent2_y, ent2_z, length, p10, p11, p12, p13)]]
**Rope::attachRopeToEntity(rope, entity, x, y, z, p5);
**[[Rope::attachRopeToEntity|Rope::attachRopeToEntity(rope, entity, x, y, z, p5)]]
**Rope::unpinRopeVertex(rope, vertex);
**[[Rope::unpinRopeVertex|Rope::unpinRopeVertex(rope, vertex)]]
**Rope::deleteRope(rope);
**[[Rope::deleteRope|Rope::deleteRope(rope)]]
**Rope::ropeConvertToSimple(rope);
**[[Rope::ropeConvertToSimple|Rope::ropeConvertToSimple(rope)]]
**Rope::startRopeUnwindingFront(rope);
**[[Rope::startRopeUnwindingFront|Rope::startRopeUnwindingFront(rope)]]
**Rope::setDisableBreaking(rope, enabled);
**[[Rope::setDisableBreaking|Rope::setDisableBreaking(rope, enabled)]]
**Rope::getRopeLength(rope);
**[[Rope::getRopeLength|Rope::getRopeLength(rope)]]
**Rope::getCgoffset(rope);
**[[Rope::getCgoffset|Rope::getCgoffset(rope)]]
**Rope::deleteChildRope(rope);
**[[Rope::deleteChildRope|Rope::deleteChildRope(rope)]]
**Rope::detachRopeFromEntity(rope, entity);
**[[Rope::detachRopeFromEntity|Rope::detachRopeFromEntity(rope, entity)]]
**Rope::setCgAtBoundcenter(rope);
**[[Rope::setCgAtBoundcenter|Rope::setCgAtBoundcenter(rope)]]
**Rope::ropeResetLength(rope, length);
**[[Rope::ropeResetLength|Rope::ropeResetLength(rope, length)]]
**Rope::ropeSetUpdatePinverts(rope);
**[[Rope::ropeSetUpdatePinverts|Rope::ropeSetUpdatePinverts(rope)]]
**Rope::stopRopeWinding(rope);
**[[Rope::stopRopeWinding|Rope::stopRopeWinding(rope)]]
**Rope::loadRopeData(rope, rope_preset);
**[[Rope::loadRopeData|Rope::loadRopeData(rope, rope_preset)]]
**Rope::ropeForceLength(rope, length);
**[[Rope::ropeForceLength|Rope::ropeForceLength(rope, length)]]
**Rope::setCgoffset(rope, x, y, z);
**[[Rope::setCgoffset|Rope::setCgoffset(rope, x, y, z)]]
**Rope::applyImpulseToCloth(posX, posY, posZ, vecX, vecY, vecZ, impulse);
**[[Rope::applyImpulseToCloth|Rope::applyImpulseToCloth(posX, posY, posZ, vecX, vecY, vecZ, impulse)]]
**Rope::addRope(x, y, z, rotX, rotY, rotZ, length, ropeType, maxLength, minLength, p10, p11, p12, rigid, p14, breakWhenShot, unkPtr);
**[[Rope::addRope|Rope::addRope(x, y, z, rotX, rotY, rotZ, length, ropeType, maxLength, minLength, p10, p11, p12, rigid, p14, breakWhenShot, unkPtr)]]
**Rope::getRopeVertexCoord(rope, vertex);
**[[Rope::getRopeVertexCoord|Rope::getRopeVertexCoord(rope, vertex)]]
**Rope::setDamping(rope, vertex, value);
**[[Rope::setDamping|Rope::setDamping(rope, vertex, value)]]
**Rope::ropeDrawShadowEnabled(rope, toggle);
**[[Rope::ropeDrawShadowEnabled|Rope::ropeDrawShadowEnabled(rope, toggle)]]
**Rope::doesRopeExist(rope);
**[[Rope::doesRopeExist|Rope::doesRopeExist(rope)]]
**Rope::stopRopeUnwindingFront(rope);
**[[Rope::stopRopeUnwindingFront|Rope::stopRopeUnwindingFront(rope)]]


==Script==
==Script==
**Script::getThreadName(threadId);
**[[Script::getThreadName|Script::getThreadName(threadId)]]
**Script::getEventData(p0, eventIndex, eventData, p3);
**[[Script::getEventData|Script::getEventData(p0, eventIndex, eventData, p3)]]
**Script::getNumberOfInstancesOfStreamedScript(scriptHash);
**[[Script::getNumberOfInstancesOfStreamedScript|Script::getNumberOfInstancesOfStreamedScript(scriptHash)]]
**Script::isThreadActive(threadId);
**[[Script::isThreadActive|Script::isThreadActive(threadId)]]
**Script::setNoLoadingScreen(toggle);
**[[Script::setNoLoadingScreen|Script::setNoLoadingScreen(toggle)]]
**Script::triggerScriptEvent(p0, argsStruct, argsStructSize, bitset);
**[[Script::triggerScriptEvent|Script::triggerScriptEvent(p0, argsStruct, argsStructSize, bitset)]]
**Script::hasStreamedScriptLoaded(scriptHash);
**[[Script::hasStreamedScriptLoaded|Script::hasStreamedScriptLoaded(scriptHash)]]
**Script::getNumberOfEvents(p0);
**[[Script::getNumberOfEvents|Script::getNumberOfEvents(p0)]]
**Script::requestScript(scriptName);
**[[Script::requestScript|Script::requestScript(scriptName)]]
**Script::getEventExists(p0, eventIndex);
**[[Script::getEventExists|Script::getEventExists(p0, eventIndex)]]
**Script::setStreamedScriptAsNoLongerNeeded(scriptHash);
**[[Script::setStreamedScriptAsNoLongerNeeded|Script::setStreamedScriptAsNoLongerNeeded(scriptHash)]]
**Script::terminateThread(threadId);
**[[Script::terminateThread|Script::terminateThread(threadId)]]
**Script::setScriptAsNoLongerNeeded(scriptName);
**[[Script::setScriptAsNoLongerNeeded|Script::setScriptAsNoLongerNeeded(scriptName)]]
**Script::requestStreamedScript(scriptHash);
**[[Script::requestStreamedScript|Script::requestStreamedScript(scriptHash)]]
**Script::getEventAtIndex(p0, eventIndex);
**[[Script::getEventAtIndex|Script::getEventAtIndex(p0, eventIndex)]]
**Script::hasScriptLoaded(scriptName);
**[[Script::hasScriptLoaded|Script::hasScriptLoaded(scriptName)]]
**Script::isStreamedScriptRunning(scriptHash);
**[[Script::isStreamedScriptRunning|Script::isStreamedScriptRunning(scriptHash)]]
**Script::doesScriptExist(scriptName);
**[[Script::doesScriptExist|Script::doesScriptExist(scriptName)]]


==Stats==
==Stats==
**Stats::statSlotIsLoaded(p0);
**[[Stats::statSlotIsLoaded|Stats::statSlotIsLoaded(p0)]]
**Stats::playstatsFriendActivity(p0, p1);
**[[Stats::playstatsFriendActivity|Stats::playstatsFriendActivity(p0, p1)]]
**Stats::statGetBoolMasked(statName, mask, p2);
**[[Stats::statGetBoolMasked|Stats::statGetBoolMasked(statName, mask, p2)]]
**Stats::leaderboardsGetNumberOfColumns(p0, p1);
**[[Stats::leaderboardsGetNumberOfColumns|Stats::leaderboardsGetNumberOfColumns(p0, p1)]]
**Stats::statGetBool(statHash, outValue, p2);
**[[Stats::statGetBool|Stats::statGetBool(statHash, outValue, p2)]]
**Stats::playstatsShopItem(p0, p1, p2, p3, p4);
**[[Stats::playstatsShopItem|Stats::playstatsShopItem(p0, p1, p2, p3, p4)]]
**Stats::statSetGxtLabel(statName, value, save);
**[[Stats::statSetGxtLabel|Stats::statSetGxtLabel(statName, value, save)]]
**Stats::statGetUserId(p0);
**[[Stats::statGetUserId|Stats::statGetUserId(p0)]]
**Stats::statSetDate(statName, value, numFields, save);
**[[Stats::statSetDate|Stats::statSetDate(statName, value, numFields, save)]]
**Stats::statGetNumberOfSeconds(statName);
**[[Stats::statGetNumberOfSeconds|Stats::statGetNumberOfSeconds(statName)]]
**Stats::leaderboardsReadSuccessful(p0, p1, p2);
**[[Stats::leaderboardsReadSuccessful|Stats::leaderboardsReadSuccessful(p0, p1, p2)]]
**Stats::playstatsClothChange(p0, p1, p2, p3, p4);
**[[Stats::playstatsClothChange|Stats::playstatsClothChange(p0, p1, p2, p3, p4)]]
**Stats::statGetPos(p0, p1, p2, p3, p4);
**[[Stats::statGetPos|Stats::statGetPos(p0, p1, p2, p3, p4)]]
**Stats::playstatsAwardXp(p0, p1, p2);
**[[Stats::playstatsAwardXp|Stats::playstatsAwardXp(p0, p1, p2)]]
**Stats::statSetFloat(statName, value, save);
**[[Stats::statSetFloat|Stats::statSetFloat(statName, value, save)]]
**Stats::statDeleteSlot(p0);
**[[Stats::statDeleteSlot|Stats::statDeleteSlot(p0)]]
**Stats::statSetBool(statName, value, save);
**[[Stats::statSetBool|Stats::statSetBool(statName, value, save)]]
**Stats::statGetLicensePlate(statName);
**[[Stats::statGetLicensePlate|Stats::statGetLicensePlate(statName)]]
**Stats::statSetBoolMasked(statName, value, mask, save);
**[[Stats::statSetBoolMasked|Stats::statSetBoolMasked(statName, value, mask, save)]]
**Stats::leaderboards2ReadByRadius(p0, p1, p2);
**[[Stats::leaderboards2ReadByRadius|Stats::leaderboards2ReadByRadius(p0, p1, p2)]]
**Stats::playstatsCheatApplied(cheat);
**[[Stats::playstatsCheatApplied|Stats::playstatsCheatApplied(cheat)]]
**Stats::statGetMaskedInt(p0, p1, p2, p3, p4);
**[[Stats::statGetMaskedInt|Stats::statGetMaskedInt(p0, p1, p2, p3, p4)]]
**Stats::statSetProfileSetting(profileSetting, value);
**[[Stats::statSetProfileSetting|Stats::statSetProfileSetting(profileSetting, value)]]
**Stats::playstatsOddjobDone(p0, p1, p2);
**[[Stats::playstatsOddjobDone|Stats::playstatsOddjobDone(p0, p1, p2)]]
**Stats::statSetLicensePlate(statName, str);
**[[Stats::statSetLicensePlate|Stats::statSetLicensePlate(statName, str)]]
**Stats::statGetNumberOfMinutes(statName);
**[[Stats::statGetNumberOfMinutes|Stats::statGetNumberOfMinutes(statName)]]
**Stats::statGetInt(statHash, outValue, p2);
**[[Stats::statGetInt|Stats::statGetInt(statHash, outValue, p2)]]
**Stats::statSetMaskedInt(statName, p1, p2, p3, save);
**[[Stats::statSetMaskedInt|Stats::statSetMaskedInt(statName, p1, p2, p3, save)]]
**Stats::playstatsMissionOver(p0, p1, p2, p3, p4, p5);
**[[Stats::playstatsMissionOver|Stats::playstatsMissionOver(p0, p1, p2, p3, p4, p5)]]
**Stats::leaderboardsReadClear(p0, p1, p2);
**[[Stats::leaderboardsReadClear|Stats::leaderboardsReadClear(p0, p1, p2)]]
**Stats::leaderboards2ReadByScoreInt(p0, p1, p2);
**[[Stats::leaderboards2ReadByScoreInt|Stats::leaderboards2ReadByScoreInt(p0, p1, p2)]]
**Stats::statGetDate(statHash, p1, p2, p3);
**[[Stats::statGetDate|Stats::statGetDate(statHash, p1, p2, p3)]]
**Stats::statSetUserId(statName, value, save);
**[[Stats::statSetUserId|Stats::statSetUserId(statName, value, save)]]
**Stats::leaderboardsGetCacheDataRow(p0, p1, p2);
**[[Stats::leaderboardsGetCacheDataRow|Stats::leaderboardsGetCacheDataRow(p0, p1, p2)]]
**Stats::leaderboards2ReadFriendsByRow(p0, p1, p2, p3, p4, p5);
**[[Stats::leaderboards2ReadFriendsByRow|Stats::leaderboards2ReadFriendsByRow(p0, p1, p2, p3, p4, p5)]]
**Stats::playstatsNpcInvite(p0);
**[[Stats::playstatsNpcInvite|Stats::playstatsNpcInvite(p0)]]
**Stats::statIncrement(statName, value);
**[[Stats::statIncrement|Stats::statIncrement(statName, value)]]
**Stats::playstatsRaceCheckpoint(p0, p1, p2, p3, p4);
**[[Stats::playstatsRaceCheckpoint|Stats::playstatsRaceCheckpoint(p0, p1, p2, p3, p4)]]
**Stats::leaderboardsGetCacheExists(p0);
**[[Stats::leaderboardsGetCacheExists|Stats::leaderboardsGetCacheExists(p0)]]
**Stats::statLoadPending(p0);
**[[Stats::statLoadPending|Stats::statLoadPending(p0)]]
**Stats::statLoad(p0);
**[[Stats::statLoad|Stats::statLoad(p0)]]
**Stats::statSetString(statName, value, save);
**[[Stats::statSetString|Stats::statSetString(statName, value, save)]]
**Stats::leaderboards2ReadByRow(p0, p1, p2, p3, p4, p5, p6);
**[[Stats::leaderboards2ReadByRow|Stats::leaderboards2ReadByRow(p0, p1, p2, p3, p4, p5, p6)]]
**Stats::leaderboardsReadPending(p0, p1, p2);
**[[Stats::leaderboardsReadPending|Stats::leaderboardsReadPending(p0, p1, p2)]]
**Stats::leaderboards2WriteData(p0);
**[[Stats::leaderboards2WriteData|Stats::leaderboards2WriteData(p0)]]
**Stats::statSetInt(statName, value, save);
**[[Stats::statSetInt|Stats::statSetInt(statName, value, save)]]
**Stats::leaderboardsCacheDataRow(p0);
**[[Stats::leaderboardsCacheDataRow|Stats::leaderboardsCacheDataRow(p0)]]
**Stats::leaderboards2ReadByRank(p0, p1, p2);
**[[Stats::leaderboards2ReadByRank|Stats::leaderboards2ReadByRank(p0, p1, p2)]]
**Stats::playstatsPropChange(p0, p1, p2, p3);
**[[Stats::playstatsPropChange|Stats::playstatsPropChange(p0, p1, p2, p3)]]
**Stats::playstatsMatchStarted(p0, p1, p2, p3, p4, p5, p6);
**[[Stats::playstatsMatchStarted|Stats::playstatsMatchStarted(p0, p1, p2, p3, p4, p5, p6)]]
**Stats::leaderboardsGetColumnType(p0, p1, p2);
**[[Stats::leaderboardsGetColumnType|Stats::leaderboardsGetColumnType(p0, p1, p2)]]
**Stats::playstatsMissionStarted(p0, p1, p2, p3);
**[[Stats::playstatsMissionStarted|Stats::playstatsMissionStarted(p0, p1, p2, p3)]]
**Stats::statSetCurrentPosixTime(statName, p1);
**[[Stats::statSetCurrentPosixTime|Stats::statSetCurrentPosixTime(statName, p1)]]
**Stats::leaderboards2ReadByHandle(p0, p1);
**[[Stats::leaderboards2ReadByHandle|Stats::leaderboards2ReadByHandle(p0, p1)]]
**Stats::leaderboardsGetColumnId(p0, p1, p2);
**[[Stats::leaderboardsGetColumnId|Stats::leaderboardsGetColumnId(p0, p1, p2)]]
**Stats::playstatsRankUp(p0);
**[[Stats::playstatsRankUp|Stats::playstatsRankUp(p0)]]
**Stats::playstatsMissionCheckpoint(p0, p1, p2, p3);
**[[Stats::playstatsMissionCheckpoint|Stats::playstatsMissionCheckpoint(p0, p1, p2, p3)]]
**Stats::statGetFloat(statHash, outValue, p2);
**[[Stats::statGetFloat|Stats::statGetFloat(statHash, outValue, p2)]]
**Stats::statSetPos(statName, x, y, z, save);
**[[Stats::statSetPos|Stats::statSetPos(statName, x, y, z, save)]]
**Stats::playstatsWebsiteVisited(scaleformHash, p1);
**[[Stats::playstatsWebsiteVisited|Stats::playstatsWebsiteVisited(scaleformHash, p1)]]
**Stats::statSave(p0, p1, p2);
**[[Stats::statSave|Stats::statSave(p0, p1, p2)]]
**Stats::statGetNumberOfDays(statName);
**[[Stats::statGetNumberOfDays|Stats::statGetNumberOfDays(statName)]]
**Stats::statGetString(statHash, p1);
**[[Stats::statGetString|Stats::statGetString(statHash, p1)]]
**Stats::leaderboards2ReadByScoreFloat(p0, p1, p2);
**[[Stats::leaderboards2ReadByScoreFloat|Stats::leaderboards2ReadByScoreFloat(p0, p1, p2)]]
**Stats::statClearSlotForReload(statSlot);
**[[Stats::statClearSlotForReload|Stats::statClearSlotForReload(statSlot)]]
**Stats::leaderboardsGetCacheTime(p0);
**[[Stats::leaderboardsGetCacheTime|Stats::leaderboardsGetCacheTime(p0)]]
**Stats::statGetNumberOfHours(statName);
**[[Stats::statGetNumberOfHours|Stats::statGetNumberOfHours(statName)]]


==Streaming==
==Streaming==
**Streaming::removeClipSet(clipSet);
**[[Streaming::removeClipSet|Streaming::removeClipSet(clipSet)]]
**Streaming::requestCollisionAtCoord(x, y, z);
**[[Streaming::requestCollisionAtCoord|Streaming::requestCollisionAtCoord(x, y, z)]]
**Streaming::removeAnimSet(animSet);
**[[Streaming::removeAnimSet|Streaming::removeAnimSet(animSet)]]
**Streaming::isModelAVehicle(model);
**[[Streaming::isModelAVehicle|Streaming::isModelAVehicle(model)]]
**Streaming::newLoadSceneStart(p0, p1, p2, p3, p4, p5, p6, p7);
**[[Streaming::newLoadSceneStart|Streaming::newLoadSceneStart(p0, p1, p2, p3, p4, p5, p6, p7)]]
**Streaming::setUnkCameraSettings(x, y, z, rad, p4, p5);
**[[Streaming::setUnkCameraSettings|Streaming::setUnkCameraSettings(x, y, z, rad, p4, p5)]]
**Streaming::hasCollisionForModelLoaded(model);
**[[Streaming::hasCollisionForModelLoaded|Streaming::hasCollisionForModelLoaded(model)]]
**Streaming::doesAnimDictExist(animDict);
**[[Streaming::doesAnimDictExist|Streaming::doesAnimDictExist(animDict)]]
**Streaming::hasClipSetLoaded(clipSet);
**[[Streaming::hasClipSetLoaded|Streaming::hasClipSetLoaded(clipSet)]]
**Streaming::isModelInCdimage(model);
**[[Streaming::isModelInCdimage|Streaming::isModelInCdimage(model)]]
**Streaming::prefetchSrl(p0);
**[[Streaming::prefetchSrl|Streaming::prefetchSrl(p0)]]
**Streaming::requestIpl(iplName);
**[[Streaming::requestIpl|Streaming::requestIpl(iplName)]]
**Streaming::setDitchPoliceModels(toggle);
**[[Streaming::setDitchPoliceModels|Streaming::setDitchPoliceModels(toggle)]]
**Streaming::loadScene(x, y, z);
**[[Streaming::loadScene|Streaming::loadScene(x, y, z)]]
**Streaming::removeNamedPtfxAsset(fxName);
**[[Streaming::removeNamedPtfxAsset|Streaming::removeNamedPtfxAsset(fxName)]]
**Streaming::setStreaming(toggle);
**[[Streaming::setStreaming|Streaming::setStreaming(toggle)]]
**Streaming::requestAnimSet(animSet);
**[[Streaming::requestAnimSet|Streaming::requestAnimSet(animSet)]]
**Streaming::setGamePausesForStreaming(toggle);
**[[Streaming::setGamePausesForStreaming|Streaming::setGamePausesForStreaming(toggle)]]
**Streaming::setReducePedModelBudget(toggle);
**[[Streaming::setReducePedModelBudget|Streaming::setReducePedModelBudget(toggle)]]
**Streaming::setReduceVehicleModelBudget(toggle);
**[[Streaming::setReduceVehicleModelBudget|Streaming::setReduceVehicleModelBudget(toggle)]]
**Streaming::hasNamedPtfxAssetLoaded(fxName);
**[[Streaming::hasNamedPtfxAssetLoaded|Streaming::hasNamedPtfxAssetLoaded(fxName)]]
**Streaming::isIplActive(iplName);
**[[Streaming::isIplActive|Streaming::isIplActive(iplName)]]
**Streaming::setPedPopulationBudget(p0);
**[[Streaming::setPedPopulationBudget|Streaming::setPedPopulationBudget(p0)]]
**Streaming::requestCollisionForModel(model);
**[[Streaming::requestCollisionForModel|Streaming::requestCollisionForModel(model)]]
**Streaming::requestModel(model);
**[[Streaming::requestModel|Streaming::requestModel(model)]]
**Streaming::hasModelLoaded(model);
**[[Streaming::hasModelLoaded|Streaming::hasModelLoaded(model)]]
**Streaming::requestModel2(model);
**[[Streaming::requestModel2|Streaming::requestModel2(model)]]
**Streaming::setSrlTime(p0);
**[[Streaming::setSrlTime|Streaming::setSrlTime(p0)]]
**Streaming::newLoadSceneStartSafe(p0, p1, p2, p3, p4);
**[[Streaming::newLoadSceneStartSafe|Streaming::newLoadSceneStartSafe(p0, p1, p2, p3, p4)]]
**Streaming::getIdealPlayerSwitchType(x1, y1, z1, x2, y2, z2);
**[[Streaming::getIdealPlayerSwitchType|Streaming::getIdealPlayerSwitchType(x1, y1, z1, x2, y2, z2)]]
**Streaming::requestNamedPtfxAsset(fxName);
**[[Streaming::requestNamedPtfxAsset|Streaming::requestNamedPtfxAsset(fxName)]]
**Streaming::setHdArea(x, y, z, ground);
**[[Streaming::setHdArea|Streaming::setHdArea(x, y, z, ground)]]
**Streaming::setFocusArea(x, y, z, offsetX, offsetY, offsetZ);
**[[Streaming::setFocusArea|Streaming::setFocusArea(x, y, z, offsetX, offsetY, offsetZ)]]
**Streaming::isModelValid(model);
**[[Streaming::isModelValid|Streaming::isModelValid(model)]]
**Streaming::setPlayerSwitchLocation(p0, p1, p2, p3, p4, p5, p6, p7, p8);
**[[Streaming::setPlayerSwitchLocation|Streaming::setPlayerSwitchLocation(p0, p1, p2, p3, p4, p5, p6, p7, p8)]]
**Streaming::hasAnimSetLoaded(animSet);
**[[Streaming::hasAnimSetLoaded|Streaming::hasAnimSetLoaded(animSet)]]
**Streaming::requestAdditionalCollisionAtCoord(p0, p1, p2);
**[[Streaming::requestAdditionalCollisionAtCoord|Streaming::requestAdditionalCollisionAtCoord(p0, p1, p2)]]
**Streaming::setVehiclePopulationBudget(p0);
**[[Streaming::setVehiclePopulationBudget|Streaming::setVehiclePopulationBudget(p0)]]
**Streaming::hasAnimDictLoaded(animDict);
**[[Streaming::hasAnimDictLoaded|Streaming::hasAnimDictLoaded(animDict)]]
**Streaming::requestClipSet(clipSet);
**[[Streaming::requestClipSet|Streaming::requestClipSet(clipSet)]]
**Streaming::requestAnimDict(animDict);
**[[Streaming::requestAnimDict|Streaming::requestAnimDict(animDict)]]
**Streaming::setInteriorActive(interiorID, toggle);
**[[Streaming::setInteriorActive|Streaming::setInteriorActive(interiorID, toggle)]]
**Streaming::setModelAsNoLongerNeeded(model);
**[[Streaming::setModelAsNoLongerNeeded|Streaming::setModelAsNoLongerNeeded(model)]]
**Streaming::removeIpl(iplName);
**[[Streaming::removeIpl|Streaming::removeIpl(iplName)]]
**Streaming::removeAnimDict(animDict);
**[[Streaming::removeAnimDict|Streaming::removeAnimDict(animDict)]]
**Streaming::startPlayerSwitch(from, to, flags, switchType);
**[[Streaming::startPlayerSwitch|Streaming::startPlayerSwitch(from, to, flags, switchType)]]


==System==
==System==
**System::sin(value);
**[[System::sin|System::sin(value)]]
**System::ceil(value);
**[[System::ceil|System::ceil(value)]]
**System::vdist(x1, y1, z1, x2, y2, z2);
**[[System::vdist|System::vdist(x1, y1, z1, x2, y2, z2)]]
**System::wait(ms);
**[[System::wait|System::wait(ms)]]
**System::settimerb(value);
**[[System::settimerb|System::settimerb(value)]]
**System::vmag(p0, p1, p2);
**[[System::vmag|System::vmag(p0, p1, p2)]]
**System::sqrt(value);
**[[System::sqrt|System::sqrt(value)]]
**System::shiftRight(value, bitShift);
**[[System::shiftRight|System::shiftRight(value, bitShift)]]
**System::vmag2(p0, p1, p2);
**[[System::vmag2|System::vmag2(p0, p1, p2)]]
**System::vdist2(x1, y1, z1, x2, y2, z2);
**[[System::vdist2|System::vdist2(x1, y1, z1, x2, y2, z2)]]
**System::startNewScriptWithArgs(scriptName, args, argCount, stackSize);
**[[System::startNewScriptWithArgs|System::startNewScriptWithArgs(scriptName, args, argCount, stackSize)]]
**System::toFloat(value);
**[[System::toFloat|System::toFloat(value)]]
**System::settimera(value);
**[[System::settimera|System::settimera(value)]]
**System::startNewStreamedScriptWithArgs(scriptHash, args, argCount, stackSize);
**[[System::startNewStreamedScriptWithArgs|System::startNewStreamedScriptWithArgs(scriptHash, args, argCount, stackSize)]]
**System::cos(value);
**[[System::cos|System::cos(value)]]
**System::pow(base, exponent);
**[[System::pow|System::pow(base, exponent)]]
**System::startNewScript(scriptName, stackSize);
**[[System::startNewScript|System::startNewScript(scriptName, stackSize)]]
**System::startNewStreamedScript(scriptHash, stackSize);
**[[System::startNewStreamedScript|System::startNewStreamedScript(scriptHash, stackSize)]]
**System::shiftLeft(value, bitShift);
**[[System::shiftLeft|System::shiftLeft(value, bitShift)]]
**System::round(value);
**[[System::round|System::round(value)]]
**System::floor(value);
**[[System::floor|System::floor(value)]]


==Time==
==Time==
**Time::pauseClock(toggle);
**[[Time::pauseClock|Time::pauseClock(toggle)]]
**Time::setClockTime(hour, minute, second);
**[[Time::setClockTime|Time::setClockTime(hour, minute, second)]]
**Time::getLocalTime(year, month, day, hour, minute, second);
**[[Time::getLocalTime|Time::getLocalTime(year, month, day, hour, minute, second)]]
**Time::getLocalTimeGmt(year, month, day, hour, minute, second);
**[[Time::getLocalTimeGmt|Time::getLocalTimeGmt(year, month, day, hour, minute, second)]]
**Time::setClockDate(day, month, year);
**[[Time::setClockDate|Time::setClockDate(day, month, year)]]
**Time::advanceClockTimeTo(hour, minute, second);
**[[Time::advanceClockTimeTo|Time::advanceClockTimeTo(hour, minute, second)]]
**Time::addToClockTime(hours, minutes, seconds);
**[[Time::addToClockTime|Time::addToClockTime(hours, minutes, seconds)]]
**Time::getPosixTime(year, month, day, hour, minute, second);
**[[Time::getPosixTime|Time::getPosixTime(year, month, day, hour, minute, second)]]


==Ui==
==Ui==
**Ui::hasAdditionalTextLoaded(slot);
**[[Ui::hasAdditionalTextLoaded|Ui::hasAdditionalTextLoaded(slot)]]
**Ui::flashAbilityBar(p0);
**[[Ui::flashAbilityBar|Ui::flashAbilityBar(p0)]]
**Ui::setTextProportional(p0);
**[[Ui::setTextProportional|Ui::setTextProportional(p0)]]
**Ui::addTextComponentInteger(value);
**[[Ui::addTextComponentInteger|Ui::addTextComponentInteger(value)]]
**Ui::setPlayerCashChange(cash, bank);
**[[Ui::setPlayerCashChange|Ui::setPlayerCashChange(cash, bank)]]
**Ui::setTextScale(p0, size);
**[[Ui::setTextScale|Ui::setTextScale(p0, size)]]
**Ui::setRadarZoom(zoomLevel);
**[[Ui::setRadarZoom|Ui::setRadarZoom(zoomLevel)]]
**Ui::showHudComponentThisFrame(id);
**[[Ui::showHudComponentThisFrame|Ui::showHudComponentThisFrame(id)]]
**Ui::addTextComponentSubstringCash(cashAmount, p1);
**[[Ui::addTextComponentSubstringCash|Ui::addTextComponentSubstringCash(cashAmount, p1)]]
**Ui::restartFrontendMenu(menuHash, p1);
**[[Ui::restartFrontendMenu|Ui::restartFrontendMenu(menuHash, p1)]]
**Ui::addTextComponentSubstringTime(timestamp, flags);
**[[Ui::addTextComponentSubstringTime|Ui::addTextComponentSubstringTime(timestamp, flags)]]
**Ui::isNamedRendertargetLinked(hash);
**[[Ui::isNamedRendertargetLinked|Ui::isNamedRendertargetLinked(hash)]]
**Ui::lockMinimapPosition(x, y);
**[[Ui::lockMinimapPosition|Ui::lockMinimapPosition(x, y)]]
**Ui::getTextSubstring(text, position, length);
**[[Ui::getTextSubstring|Ui::getTextSubstring(text, position, length)]]
**Ui::addTextComponentSubstringLocalized(gxtEntryHash);
**[[Ui::addTextComponentSubstringLocalized|Ui::addTextComponentSubstringLocalized(gxtEntryHash)]]
**Ui::setNotificationFlashColor(red, green, blue, alpha);
**[[Ui::setNotificationFlashColor|Ui::setNotificationFlashColor(red, green, blue, alpha)]]
**Ui::keyHudColour(p0, p1);
**[[Ui::keyHudColour|Ui::keyHudColour(p0, p1)]]
**Ui::getNamedRendertargetRenderId(p0);
**[[Ui::getNamedRendertargetRenderId|Ui::getNamedRendertargetRenderId(p0)]]
**Ui::doesTextBlockExist(gxt);
**[[Ui::doesTextBlockExist|Ui::doesTextBlockExist(gxt)]]
**Ui::setNotificationMessage(picName1, picName2, flash, iconType, sender, subject);
**[[Ui::setNotificationMessage|Ui::setNotificationMessage(picName1, picName2, flash, iconType, sender, subject)]]
**Ui::setTextChatUnk(p0);
**[[Ui::setTextChatUnk|Ui::setTextChatUnk(p0)]]
**Ui::setNotificationTextEntry(type);
**[[Ui::setNotificationTextEntry|Ui::setNotificationTextEntry(type)]]
**Ui::getHudComponentPosition(p0);
**[[Ui::getHudComponentPosition|Ui::getHudComponentPosition(p0)]]
**Ui::setRadarBigmapEnabled(toggleBigMap, showFullMap);
**[[Ui::setRadarBigmapEnabled|Ui::setRadarBigmapEnabled(toggleBigMap, showFullMap)]]
**Ui::displayHelpTextFromStringLabel(p0, loop, beep, shape);
**[[Ui::displayHelpTextFromStringLabel|Ui::displayHelpTextFromStringLabel(p0, loop, beep, shape)]]
**Ui::setTextEntry(text);
**[[Ui::setTextEntry|Ui::setTextEntry(text)]]
**Ui::displayAreaName(toggle);
**[[Ui::displayAreaName|Ui::displayAreaName(toggle)]]
**Ui::lockMinimapAngle(angle);
**[[Ui::lockMinimapAngle|Ui::lockMinimapAngle(angle)]]
**Ui::clearAdditionalText(p0, p1);
**[[Ui::clearAdditionalText|Ui::clearAdditionalText(p0, p1)]]
**Ui::drawNotification(blink, p1);
**[[Ui::drawNotification|Ui::drawNotification(blink, p1)]]
**Ui::setGpsFlashes(toggle);
**[[Ui::setGpsFlashes|Ui::setGpsFlashes(toggle)]]
**Ui::drawNotification3(blink, p1);
**[[Ui::drawNotification3|Ui::drawNotification3(blink, p1)]]
**Ui::hideSpecialAbilityLockonOperation(p0, p1);
**[[Ui::hideSpecialAbilityLockonOperation|Ui::hideSpecialAbilityLockonOperation(p0, p1)]]
**Ui::setTextEdge(p0, r, g, b, a);
**[[Ui::setTextEdge|Ui::setTextEdge(p0, r, g, b, a)]]
**Ui::objectDecalToggle(hash);
**[[Ui::objectDecalToggle|Ui::objectDecalToggle(hash)]]
**Ui::drawNotification2(blink, p1);
**[[Ui::drawNotification2|Ui::drawNotification2(blink, p1)]]
**Ui::resetHudComponentValues(id);
**[[Ui::resetHudComponentValues|Ui::resetHudComponentValues(id)]]
**Ui::setTextDropshadow(distance, r, g, b, a);
**[[Ui::setTextDropshadow|Ui::setTextDropshadow(distance, r, g, b, a)]]
**Ui::addBlipForRadius(posX, posY, posZ, radius);
**[[Ui::addBlipForRadius|Ui::addBlipForRadius(posX, posY, posZ, radius)]]
**Ui::enableDeathbloodSeethrough(p0);
**[[Ui::enableDeathbloodSeethrough|Ui::enableDeathbloodSeethrough(p0)]]
**Ui::setTextJustification(justifyType);
**[[Ui::setTextJustification|Ui::setTextJustification(justifyType)]]
**Ui::hasHeadDisplayLoaded(headDisplayId);
**[[Ui::hasHeadDisplayLoaded|Ui::hasHeadDisplayLoaded(headDisplayId)]]
**Ui::clearFloatingHelp(p0, p1);
**[[Ui::clearFloatingHelp|Ui::clearFloatingHelp(p0, p1)]]
**Ui::setTextGxtEntry(entry);
**[[Ui::setTextGxtEntry|Ui::setTextGxtEntry(entry)]]
**Ui::setNotificationMessageClanTag2(picName1, picName2, flash, iconType1, sender, subject, duration, clanTag, iconType2, p9);
**[[Ui::setNotificationMessageClanTag2|Ui::setNotificationMessageClanTag2(picName1, picName2, flash, iconType1, sender, subject, duration, clanTag, iconType2, p9)]]
**Ui::setTextEntryForWidth(text);
**[[Ui::setTextEntryForWidth|Ui::setTextEntryForWidth(text)]]
**Ui::registerNamedRendertarget(p0, p1);
**[[Ui::registerNamedRendertarget|Ui::registerNamedRendertarget(p0, p1)]]
**Ui::setMinimapBlockWaypoint(toggle);
**[[Ui::setMinimapBlockWaypoint|Ui::setMinimapBlockWaypoint(toggle)]]
**Ui::addTrevorRandomModifier(headDisplayId);
**[[Ui::addTrevorRandomModifier|Ui::addTrevorRandomModifier(headDisplayId)]]
**Ui::setRadarAsInteriorThisFrame(interior, x, y, z, p4);
**[[Ui::setRadarAsInteriorThisFrame|Ui::setRadarAsInteriorThisFrame(interior, x, y, z, p4)]]
**Ui::addBlipForCoord(x, y, z);
**[[Ui::addBlipForCoord|Ui::addBlipForCoord(x, y, z)]]
**Ui::setGpsFlags(p0, p1);
**[[Ui::setGpsFlags|Ui::setGpsFlags(p0, p1)]]
**Ui::setNotificationMessageClanTag(picName1, picName2, flash, iconType, sender, subject, duration, clanTag);
**[[Ui::setNotificationMessageClanTag|Ui::setNotificationMessageClanTag(picName1, picName2, flash, iconType, sender, subject, duration, clanTag)]]
**Ui::setTextRenderId(renderId);
**[[Ui::setTextRenderId|Ui::setTextRenderId(renderId)]]
**Ui::setMissionName(p0, name);
**[[Ui::setMissionName|Ui::setMissionName(p0, name)]]
**Ui::requestAdditionalText2(gxt, slot);
**[[Ui::requestAdditionalText2|Ui::requestAdditionalText2(gxt, slot)]]
**Ui::addNextMessageToPreviousBriefs(p0);
**[[Ui::addNextMessageToPreviousBriefs|Ui::addNextMessageToPreviousBriefs(p0)]]
**Ui::setTextWrap(start, end);
**[[Ui::setTextWrap|Ui::setTextWrap(start, end)]]
**Ui::setHeadDisplayFlag(headDisplayId, sprite, toggle);
**[[Ui::setHeadDisplayFlag|Ui::setHeadDisplayFlag(headDisplayId, sprite, toggle)]]
**Ui::setTextFont(fontType);
**[[Ui::setTextFont|Ui::setTextFont(fontType)]]
**Ui::hideHudComponentThisFrame(id);
**[[Ui::hideHudComponentThisFrame|Ui::hideHudComponentThisFrame(id)]]
**Ui::toggleStealthRadar(toggle);
**[[Ui::toggleStealthRadar|Ui::toggleStealthRadar(toggle)]]
**Ui::setTextRightJustify(toggle);
**[[Ui::setTextRightJustify|Ui::setTextRightJustify(toggle)]]
**Ui::addTextComponentSubstringPlayerName(text);
**[[Ui::addTextComponentSubstringPlayerName|Ui::addTextComponentSubstringPlayerName(text)]]
**Ui::isMinimapAreaRevealed(x, y, radius);
**[[Ui::isMinimapAreaRevealed|Ui::isMinimapAreaRevealed(x, y, radius)]]
**Ui::setWarningMessage3(entryHeader, entryLine1, instructionalKey, entryLine2, p4, p5, p6, p7, p8, p9);
**[[Ui::setWarningMessage3|Ui::setWarningMessage3(entryHeader, entryLine1, instructionalKey, entryLine2, p4, p5, p6, p7, p8, p9)]]
**Ui::requestAdditionalText(gxt, slot);
**[[Ui::requestAdditionalText|Ui::requestAdditionalText(gxt, slot)]]
**Ui::setFrontendActive(active);
**[[Ui::setFrontendActive|Ui::setFrontendActive(active)]]
**Ui::setMinimapComponent(p0, p1, p2);
**[[Ui::setMinimapComponent|Ui::setMinimapComponent(p0, p1, p2)]]
**Ui::setPlayerBlipPositionThisFrame(x, y);
**[[Ui::setPlayerBlipPositionThisFrame|Ui::setPlayerBlipPositionThisFrame(x, y)]]
**Ui::isNamedRendertargetRegistered(p0);
**[[Ui::isNamedRendertargetRegistered|Ui::isNamedRendertargetRegistered(p0)]]
**Ui::setWarningMessage(entryLine1, instructionalKey, entryLine2, p3, p4, p5, p6, background);
**[[Ui::setWarningMessage|Ui::setWarningMessage(entryLine1, instructionalKey, entryLine2, p3, p4, p5, p6, background)]]
**Ui::getLabelText(labelName);
**[[Ui::getLabelText|Ui::getLabelText(labelName)]]
**Ui::getHudColour(hudIndex, r, g, b, a);
**[[Ui::getHudColour|Ui::getHudColour(hudIndex, r, g, b, a)]]
**Ui::getLengthOfStringWithThisTextLabel(gxt);
**[[Ui::getLengthOfStringWithThisTextLabel|Ui::getLengthOfStringWithThisTextLabel(gxt)]]
**Ui::setTextComponentFormat(inputType);
**[[Ui::setTextComponentFormat|Ui::setTextComponentFormat(inputType)]]
**Ui::getTextScreenWidth(p0);
**[[Ui::getTextScreenWidth|Ui::getTextScreenWidth(p0)]]
**Ui::removeBlip(blip);
**[[Ui::removeBlip|Ui::removeBlip(blip)]]
**Ui::isStreamingAdditionalText(p0);
**[[Ui::isStreamingAdditionalText|Ui::isStreamingAdditionalText(p0)]]
**Ui::setCursorSprite(spriteId);
**[[Ui::setCursorSprite|Ui::setCursorSprite(spriteId)]]
**Ui::clearHelp(toggle);
**[[Ui::clearHelp|Ui::clearHelp(toggle)]]
**Ui::setMinimapVisible(toggle);
**[[Ui::setMinimapVisible|Ui::setMinimapVisible(toggle)]]
**Ui::addTextComponentSubstringWebsite(website);
**[[Ui::addTextComponentSubstringWebsite|Ui::addTextComponentSubstringWebsite(website)]]
**Ui::displayHelpTextThisFrame(message, p1);
**[[Ui::displayHelpTextThisFrame|Ui::displayHelpTextThisFrame(message, p1)]]
**Ui::displayCash(toggle);
**[[Ui::displayCash|Ui::displayCash(toggle)]]
**Ui::setAbilityBarValue(p0, p1);
**[[Ui::setAbilityBarValue|Ui::setAbilityBarValue(p0, p1)]]
**Ui::drawSubtitleTimed(time, p1);
**[[Ui::drawSubtitleTimed|Ui::drawSubtitleTimed(time, p1)]]
**Ui::displayRadar(Toggle);
**[[Ui::displayRadar|Ui::displayRadar(Toggle)]]
**Ui::flashWantedDisplay(p0);
**[[Ui::flashWantedDisplay|Ui::flashWantedDisplay(p0)]]
**Ui::setTextLeading(p0);
**[[Ui::setTextLeading|Ui::setTextLeading(p0)]]
**Ui::displayAmmoThisFrame(display);
**[[Ui::displayAmmoThisFrame|Ui::displayAmmoThisFrame(display)]]
**Ui::displayHud(toggle);
**[[Ui::displayHud|Ui::displayHud(toggle)]]
**Ui::setHudComponentPosition(id, p1, p2);
**[[Ui::setHudComponentPosition|Ui::setHudComponentPosition(id, p1, p2)]]
**Ui::setLoadingPromptTextEntry(string);
**[[Ui::setLoadingPromptTextEntry|Ui::setLoadingPromptTextEntry(string)]]
**Ui::doesTextLabelExist(gxt);
**[[Ui::doesTextLabelExist|Ui::doesTextLabelExist(gxt)]]
**Ui::hasThisAdditionalTextLoaded(gxt, slot);
**[[Ui::hasThisAdditionalTextLoaded|Ui::hasThisAdditionalTextLoaded(gxt, slot)]]
**Ui::getTextSubstringSafe(text, position, length, maxLength);
**[[Ui::getTextSubstringSafe|Ui::getTextSubstringSafe(text, position, length, maxLength)]]
**Ui::setTextEntry2(p0);
**[[Ui::setTextEntry2|Ui::setTextEntry2(p0)]]
**Ui::isHudComponentActive(id);
**[[Ui::isHudComponentActive|Ui::isHudComponentActive(id)]]
**Ui::respondingAsTemp(p0);
**[[Ui::respondingAsTemp|Ui::respondingAsTemp(p0)]]
**Ui::showLoadingPrompt(busySpinnerType);
**[[Ui::showLoadingPrompt|Ui::showLoadingPrompt(busySpinnerType)]]
**Ui::addBlipForPickup(pickup);
**[[Ui::addBlipForPickup|Ui::addBlipForPickup(pickup)]]
**Ui::removeNotification(notifactionId);
**[[Ui::removeNotification|Ui::removeNotification(notifactionId)]]
**Ui::setTextColour(red, green, blue, alpha);
**[[Ui::setTextColour|Ui::setTextColour(red, green, blue, alpha)]]
**Ui::setTextCentre(align);
**[[Ui::setTextCentre|Ui::setTextCentre(align)]]
**Ui::setWidescreenFormat(p0);
**[[Ui::setWidescreenFormat|Ui::setWidescreenFormat(p0)]]
**Ui::addTextComponentItemString(labelName);
**[[Ui::addTextComponentItemString|Ui::addTextComponentItemString(labelName)]]
**Ui::setRadarZoomLevelThisFrame(zoomLevel);
**[[Ui::setRadarZoomLevelThisFrame|Ui::setRadarZoomLevelThisFrame(zoomLevel)]]
**Ui::drawText(x, y);
**[[Ui::drawText|Ui::drawText(x, y)]]
**Ui::getTextSubstringSlice(text, startPosition, endPosition);
**[[Ui::getTextSubstringSlice|Ui::getTextSubstringSlice(text, startPosition, endPosition)]]
**Ui::setHeadDisplayWanted(headDisplayId, wantedlvl);
**[[Ui::setHeadDisplayWanted|Ui::setHeadDisplayWanted(headDisplayId, wantedlvl)]]
**Ui::clearThisPrint(p0);
**[[Ui::clearThisPrint|Ui::clearThisPrint(p0)]]
**Ui::getStreetNameFromHashKey(hash);
**[[Ui::getStreetNameFromHashKey|Ui::getStreetNameFromHashKey(hash)]]
**Ui::setMinimapAttitudeIndicatorLevel(altitude, p1);
**[[Ui::setMinimapAttitudeIndicatorLevel|Ui::setMinimapAttitudeIndicatorLevel(altitude, p1)]]
**Ui::getTextScaleHeight(size, font);
**[[Ui::getTextScaleHeight|Ui::getTextScaleHeight(size, font)]]
**Ui::setWarningMessage2(entryHeader, entryLine1, instructionalKey, entryLine2, p4, p5, p6, p7, background);
**[[Ui::setWarningMessage2|Ui::setWarningMessage2(entryHeader, entryLine1, instructionalKey, entryLine2, p4, p5, p6, p7, background)]]
**Ui::isScriptedHudComponentActive(id);
**[[Ui::isScriptedHudComponentActive|Ui::isScriptedHudComponentActive(id)]]
**Ui::setHeadDisplayString(headDisplayId, string);
**[[Ui::setHeadDisplayString|Ui::setHeadDisplayString(headDisplayId, string)]]
**Ui::setPauseMenuActive(toggle);
**[[Ui::setPauseMenuActive|Ui::setPauseMenuActive(toggle)]]
**Ui::hideScriptedHudComponentThisFrame(id);
**[[Ui::hideScriptedHudComponentThisFrame|Ui::hideScriptedHudComponentThisFrame(id)]]
**Ui::addTextComponentFloat(value, decimalPlaces);
**[[Ui::addTextComponentFloat|Ui::addTextComponentFloat(value, decimalPlaces)]]
**Ui::releaseNamedRendertarget(p0);
**[[Ui::releaseNamedRendertarget|Ui::releaseNamedRendertarget(p0)]]
**Ui::showWeaponWheel(forcedShow);
**[[Ui::showWeaponWheel|Ui::showWeaponWheel(forcedShow)]]
**Ui::activateFrontendMenu(menuhash, Toggle_Pause, p2);
**[[Ui::activateFrontendMenu|Ui::activateFrontendMenu(menuhash, Toggle_Pause, p2)]]
**Ui::setUseridsUihidden(p0, p1);
**[[Ui::setUseridsUihidden|Ui::setUseridsUihidden(p0, p1)]]
**Ui::drawNotification4(blink, p1);
**[[Ui::drawNotification4|Ui::drawNotification4(blink, p1)]]
**Ui::getLengthOfLiteralString(string);
**[[Ui::getLengthOfLiteralString|Ui::getLengthOfLiteralString(string)]]
**Ui::setHudColour(hudIndex, r, g, b, a);
**[[Ui::setHudColour|Ui::setHudColour(hudIndex, r, g, b, a)]]
**Ui::linkNamedRendertarget(hash);
**[[Ui::linkNamedRendertarget|Ui::linkNamedRendertarget(hash)]]
**Ui::setMinimapRevealed(toggle);
**[[Ui::setMinimapRevealed|Ui::setMinimapRevealed(toggle)]]
**Ui::beginTextCommandSetBlipName(gxtentry);
**[[Ui::beginTextCommandSetBlipName|Ui::beginTextCommandSetBlipName(gxtentry)]]
**Ui::getBlipInfoIdCoord(p0);
**[[Ui::getBlipInfoIdCoord|Ui::getBlipInfoIdCoord(p0)]]
**Ui::setMultiplayerHudCash(p0, p1);
**[[Ui::setMultiplayerHudCash|Ui::setMultiplayerHudCash(p0, p1)]]
**Ui::setNewWaypoint(x, y);
**[[Ui::setNewWaypoint|Ui::setNewWaypoint(x, y)]]


==Unk==
==Unk==
**Unk::getBroadcastFinshedLosSound(p0);
**[[Unk::getBroadcastFinshedLosSound|Unk::getBroadcastFinshedLosSound(p0)]]


==Recorder==
==Recorder==
Line 1,334: Line 1,334:


==Vehicle==
==Vehicle==
**Vehicle::getRandomVehicleModelInMemory(p0, modelHash, p2);
**[[Vehicle::getRandomVehicleModelInMemory|Vehicle::getRandomVehicleModelInMemory(p0, modelHash, p2)]]
**Vehicle::hasPreloadModsFinished(p0);
**[[Vehicle::hasPreloadModsFinished|Vehicle::hasPreloadModsFinished(p0)]]
**Vehicle::getTotalDurationOfVehicleRecording(p0, p1);
**[[Vehicle::getTotalDurationOfVehicleRecording|Vehicle::getTotalDurationOfVehicleRecording(p0, p1)]]
**Vehicle::setVehicleModelIsSuppressed(model, suppressed);
**[[Vehicle::setVehicleModelIsSuppressed|Vehicle::setVehicleModelIsSuppressed(model, suppressed)]]
**Vehicle::getTotalDurationOfVehicleRecordingId(p0);
**[[Vehicle::getTotalDurationOfVehicleRecordingId|Vehicle::getTotalDurationOfVehicleRecordingId(p0)]]
**Vehicle::hasVehicleAssetLoaded(vehicleAsset);
**[[Vehicle::hasVehicleAssetLoaded|Vehicle::hasVehicleAssetLoaded(vehicleAsset)]]
**Vehicle::isPlaybackGoingOnForVehicle(p0);
**[[Vehicle::isPlaybackGoingOnForVehicle|Vehicle::isPlaybackGoingOnForVehicle(p0)]]
**Vehicle::getRotationOfVehicleRecordingAtTime(p0, p1, p2);
**[[Vehicle::getRotationOfVehicleRecordingAtTime|Vehicle::getRotationOfVehicleRecordingAtTime(p0, p1, p2)]]
**Vehicle::getVehicleRecordingId(p0, p1);
**[[Vehicle::getVehicleRecordingId|Vehicle::getVehicleRecordingId(p0, p1)]]
**Vehicle::deleteScriptVehicleGenerator(vehicleGenerator);
**[[Vehicle::deleteScriptVehicleGenerator|Vehicle::deleteScriptVehicleGenerator(vehicleGenerator)]]
**Vehicle::setVehicleDensityMultiplierThisFrame(multiplier);
**[[Vehicle::setVehicleDensityMultiplierThisFrame|Vehicle::setVehicleDensityMultiplierThisFrame(multiplier)]]
**Vehicle::setFarDrawVehicles(toggle);
**[[Vehicle::setFarDrawVehicles|Vehicle::setFarDrawVehicles(toggle)]]
**Vehicle::startPlaybackRecordedVehicleUsingAi(p0, p1, p2, p3, p4);
**[[Vehicle::startPlaybackRecordedVehicleUsingAi|Vehicle::startPlaybackRecordedVehicleUsingAi(p0, p1, p2, p3, p4)]]
**Vehicle::getVehicleModelMaxNumberOfPassengers(modelHash);
**[[Vehicle::getVehicleModelMaxNumberOfPassengers|Vehicle::getVehicleModelMaxNumberOfPassengers(modelHash)]]
**Vehicle::setGarbageTrucks(toggle);
**[[Vehicle::setGarbageTrucks|Vehicle::setGarbageTrucks(toggle)]]
**Vehicle::getPositionInRecording(p0);
**[[Vehicle::getPositionInRecording|Vehicle::getPositionInRecording(p0)]]
**Vehicle::getVehicleClassMaxAcceleration(p0);
**[[Vehicle::getVehicleClassMaxAcceleration|Vehicle::getVehicleClassMaxAcceleration(p0)]]
**Vehicle::addVehicleStuckCheckWithWarp(p0, p1, p2, p3, p4, p5, p6);
**[[Vehicle::addVehicleStuckCheckWithWarp|Vehicle::addVehicleStuckCheckWithWarp(p0, p1, p2, p3, p4, p5, p6)]]
**Vehicle::hasVehicleRecordingBeenLoaded(p0, p1);
**[[Vehicle::hasVehicleRecordingBeenLoaded|Vehicle::hasVehicleRecordingBeenLoaded(p0, p1)]]
**Vehicle::getRandomVehicleInSphere(x, y, z, radius, modelHash, flags);
**[[Vehicle::getRandomVehicleInSphere|Vehicle::getRandomVehicleInSphere(x, y, z, radius, modelHash, flags)]]
**Vehicle::isThisModelAQuadbike(model);
**[[Vehicle::isThisModelAQuadbike|Vehicle::isThisModelAQuadbike(model)]]
**Vehicle::startPlaybackRecordedVehicle(p0, p1, p2, p3);
**[[Vehicle::startPlaybackRecordedVehicle|Vehicle::startPlaybackRecordedVehicle(p0, p1, p2, p3)]]
**Vehicle::getCurrentPlaybackForVehicle(p0);
**[[Vehicle::getCurrentPlaybackForVehicle|Vehicle::getCurrentPlaybackForVehicle(p0)]]
**Vehicle::isThisModelABoat(model);
**[[Vehicle::isThisModelABoat|Vehicle::isThisModelABoat(model)]]
**Vehicle::removeVehiclesFromGeneratorsInArea(x1, y1, z1, x2, y2, z2, unk);
**[[Vehicle::removeVehiclesFromGeneratorsInArea|Vehicle::removeVehiclesFromGeneratorsInArea(x1, y1, z1, x2, y2, z2, unk)]]
**Vehicle::getVehicleClassMaxBraking(p0);
**[[Vehicle::getVehicleClassMaxBraking|Vehicle::getVehicleClassMaxBraking(p0)]]
**Vehicle::getVehicleClassMaxAgility(p0);
**[[Vehicle::getVehicleClassMaxAgility|Vehicle::getVehicleClassMaxAgility(p0)]]
**Vehicle::getVehicleModelMaxTraction(modelHash);
**[[Vehicle::getVehicleModelMaxTraction|Vehicle::getVehicleModelMaxTraction(modelHash)]]
**Vehicle::stopPlaybackRecordedVehicle(p0);
**[[Vehicle::stopPlaybackRecordedVehicle|Vehicle::stopPlaybackRecordedVehicle(p0)]]
**Vehicle::getTimePositionInRecording(p0);
**[[Vehicle::getTimePositionInRecording|Vehicle::getTimePositionInRecording(p0)]]
**Vehicle::deleteMissionTrain(train);
**[[Vehicle::deleteMissionTrain|Vehicle::deleteMissionTrain(train)]]
**Vehicle::setAllLowPriorityVehicleGeneratorsActive(active);
**[[Vehicle::setAllLowPriorityVehicleGeneratorsActive|Vehicle::setAllLowPriorityVehicleGeneratorsActive(active)]]
**Vehicle::isAnyVehicleNearPoint(x, y, z, radius);
**[[Vehicle::isAnyVehicleNearPoint|Vehicle::isAnyVehicleNearPoint(x, y, z, radius)]]
**Vehicle::pausePlaybackRecordedVehicle(p0);
**[[Vehicle::pausePlaybackRecordedVehicle|Vehicle::pausePlaybackRecordedVehicle(p0)]]
**Vehicle::createMissionTrain(variation, x, y, z, direction);
**[[Vehicle::createMissionTrain|Vehicle::createMissionTrain(variation, x, y, z, direction)]]
**Vehicle::setPlaybackSpeed(p0, speed);
**[[Vehicle::setPlaybackSpeed|Vehicle::setPlaybackSpeed(p0, speed)]]
**Vehicle::setPlaybackToUseAiTryToRevertBackLater(p0, p1, p2, p3);
**[[Vehicle::setPlaybackToUseAiTryToRevertBackLater|Vehicle::setPlaybackToUseAiTryToRevertBackLater(p0, p1, p2, p3)]]
**Vehicle::setVehicleShootAtTarget(driver, entity, xTarget, yTarget, zTarget);
**[[Vehicle::setVehicleShootAtTarget|Vehicle::setVehicleShootAtTarget(driver, entity, xTarget, yTarget, zTarget)]]
**Vehicle::preloadVehicleMod(p0, p1, p2);
**[[Vehicle::preloadVehicleMod|Vehicle::preloadVehicleMod(p0, p1, p2)]]
**Vehicle::startPlaybackRecordedVehicleWithFlags(p0, p1, p2, p3, p4, p5);
**[[Vehicle::startPlaybackRecordedVehicleWithFlags|Vehicle::startPlaybackRecordedVehicleWithFlags(p0, p1, p2, p3, p4, p5)]]
**Vehicle::isCopVehicleInArea3d(x1, x2, y1, y2, z1, z2);
**[[Vehicle::isCopVehicleInArea3d|Vehicle::isCopVehicleInArea3d(x1, x2, y1, y2, z1, z2)]]
**Vehicle::isThisModelACar(model);
**[[Vehicle::isThisModelACar|Vehicle::isThisModelACar(model)]]
**Vehicle::setRandomTrains(toggle);
**[[Vehicle::setRandomTrains|Vehicle::setRandomTrains(toggle)]]
**Vehicle::requestVehicleAsset(vehicleHash, vehicleAsset);
**[[Vehicle::requestVehicleAsset|Vehicle::requestVehicleAsset(vehicleHash, vehicleAsset)]]
**Vehicle::removeVehicleStuckCheck(p0);
**[[Vehicle::removeVehicleStuckCheck|Vehicle::removeVehicleStuckCheck(p0)]]
**Vehicle::setRandomBoats(toggle);
**[[Vehicle::setRandomBoats|Vehicle::setRandomBoats(toggle)]]
**Vehicle::setCargobobHookPosition(p0, p1, p2, p3);
**[[Vehicle::setCargobobHookPosition|Vehicle::setCargobobHookPosition(p0, p1, p2, p3)]]
**Vehicle::unpausePlaybackRecordedVehicle(p0);
**[[Vehicle::unpausePlaybackRecordedVehicle|Vehicle::unpausePlaybackRecordedVehicle(p0)]]
**Vehicle::getVehicleModelAcceleration(modelHash);
**[[Vehicle::getVehicleModelAcceleration|Vehicle::getVehicleModelAcceleration(modelHash)]]
**Vehicle::skipTimeInPlaybackRecordedVehicle(p0, p1);
**[[Vehicle::skipTimeInPlaybackRecordedVehicle|Vehicle::skipTimeInPlaybackRecordedVehicle(p0, p1)]]
**Vehicle::isThisModelAnEmergencyBoat(model);
**[[Vehicle::isThisModelAnEmergencyBoat|Vehicle::isThisModelAnEmergencyBoat(model)]]
**Vehicle::doesVehicleExistWithDecorator(decorator);
**[[Vehicle::doesVehicleExistWithDecorator|Vehicle::doesVehicleExistWithDecorator(decorator)]]
**Vehicle::createScriptVehicleGenerator(x, y, z, heading, p4, p5, modelHash, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
**[[Vehicle::createScriptVehicleGenerator|Vehicle::createScriptVehicleGenerator(x, y, z, heading, p4, p5, modelHash, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16)]]
**Vehicle::isThisModelAPlane(model);
**[[Vehicle::isThisModelAPlane|Vehicle::isThisModelAPlane(model)]]
**Vehicle::getNumModColors(p0, p1);
**[[Vehicle::getNumModColors|Vehicle::getNumModColors(p0, p1)]]
**Vehicle::skipToEndAndStopPlaybackRecordedVehicle(p0);
**[[Vehicle::skipToEndAndStopPlaybackRecordedVehicle|Vehicle::skipToEndAndStopPlaybackRecordedVehicle(p0)]]
**Vehicle::isThisModelATrain(model);
**[[Vehicle::isThisModelATrain|Vehicle::isThisModelATrain(model)]]
**Vehicle::removeVehicleAsset(vehicleAsset);
**[[Vehicle::removeVehicleAsset|Vehicle::removeVehicleAsset(vehicleAsset)]]
**Vehicle::isPlaybackUsingAiGoingOnForVehicle(p0);
**[[Vehicle::isPlaybackUsingAiGoingOnForVehicle|Vehicle::isPlaybackUsingAiGoingOnForVehicle(p0)]]
**Vehicle::createVehicle(modelHash, x, y, z, heading, networkHandle, vehiclehandle);
**[[Vehicle::createVehicle|Vehicle::createVehicle(modelHash, x, y, z, heading, networkHandle, vehiclehandle)]]
**Vehicle::requestVehicleRecording(p0, p1);
**[[Vehicle::requestVehicleRecording|Vehicle::requestVehicleRecording(p0, p1)]]
**Vehicle::getDisplayNameFromVehicleModel(modelHash);
**[[Vehicle::getDisplayNameFromVehicleModel|Vehicle::getDisplayNameFromVehicleModel(modelHash)]]
**Vehicle::setRandomVehicleDensityMultiplierThisFrame(multiplier);
**[[Vehicle::setRandomVehicleDensityMultiplierThisFrame|Vehicle::setRandomVehicleDensityMultiplierThisFrame(multiplier)]]
**Vehicle::getRandomVehicleBackBumperInSphere(p0, p1, p2, p3, p4, p5, p6);
**[[Vehicle::getRandomVehicleBackBumperInSphere|Vehicle::getRandomVehicleBackBumperInSphere(p0, p1, p2, p3, p4, p5, p6)]]
**Vehicle::isThisModelABike(model);
**[[Vehicle::isThisModelABike|Vehicle::isThisModelABike(model)]]
**Vehicle::setMissionTrainAsNoLongerNeeded(train, p1);
**[[Vehicle::setMissionTrainAsNoLongerNeeded|Vehicle::setMissionTrainAsNoLongerNeeded(train, p1)]]
**Vehicle::isThisModelABicycle(model);
**[[Vehicle::isThisModelABicycle|Vehicle::isThisModelABicycle(model)]]
**Vehicle::setAllVehicleGeneratorsActiveInArea(x1, y1, z1, x2, y2, z2, p6, p7);
**[[Vehicle::setAllVehicleGeneratorsActiveInArea|Vehicle::setAllVehicleGeneratorsActiveInArea(x1, y1, z1, x2, y2, z2, p6, p7)]]
**Vehicle::getRandomVehicleFrontBumperInSphere(p0, p1, p2, p3, p4, p5, p6);
**[[Vehicle::getRandomVehicleFrontBumperInSphere|Vehicle::getRandomVehicleFrontBumperInSphere(p0, p1, p2, p3, p4, p5, p6)]]
**Vehicle::setNumberOfParkedVehicles(value);
**[[Vehicle::setNumberOfParkedVehicles|Vehicle::setNumberOfParkedVehicles(value)]]
**Vehicle::isVehicleInGarageArea(garageName, vehicle);
**[[Vehicle::isVehicleInGarageArea|Vehicle::isVehicleInGarageArea(garageName, vehicle)]]
**Vehicle::getPositionOfVehicleRecordingAtTime(p0, p1, p2);
**[[Vehicle::getPositionOfVehicleRecordingAtTime|Vehicle::getPositionOfVehicleRecordingAtTime(p0, p1, p2)]]
**Vehicle::setScriptVehicleGenerator(vehicleGenerator, enabled);
**[[Vehicle::setScriptVehicleGenerator|Vehicle::setScriptVehicleGenerator(vehicleGenerator, enabled)]]
**Vehicle::getVehicleClassMaxTraction(p0);
**[[Vehicle::getVehicleClassMaxTraction|Vehicle::getVehicleClassMaxTraction(p0)]]
**Vehicle::getVehicleModelMaxBraking(modelHash);
**[[Vehicle::getVehicleModelMaxBraking|Vehicle::getVehicleModelMaxBraking(modelHash)]]
**Vehicle::isThisModelAHeli(model);
**[[Vehicle::isThisModelAHeli|Vehicle::isThisModelAHeli(model)]]
**Vehicle::getVehicleClassFromName(modelHash);
**[[Vehicle::getVehicleClassFromName|Vehicle::getVehicleClassFromName(modelHash)]]
**Vehicle::setParkedVehicleDensityMultiplierThisFrame(multiplier);
**[[Vehicle::setParkedVehicleDensityMultiplierThisFrame|Vehicle::setParkedVehicleDensityMultiplierThisFrame(multiplier)]]
**Vehicle::removeVehicleRecording(p0, p1);
**[[Vehicle::removeVehicleRecording|Vehicle::removeVehicleRecording(p0, p1)]]
**Vehicle::getVehicleModelMaxSpeed(modelHash);
**[[Vehicle::getVehicleModelMaxSpeed|Vehicle::getVehicleModelMaxSpeed(modelHash)]]
**Vehicle::disableVehicleWeapon(disabled, weaponHash, vehicle, owner);
**[[Vehicle::disableVehicleWeapon|Vehicle::disableVehicleWeapon(disabled, weaponHash, vehicle, owner)]]
**Vehicle::doesScriptVehicleGeneratorExist(vehicleGenerator);
**[[Vehicle::doesScriptVehicleGeneratorExist|Vehicle::doesScriptVehicleGeneratorExist(vehicleGenerator)]]
**Vehicle::getClosestVehicle(x, y, z, radius, modelHash, flags);
**[[Vehicle::getClosestVehicle|Vehicle::getClosestVehicle(x, y, z, radius, modelHash, flags)]]
**Vehicle::displayDistantVehicles(toggle);
**[[Vehicle::displayDistantVehicles|Vehicle::displayDistantVehicles(toggle)]]
**Vehicle::switchTrainTrack(intersectionId, state);
**[[Vehicle::switchTrainTrack|Vehicle::switchTrainTrack(intersectionId, state)]]


==Water==
==Water==
**Water::testVerticalProbeAgainstAllWater(x, y, z, p3, p4);
**[[Water::testVerticalProbeAgainstAllWater|Water::testVerticalProbeAgainstAllWater(x, y, z, p3, p4)]]
**Water::testProbeAgainstAllWater(p0, p1, p2, p3, p4, p5, p6, p7);
**[[Water::testProbeAgainstAllWater|Water::testProbeAgainstAllWater(p0, p1, p2, p3, p4, p5, p6, p7)]]
**Water::getWaterHeightNoWaves(x, y, z, height);
**[[Water::getWaterHeightNoWaves|Water::getWaterHeightNoWaves(x, y, z, height)]]
**Water::setWavesIntensity(intensity);
**[[Water::setWavesIntensity|Water::setWavesIntensity(intensity)]]
**Water::modifyWater(x, y, radius, height);
**[[Water::modifyWater|Water::modifyWater(x, y, radius, height)]]
**Water::getWaterHeight(x, y, z, height);
**[[Water::getWaterHeight|Water::getWaterHeight(x, y, z, height)]]
**Water::testProbeAgainstWater(p0, p1, p2, p3, p4, p5, p6);
**[[Water::testProbeAgainstWater|Water::testProbeAgainstWater(p0, p1, p2, p3, p4, p5, p6)]]


==Weapon==
==Weapon==
**Weapon::getWeaponComponentTypeModel(componentHash);
**[[Weapon::getWeaponComponentTypeModel|Weapon::getWeaponComponentTypeModel(componentHash)]]
**Weapon::giveWeaponComponentToWeaponObject(weaponObject, addonHash);
**[[Weapon::giveWeaponComponentToWeaponObject|Weapon::giveWeaponComponentToWeaponObject(weaponObject, addonHash)]]
**Weapon::hasWeaponAssetLoaded(weaponHash);
**[[Weapon::hasWeaponAssetLoaded|Weapon::hasWeaponAssetLoaded(weaponHash)]]
**Weapon::getWeaponDamageType(weaponHash);
**[[Weapon::getWeaponDamageType|Weapon::getWeaponDamageType(weaponHash)]]
**Weapon::getWeapontypeSlot(weaponHash);
**[[Weapon::getWeapontypeSlot|Weapon::getWeapontypeSlot(weaponHash)]]
**Weapon::requestWeaponHighDetailModel(weaponObject);
**[[Weapon::requestWeaponHighDetailModel|Weapon::requestWeaponHighDetailModel(weaponObject)]]
**Weapon::requestWeaponAsset(weaponHash, p1, p2);
**[[Weapon::requestWeaponAsset|Weapon::requestWeaponAsset(weaponHash, p1, p2)]]
**Weapon::getWeaponClipSize(weaponHash);
**[[Weapon::getWeaponClipSize|Weapon::getWeaponClipSize(weaponHash)]]
**Weapon::doesWeaponTakeWeaponComponent(weaponHash, componentHash);
**[[Weapon::doesWeaponTakeWeaponComponent|Weapon::doesWeaponTakeWeaponComponent(weaponHash, componentHash)]]
**Weapon::getWeaponTintCount(weaponHash);
**[[Weapon::getWeaponTintCount|Weapon::getWeaponTintCount(weaponHash)]]
**Weapon::hasVehicleGotProjectileAttached(driver, vehicle, weapon, p3);
**[[Weapon::hasVehicleGotProjectileAttached|Weapon::hasVehicleGotProjectileAttached(driver, vehicle, weapon, p3)]]
**Weapon::hasWeaponGotWeaponComponent(weapon, addonHash);
**[[Weapon::hasWeaponGotWeaponComponent|Weapon::hasWeaponGotWeaponComponent(weapon, addonHash)]]
**Weapon::isWeaponValid(weaponHash);
**[[Weapon::isWeaponValid|Weapon::isWeaponValid(weaponHash)]]
**Weapon::createWeaponObject(weaponHash, ammoCount, x, y, z, showWorldModel, heading, p7);
**[[Weapon::createWeaponObject|Weapon::createWeaponObject(weaponHash, ammoCount, x, y, z, showWorldModel, heading, p7)]]
**Weapon::setPedAmmoToDrop(p0, p1);
**[[Weapon::setPedAmmoToDrop|Weapon::setPedAmmoToDrop(p0, p1)]]
**Weapon::removeWeaponAsset(weaponHash);
**[[Weapon::removeWeaponAsset|Weapon::removeWeaponAsset(weaponHash)]]
**Weapon::giveWeaponObjectToPed(weaponObject, ped);
**[[Weapon::giveWeaponObjectToPed|Weapon::giveWeaponObjectToPed(weaponObject, ped)]]
**Weapon::getWeaponComponentHudStats(p0, p1);
**[[Weapon::getWeaponComponentHudStats|Weapon::getWeaponComponentHudStats(p0, p1)]]
**Weapon::canUseWeaponOnParachute(weaponHash);
**[[Weapon::canUseWeaponOnParachute|Weapon::canUseWeaponOnParachute(weaponHash)]]
**Weapon::getWeapontypeGroup(weaponHash);
**[[Weapon::getWeapontypeGroup|Weapon::getWeapontypeGroup(weaponHash)]]
**Weapon::enableLaserSightRendering(toggle);
**[[Weapon::enableLaserSightRendering|Weapon::enableLaserSightRendering(toggle)]]
**Weapon::getWeaponObjectTintIndex(weapon);
**[[Weapon::getWeaponObjectTintIndex|Weapon::getWeaponObjectTintIndex(weapon)]]
**Weapon::setFlashLightFadeDistance(distance);
**[[Weapon::setFlashLightFadeDistance|Weapon::setFlashLightFadeDistance(distance)]]
**Weapon::getWeaponHudStats(p0, p1);
**[[Weapon::getWeaponHudStats|Weapon::getWeaponHudStats(p0, p1)]]
**Weapon::getWeapontypeModel(weaponHash);
**[[Weapon::getWeapontypeModel|Weapon::getWeapontypeModel(weaponHash)]]
**Weapon::removeWeaponComponentFromWeaponObject(p0, p1);
**[[Weapon::removeWeaponComponentFromWeaponObject|Weapon::removeWeaponComponentFromWeaponObject(p0, p1)]]
**Weapon::setWeaponObjectTintIndex(weapon, tint);
**[[Weapon::setWeaponObjectTintIndex|Weapon::setWeaponObjectTintIndex(weapon, tint)]]
**Weapon::removeAllProjectilesOfType(weaponHash, p1);
**[[Weapon::removeAllProjectilesOfType|Weapon::removeAllProjectilesOfType(weaponHash, p1)]]


==Worldprobe==
==Worldprobe==
**Worldprobe::startShapeTestCapsule(x1, y1, z1, x2, y2, z2, radius, flags, entity, p9);
**[[Worldprobe::startShapeTestCapsule|Worldprobe::startShapeTestCapsule(x1, y1, z1, x2, y2, z2, radius, flags, entity, p9)]]
**Worldprobe::castRayPointToPoint(x1, y1, z1, x2, y2, z2, flags, entity, p8);
**[[Worldprobe::castRayPointToPoint|Worldprobe::castRayPointToPoint(x1, y1, z1, x2, y2, z2, flags, entity, p8)]]
**Worldprobe::getShapeTestResult(rayHandle, hit, endCoords, surfaceNormal, entityHit);
**[[Worldprobe::getShapeTestResult|Worldprobe::getShapeTestResult(rayHandle, hit, endCoords, surfaceNormal, entityHit)]]
**Worldprobe::getShapeTestResultEx(rayHandle, hit, endCoords, surfaceNormal, _materialHash, entityHit);
**[[Worldprobe::getShapeTestResultEx|Worldprobe::getShapeTestResultEx(rayHandle, hit, endCoords, surfaceNormal, _materialHash, entityHit)]]
**Worldprobe::startShapeTestLosProbe(x1, y1, z1, x2, y2, z2, flags, entity, p8);
**[[Worldprobe::startShapeTestLosProbe|Worldprobe::startShapeTestLosProbe(x1, y1, z1, x2, y2, z2, flags, entity, p8)]]
**Worldprobe::startShapeTestBox(x, y, z, x1, y2, z2, rotX, rotY, rotZ, p9, p10, entity, p12);
**[[Worldprobe::startShapeTestBox|Worldprobe::startShapeTestBox(x, y, z, x1, y2, z2, rotX, rotY, rotZ, p9, p10, entity, p12)]]


==Zone==
==Zone==
**Zone::getZoneAtCoords(x, y, z);
**[[Zone::getZoneAtCoords|Zone::getZoneAtCoords(x, y, z)]]
**Zone::getZonePopschedule(zoneId);
**[[Zone::getZonePopschedule|Zone::getZonePopschedule(zoneId)]]
**Zone::clearPopscheduleOverrideVehicleModel(scheduleId);
**[[Zone::clearPopscheduleOverrideVehicleModel|Zone::clearPopscheduleOverrideVehicleModel(scheduleId)]]
**Zone::getZoneScumminess(zoneId);
**[[Zone::getZoneScumminess|Zone::getZoneScumminess(zoneId)]]
**Zone::overridePopscheduleVehicleModel(scheduleId, vehicleHash);
**[[Zone::overridePopscheduleVehicleModel|Zone::overridePopscheduleVehicleModel(scheduleId, vehicleHash)]]
**Zone::getHashOfMapAreaAtCoords(x, y, z);
**[[Zone::getHashOfMapAreaAtCoords|Zone::getHashOfMapAreaAtCoords(x, y, z)]]
**Zone::getZoneFromNameId(zoneName);
**[[Zone::getZoneFromNameId|Zone::getZoneFromNameId(zoneName)]]
**Zone::setZoneEnabled(zoneId, toggle);
**[[Zone::setZoneEnabled|Zone::setZoneEnabled(zoneId, toggle)]]
**Zone::getNameOfZone(x, y, z);
**[[Zone::getNameOfZone|Zone::getNameOfZone(x, y, z)]]


==Game Globals==
==Game Globals==
Line 1,497: Line 1,497:
**GameGlobals::itemset
**GameGlobals::itemset
**GameGlobals::mobile
**GameGlobals::mobile
**GameGlobals::networkcash
**GameGlobals::object
**GameGlobals::object
**GameGlobals::pathfind
**GameGlobals::pathfind
Line 1,516: Line 1,515:
**GameGlobals::worldprobe
**GameGlobals::worldprobe
**GameGlobals::zone
**GameGlobals::zone
[[ru:Client-side functions]]

Revision as of 20:23, 5 May 2017

Attention: work is still in progress. There still could be major changes in design of API.

Event functions

Vector3 functions

Entity (player, vehicle, object) functions

Player functions

Vehicle functions

Object functions

  • [[Object::disableGlow|mp.game.object.disableGlow

Pickup functions

Template:Pickup function c

Blip functions

Camera functions

Entity pool functions

WebBrowser functions

Key binding functions

UI functions

Template:UI function c

Global functions

App

Audio

Brain

Cam

Controls

Cutscene

Datafile

Decisionevent

Decorator

Dlc1

Dlc2

Entity

Fire

Gameplay

Graphics

Interior

Itemset

Mobile

Object

Pathfind

Ped

Player

Rope

Script

Stats

Streaming

System

Time

Ui

Unk

Recorder

    • Recorder::start(mode);
    • Recorder::stop(save);
    • Recorder::isRecording();

Vehicle

Water

Weapon

Worldprobe

Zone

Game Globals

    • GameGlobals::app
    • GameGlobals::audio
    • GameGlobals::brain
    • GameGlobals::cam
    • GameGlobals::controls
    • GameGlobals::cutscene
    • GameGlobals::datafile
    • GameGlobals::decisionevent
    • GameGlobals::decorator
    • GameGlobals::dlc1
    • GameGlobals::dlc2
    • GameGlobals::entity
    • GameGlobals::fire
    • GameGlobals::gameplay
    • GameGlobals::graphics
    • GameGlobals::interior
    • GameGlobals::itemset
    • GameGlobals::mobile
    • GameGlobals::object
    • GameGlobals::pathfind
    • GameGlobals::ped
    • GameGlobals::player
    • GameGlobals::rope
    • GameGlobals::script
    • GameGlobals::stats
    • GameGlobals::streaming
    • GameGlobals::system
    • GameGlobals::time
    • GameGlobals::ui
    • GameGlobals::unk
    • GameGlobals::recorder
    • GameGlobals::vehicle
    • GameGlobals::water
    • GameGlobals::weapon
    • GameGlobals::worldprobe
    • GameGlobals::zone