Client-side functions: Difference between revisions

From RAGE Multiplayer Wiki
No edit summary
 
(177 intermediate revisions by 31 users not shown)
Line 1: Line 1:
Attention: work is still in progress. There still could be major changes in design of API.


==Event functions==
==RAGE Classes==
{{Event_functions}}
===Entity pool===
*[[Events::callRemote]]
{{EntityPool_Client_functions}}


==Vector3 functions==
===Blip===
{{Vector3_functions}}
{{Blip_definition_c}}


==Entity (player, vehicle, object) functions==
===Browser===
{{Entity_function_c}}
{{Browser_definition_c}}


==Player functions==
===Camera===
{{Player_function_c}}
{{Camera_definition_c}}


==Vehicle functions==
===Checkpoint===
{{Vehicle_function_c}}
*[[Checkpoint::Checkpoint]]


==Object functions==
===Dummy Entity===
{{Object_function_c}}
{{Dummies_definition_c}}


==Pickup functions==
===Entity===
{{Pickup_function_c}}
{{Entity_definition_c}}


==Blip functions==
===Label===
{{Blip_function_c}}
{{Label_definition_c}}


==Camera functions==
===Marker===
{{Camera_function_c}}
{{Marker_definition_c}}


==Entity pool functions==
===Object===
{{EntityPool_function}}
{{Object_definition_c}}


==WebBrowser functions==
===Peds===
{{WebBrowser_function_c}}
*[[Ped::Ped]]


==Key binding functions==
===Pickup===
{{KeyBinding_function_c}}
*[[Pickup::Pickup]]


==UI functions==
===Player===
{{UI_function_c}}
{{Player_definition_c}}


==Global functions==
===Vector3===
{{Global_function_c}}
{{Vector3_definition}}


==App==
===Vehicle===
**App::appGetFloat(property);
{{Vehicle_definition_c}}
**App::appSetFloat(property, value);
**App::appSetBlock(blockName);
**App::appSetString(property, value);
**App::appDeleteAppData(appName);
**App::appSetInt(property, value);
**App::appGetString(property);
**App::appHasSyncedData(appName);
**App::appSetApp(appName);
**App::appGetInt(property);


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


==Brain==
=== Console ===
**Brain::registerObjectScriptBrain(scriptName, p1, p2, p3, p4, p5);
{{Console_definition_c}}
**Brain::disableScriptBrainSet(brainSet);
**Brain::registerWorldPointScriptBrain(p0, p1, p2);
**Brain::addScriptToRandomPed(name, model, p2, p3);
**Brain::enableScriptBrainSet(brainSet);
**Brain::isObjectWithinBrainActivationRange(object);


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


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


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


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


==Decisionevent==
===Keys===
**Decisionevent::isShockingEventInSphere(type, x, y, z, radius);
{{Keys_functions_c}}
**Decisionevent::removeShockingEvent(event);
**Decisionevent::suppressShockingEventTypeNextFrame(type);
**Decisionevent::clearDecisionMakerEventResponse(name, type);
**Decisionevent::addShockingEventForEntity(type, entity, duration);
**Decisionevent::unblockDecisionMakerEvent(name, type);
**Decisionevent::addShockingEventAtPosition(type, x, y, z, duration);
**Decisionevent::blockDecisionMakerEvent(name, type);
**Decisionevent::removeAllShockingEvents(p0);


==Decorator==
===Nametags===
**Decorator::decorIsRegisteredAsType(propertyName, type);
{{Nametags_functions_c}}
**Decorator::decorRegister(propertyName, type);


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


==Dlc2==
===Raycasting===
**Dlc2::nullify(variable, unused);
{{Raycast_functions_c}}
**Dlc2::isDlcPresent(DlcHash);


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


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


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


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


==Interior==
*Properties:
**Interior::getInteriorAtCoordsWithType(x, y, z, interiorType);
**[[Client-side_functions#App|mp.game.app]]
**Interior::unpinInterior(interiorID);
**[[Client-side_functions#Audio|mp.game.audio]]
**Interior::isValidInterior(interiorID);
**[[Client-side_functions#Brain|mp.game.brain]]
**Interior::isInteriorPropEnabled(interiorID, propName);
**[[Client-side_functions#Cam|mp.game.cam]]
**Interior::addPickupToInteriorRoomByName(pickup, roomName);
**[[Client-side_functions#Controls|mp.game.controls]]
**Interior::refreshInterior(interiorID);
**[[Client-side_functions#Cutscene|mp.game.cutscene]]
**Interior::disableInteriorProp(interiorID, propName);
**[[Client-side_functions#Datafile|mp.game.datafile]]
**Interior::enableInteriorProp(interiorID, propName);
**[[Client-side_functions#Decisionevent|mp.game.decisionevent]]
**Interior::disableInterior(interiorID, toggle);
**[[Client-side_functions#Decorator|mp.game.decorator]]
**Interior::isInteriorReady(interiorID);
**[[Client-side_functions#Task|mp.game.task]]
**Interior::isInteriorCapped(interiorID);
**[[Client-side_functions#Dlc1|mp.game.dlc1]]
**Interior::getOffsetFromInteriorInWorldCoords(interiorID, x, y, z);
**[[Client-side_functions#Dlc2|mp.game.dlc2]]
**Interior::hideMapObjectThisFrame(mapObjectHash);
**[[Client-side_functions#GameEntity|mp.game.entity]]
**Interior::getInteriorAtCoords(x, y, z);
**[[Client-side_functions#Fire|mp.game.fire]]
**Interior::isInteriorDisabled(interiorID);
**[[Client-side_functions#Gameplay|mp.game.gameplay]]
**Interior::capInterior(interiorID, toggle);
**[[Client-side_functions#Graphics|mp.game.graphics]]
**Interior::getInteriorGroupId(interiorID);
**[[Client-side_functions#GXT|mp.game.gxt]]
**Interior::getInteriorFromCollision(x, y, z);
**[[Client-side_functions#Interior|mp.game.interior]]
**Interior::areCoordsCollidingWithExterior(x, y, z);
**[[Client-side_functions#Itemset|mp.game.itemset]]
**Interior::unkGetInteriorAtCoords(x, y, z, unk);
**[[Client-side_functions#Mobile|mp.game.mobile]]
**[[Client-side_functions#Object|mp.game.object]]
**[[Client-side_functions#Pathfind|mp.game.pathfind]]
**[[Client-side_functions#Ped|mp.game.ped]]
**[[Client-side_functions#Player|mp.game.player]]
**[[Client-side_functions#Rope|mp.game.rope]]
**[[Client-side_functions#Script|mp.game.script]]
**[[Client-side_functions#Stats|mp.game.stats]]
**[[Client-side_functions#Streaming|mp.game.streaming]]
**[[Client-side_functions#System (Game)|mp.game.system]]
**[[Client-side_functions#Time|mp.game.time]]
**[[Client-side_functions#Ui|mp.game.ui]]
**[[Client-side_functions#Unk|mp.game.unk]]
**[[Client-side_functions#Recorder|mp.game.recorder]]
**[[Client-side_functions#Vehicle|mp.game.vehicle]]
**[[Client-side_functions#Water|mp.game.water]]
**[[Client-side_functions#Weapon|mp.game.weapon]]
**[[Client-side_functions#Worldprobe|mp.game.worldprobe]]
**[[Client-side_functions#Zone|mp.game.zone]]
**[[Client-side_functions#Replay|mp.game.replay]]
**[[Client-side_functions#GameClock|mp.game.clock]]
**[[Client-side_functions#GameFiles|mp.game.files]]


==Itemset==
===App===
**Itemset::removeFromItemset(p0, p1);
{{App_functions_c}}
**Itemset::isInItemset(p0, p1);
**Itemset::createItemset(p0);
**Itemset::cleanItemset(p0);
**Itemset::getIndexedItemInItemset(p0, p1);
**Itemset::isItemsetValid(p0);
**Itemset::getItemsetSize(p0);
**Itemset::destroyItemset(p0);
**Itemset::addToItemset(p0, p1);


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


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


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


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


==Player==
===Task===
**Player::setModel(model);
{{Task_functions_c}}
**Player::setWantedLevelMultiplier(multiplier);
**Player::setTeam(team);
**Player::changePed(pedb2b3);
**Player::setAllRandomPedsFlee(toggle);
**Player::isSpecialAbilityMeterFull();
**Player::getWantedLevelRadius();
**Player::areStarsGreyedOut();
**Player::getWantedCentrePosition();
**Player::getGroup();
**Player::clearParachuteVariationOverride();
**Player::setForcedAim(toggle);
**Player::clearParachutePackModelOverride();
**Player::setResetFlagPreferRearSeats(flags);
**Player::getTargetEntity(entity);
**Player::setClothLockCounter(value);
**Player::enableSpecialAbility(toggle);
**Player::getSprintTimeRemaining();
**Player::resetInputGait();
**Player::specialAbilityDepleteMeter(p1);
**Player::setMayNotEnterAnyVehicle();
**Player::hasDamagedAtLeastOnePed();
**Player::isWantedLevelGreater(wantedLevel);
**Player::setInvincible(toggle);
**Player::getEntityIsFreeAimingAt(entity);
**Player::setLockonRangeOverride(range);
**Player::resetArrestState();
**Player::setWeaponDefenseModifier(modifier);
**Player::isFreeAiming();
**Player::specialAbilityChargeSmall(p1p2);
**Player::setDisableAmbientMeleeMove(toggle);
**Player::getCurrentStealthNoise();
**Player::setPoliceIgnore(toggle);
**Player::setWantedLevelNoDrop(wantedLevelp2);
**Player::getTeam();
**Player::specialAbilityReset();
**Player::isBeingArrested(atArresting);
**Player::setWantedLevel(wantedLeveldisableNoMission);
**Player::isFreeAimingAtEntity(entity);
**Player::giveRagdollControl(toggle);
**Player::specialAbilityFillMeter(p1);
**Player::isSpecialAbilityActive();
**Player::getSprintStaminaRemaining();
**Player::intToindex(value);
**Player::isDead();
**Player::setPoliceRadarBlips(toggle);
**Player::getPed();
**Player::setAllRandomPedsFleeThisFrame();
**Player::simulateInputGait(amountgaitTypespeedp4p5);
**Player::isControlOn();
**Player::setMeleeWeaponDamageModifier(modifier);
**Player::clearHasDamagedAtLeastOneNonAnimalPed();
**Player::setVehicleDefenseModifier(modifier);
**Player::forceCleanupForAllThreadsWithThisName(name, cleanupFlags);
**Player::setStealthPerceptionModifier(value);
**Player::isRidingTrain();
**Player::getPedScriptIndex();
**Player::setWantedCentrePosition(xyz);
**Player::setIgnoreLowPriorityShockingEvents(toggle);
**Player::setLockon(toggle);
**Player::getTimeSinceHitVehicle();
**Player::setHealthRechargeMultiplier(regenRate);
**Player::getHasReserveParachute();
**Player::disableFiring(toggle);
**Player::isPlaying();
**Player::specialAbilityLock(playerModel);
**Player::getName();
**Player::setRunSprintMultiplierFor(multiplier);
**Player::setCanDoDriveBy(toggle);
**Player::getParachutePackTintIndex(tintIndex);
**Player::setClothPinFrames(toggle);
**Player::getParachuteTintIndex(tintIndex);
**Player::setForcedZoom(toggle);
**Player::setForceSkipAimIntro(toggle);
**Player::setMaxArmour(value);
**Player::isTargettingAnything();
**Player::isTargettingEntity(entity);
**Player::setHasReserveParachute();
**Player::setMayOnlyEnterThisVehicle(vehicle);
**Player::setParachuteSmokeTrailColor(rgb);
**Player::hasAchievementBeenPassed(achievement);
**Player::clearParachuteModelOverride();
**Player::isScriptControlOn();
**Player::setControl(togglepossiblyFlags);
**Player::setEveryoneIgnore(toggle);
**Player::isReadyForCutscene();
**Player::getMaxArmour();
**Player::setParachutePackTintIndex(tintIndex);
**Player::displaySystemSigninUi(unk);
**Player::isClimbing();
**Player::setParachuteModelOverride(model);
**Player::reserveEntityExplodesOnHighExplosionCombo(p1);
**Player::setWantedLevelDifficulty(difficulty);
**Player::specialAbilityDeactivateFast();
**Player::intToParticipantindex(value);
**Player::setAutoGiveParachuteWhenEnterPlane(toggle);
**Player::setClothPackageIndex(index);
**Player::setSprint(toggle);
**Player::specialAbilityChargeNormalized(normalizedValuep2);
**Player::getUnderwaterTimeRemaining();
**Player::restoreStamina(p1);
**Player::setParachuteTintIndex(tintIndex);
**Player::setSpecialAbilityMultiplier(multiplier);
**Player::setVehicleDamageModifier(damageAmount);
**Player::resetStamina();
**Player::setSwimMultiplierFor(multiplier);
**Player::setMaxWantedLevel(maxWantedLevel);
**Player::startTeleport(xyzheadingp5p6p7);
**Player::setMeleeWeaponDefenseModifier(modifier);
**Player::setReserveParachuteTintIndex(index);
**Player::areFlashingStarsAboutToDrop();
**Player::setTargetingMode(targetMode);
**Player::isSpecialAbilityEnabled();
**Player::setSneakingNoiseMultiplier(multiplier);
**Player::clearWantedLevel();
**Player::getInvincible();
**Player::specialAbilityChargeAbsolute(p1p2);
**Player::resetWantedLevelDifficulty();
**Player::forceCleanup(cleanupFlags);
**Player::giveAchievementTo(achievement);
**Player::startFiringAmnesty(duration);
**Player::disableVehicleRewards();
**Player::setAreasGeneratorOrientation();
**Player::setSimulateAiming(toggle);
**Player::isSpecialAbilityUnlocked(playerModel);
**Player::hasForceCleanupOccurred(cleanupFlags);
**Player::setAirDragMultiplierForsVehicle(multiplier);
**Player::setWeaponDamageModifier(damageAmount);
**Player::setCanUseCover(toggle);
**Player::getTimeSinceDroveOnPavement();
**Player::hasLeftTheWorld();
**Player::getReserveParachuteTintIndex(index);
**Player::setCanBeHassledByGangs(toggle);
**Player::specialAbilityDeactivate();
**Player::hasBeenSpottedInStolenVehicle();
**Player::setParachuteVariationOverride(p1p2p3p4);
**Player::setDispatchCopsFor(toggle);
**Player::getTimeSinceDroveAgainstTraffic();
**Player::setNoiseMultiplier(multiplier);
**Player::setParachutePackModelOverride(model);
**Player::isFreeForAmbientTask();
**Player::setHudAnimStopLevel(toggle);
**Player::canStartMission();
**Player::setWantedLevelNow(p1);
**Player::hasTeleportFinished();
**Player::getWantedLevel();
**Player::getTimeSinceHitPed();
**Player::hasDamagedAtLeastOneNonAnimalPed();
**Player::getRgbColour(rgb);
**Player::reportCrime(crimeTypewantedLvlThresh);
**Player::specialAbilityChargeContinuous(p1);
**Player::playerAttachVirtualBound(p0, p1, p2, p3, p4, p5, p6, p7);
**Player::getParachuteSmokeTrailColor(rgb);
**Player::clearHasDamagedAtLeastOnePed();
**Player::specialAbilityChargeMedium(p1p2);
**Player::specialAbilityUnlock(playerModel);
**Player::canPedHear(ped);
**Player::removeHelmet(p2);
**Player::setCanLeaveParachuteSmokeTrail(enabled);
**Player::specialAbilityChargeLarge(p1p2);
**Player::forceCleanupForThreadWithThisId(id, cleanupFlags);
**Player::isPressingHorn();
**Player::getWantedLevelThreshold(wantedLevel);


==Rope==
===GameEntity===
**Rope::setDisableFragDamage(object, toggle);
{{Entity_functions_c}}
**Rope::startRopeWinding(rope);
**Rope::getRopeLastVertexCoord(rope);
**Rope::pinRopeVertex(rope, vertex, x, y, z);
**Rope::breakEntityGlass(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
**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::attachRopeToEntity(rope, entity, x, y, z, p5);
**Rope::unpinRopeVertex(rope, vertex);
**Rope::deleteRope(rope);
**Rope::ropeConvertToSimple(rope);
**Rope::startRopeUnwindingFront(rope);
**Rope::setDisableBreaking(rope, enabled);
**Rope::getRopeLength(rope);
**Rope::getCgoffset(rope);
**Rope::deleteChildRope(rope);
**Rope::detachRopeFromEntity(rope, entity);
**Rope::setCgAtBoundcenter(rope);
**Rope::ropeResetLength(rope, length);
**Rope::ropeSetUpdatePinverts(rope);
**Rope::stopRopeWinding(rope);
**Rope::loadRopeData(rope, rope_preset);
**Rope::ropeForceLength(rope, length);
**Rope::setCgoffset(rope, x, y, z);
**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::getRopeVertexCoord(rope, vertex);
**Rope::setDamping(rope, vertex, value);
**Rope::ropeDrawShadowEnabled(rope, toggle);
**Rope::doesRopeExist(rope);
**Rope::stopRopeUnwindingFront(rope);


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


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


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


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


==Time==
===DLC===
**Time::pauseClock(toggle);
{{Dlc1_functions_c}}
**Time::setClockTime(hour, minute, second);
**Time::getLocalTime(year, month, day, hour, minute, second);
**Time::getLocalTimeGmt(year, month, day, hour, minute, second);
**Time::setClockDate(day, month, year);
**Time::advanceClockTimeTo(hour, minute, second);
**Time::addToClockTime(hours, minutes, seconds);
**Time::getPosixTime(year, month, day, hour, minute, second);


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


==Unk==
===Fire===
**Unk::getBroadcastFinshedLosSound(p0);
{{Fire_functions_c}}


==Unk1==
===Gameplay===
**Unk1::startRecording(mode);
{{Gameplay_functions_c}}


==Unk2==
===Replay===
{{Replay_functions_c}}


==Unk3==
===GameClock===
**Unk3::networkShopBasketStart(p0, p1, p2, p3);
{{GameClock_functions_c}}
**Unk3::networkShopSessionApplyReceivedData(p0);
**Unk3::networkShopCheckoutStart(p0);
**Unk3::networkShopBeginService(p0, p1, p2, p3, p4, p5);
**Unk3::networkShopSetTelemetryNonceSeed(p0);
**Unk3::networkShopStartSession(p0);
**Unk3::networkShopGetPrice(hash, hash2, p2);
**Unk3::networkShopBasketApplyServerData(p0, p1);
**Unk3::networkShopEndService(p0);
**Unk3::networkShopBasketAddItem(p0, p1);


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


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


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


==Worldprobe==
===Interior===
**Worldprobe::startShapeTestCapsule(x1, y1, z1, x2, y2, z2, radius, flags, entity, p9);
{{Interior_functions_c}}
**Worldprobe::castRayPointToPoint(x1, y1, z1, x2, y2, z2, flags, entity, p8);
**Worldprobe::getShapeTestResult(rayHandle, hit, endCoords, surfaceNormal, entityHit);
**Worldprobe::getShapeTestResultEx(rayHandle, hit, endCoords, surfaceNormal, _materialHash, entityHit);
**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);


==Zone==
===Itemset===
**Zone::getZoneAtCoords(x, y, z);
{{Itemset_functions_c}}
**Zone::getZonePopschedule(zoneId);
**Zone::clearPopscheduleOverrideVehicleModel(scheduleId);
**Zone::getZoneScumminess(zoneId);
**Zone::overridePopscheduleVehicleModel(scheduleId, vehicleHash);
**Zone::getHashOfMapAreaAtCoords(x, y, z);
**Zone::getZoneFromNameId(zoneName);
**Zone::setZoneEnabled(zoneId, toggle);
**Zone::getNameOfZone(x, y, z);


==Game Globals==
===Mobile===
**GameGlobals::app
{{Mobile_functions_c}}
**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::networkcash
**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::unk1
**GameGlobals::unk2
**GameGlobals::unk3
**GameGlobals::vehicle
**GameGlobals::water
**GameGlobals::weapon
**GameGlobals::worldprobe
**GameGlobals::zone


[[ru:Client-side functions]]
===Object===
{{Object_functions_c}}
 
===Pathfind===
{{Path_functions_c}}
 
===Ped===
{{Ped_functions_c}}
 
===Player===
{{Player_functions_c}}
 
===Recorder===
*[[Recorder::start|mp.game.recorder.start]]
*[[Recorder::stop|mp.game.recorder.stop]]
*[[Recorder::isRecording|mp.game.recorder.isRecording]]
 
===Rope===
{{Rope_functions_c}}
 
===Script===
{{Script_functions_c}}
 
===Stats===
{{Stats_functions_c}}
 
===Streaming===
{{Streaming_functions_c}}
 
===System (Game)===
{{System_functions_c}}
 
===Time===
{{Time_functions_c}}
 
===Ui===
{{Ui_functions_c}}
 
===Unk===
*[[Unk::getBroadcastFinishedLosSound|mp.game.unk.getBroadcastFinishedLosSound]]
 
===Vehicle===
{{Vehicle_functions_c}}
 
===Water===
{{Water_functions_c}}
 
===Weapon===
{{Weapon_functions_c}}
 
===Worldprobe===
{{Worldprobe_functions_c}}
 
===Zone===
{{Zone_functions_c}}

Latest revision as of 17:42, 16 March 2025

RAGE Classes

Entity pool

Blip

Browser

Camera

Checkpoint

Dummy Entity

Entity

Label

Marker

Object

Peds

Pickup

Player

Vector3

Vehicle

RAGE Static Objects

Globals

Console

Cursor

Discord

Event

Gui

Keys

Nametags

Preferences

Raycasting

Storage

System

Voice chat

Game Static Objects

Game Globals

App

Audio

Brain

Cam

Controls

Task

GameEntity

Cutscene

Datafile

Decisionevent

Decorator

DLC

DLC2

Fire

Gameplay

Replay

GameClock

GameFiles

Graphics

GXT

Interior

Itemset

Mobile

Object

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

Pathfind

Ped

Player

Recorder

Rope

Script

Stats

Streaming

System (Game)

Time

Ui

Unk

Vehicle

Water

Weapon

Worldprobe

Zone

Retrieved from "https://wiki.rage.mp/w/index.php?title=Client-side_functions&oldid=27475"