Почти все возможности взаимодействия с игрой в MoonLoader реализованы посредством эмуляции опкодов, которые используются в игре для программирования миссий. Многие опкоды не вошли в релиз MoonLoader с самой первой версии, часть вошедших опкодов позже была заменена встроенными реализациями в обновлениях.
Следующая таблица содержит все опкоды игры, где каждому опкоду соответствует его аналог в Lua и комментарий о различиях или причинах отсутствия.
Отсутствие пояснения к опкоду в третьей колонке означает, что Lua функция напрямую эмулирует опкод игры без каких-либо изменений в поведении.
| Опкод | Lua | Пояснение |
|---|---|---|
| 0000 | [1] | |
| 0001 | wait(int time) | [2] |
| 0003 | shakeCam(int shake) | |
| 0052 | [1:1] | |
| 0053 | Player player = createPlayer(Model modelId, float atX, float atY, float atZ) | |
| 0092 | [3] | |
| 0093 | [3:1] | |
| 0094 | math.abs |
[2:1] |
| 0095 | math.abs |
[2:2] |
| 0096 | math.abs |
[2:3] |
| 0097 | math.abs |
[2:4] |
| 0098 | math.random |
[2:5] |
| 0099 | math.random |
[2:6] |
| 009A | Ped ped = createChar(int pedtype, Model modelId, float atX, float atY, float atZ) | |
| 009B | deleteChar(Ped ped) | |
| 00A0 | float positionX, float positionY, float positionZ = getCharCoordinates(Ped ped) | |
| 00A1 | setCharCoordinates(Ped ped, float posX, float posY, float posZ) | |
| 00A3 | bool result = isCharInArea2d(Ped ped, float cornerAX, float cornerAY, float cornerBX, float cornerBY, bool sphere) | |
| 00A4 | bool result = isCharInArea3d(Ped ped, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool sphere) | |
| 00A5 | Vehicle car = createCar(Model modelId, float atX, float atY, float atZ) | |
| 00A6 | deleteCar(Vehicle car) | |
| 00A7 | carGotoCoordinates(Vehicle car, float driveToX, float driveToY, float driveToZ) | |
| 00A8 | carWanderRandomly(Vehicle car) | |
| 00A9 | carSetIdle(Vehicle car) | |
| 00AA | float positionX, float positionY, float positionZ = getCarCoordinates(Vehicle car) | |
| 00AB | setCarCoordinates(Vehicle car, float atX, float atY, float atZ) | |
| 00AD | setCarCruiseSpeed(Vehicle car, float maxSpeed) | |
| 00AE | setCarDrivingStyle(Vehicle car, int behaviour) | |
| 00AF | setCarMission(Vehicle car, int driverBehaviour) | |
| 00B0 | bool result = isCarInArea2d(Vehicle car, float cornerAX, float cornerAY, float cornerBX, float cornerBY, bool sphere) | |
| 00B1 | bool result = isCarInArea3d(Vehicle car, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool sphere) | |
| 00BA | printBig(GxtString gxtString, int time, int style) | |
| 00BB | printText(GxtString gxtString, int time, int flag) | |
| 00BC | printTextNow(GxtString gxtString, int time, int flag) | |
| 00BE | clearPrints() | |
| 00BF | int hours, int mins = getTimeOfDay() | |
| 00C0 | setTimeOfDay(int hours, int minutes) | |
| 00C1 | int minutes = getMinutesToTimeOfDay(int hours, int minutes) | |
| 00C2 | bool result = isPointOnScreen(float sphereX, float sphereY, float sphereZ, float radius) | |
| 00D6 | [3:2] | |
| 00D7 | [3:3] | |
| 00D8 | [1:2] | |
| 00D9 | Vehicle car = storeCarCharIsIn(Ped ped) | |
| 00DB | bool result = isCharInCar(Ped ped, Vehicle car) | |
| 00DD | bool result = isCharInModel(Ped ped, Model carModel) | |
| 00DF | bool result = isCharInAnyCar(Ped ped) | |
| 00E1 | bool result = isButtonPressed(Player player, int key) | |
| 00E2 | int state = getPadState(Player player, int key) | |
| 00EC | bool result = locateCharAnyMeans2d(Ped ped, float pointX, float pointY, float radiusX, float radiusY, bool sphere) | |
| 00ED | bool result = locateCharOnFoot2d(Ped ped, float pointX, float pointY, float radiusX, float radiusY, bool sphere) | |
| 00EE | bool result = locateCharInCar2d(Ped ped, float pointX, float pointY, float radiusX, float radiusY, bool sphere) | |
| 00EF | bool result = locateStoppedCharAnyMeans2d(Ped ped, float pointX, float pointY, float radiusX, float radiusY, bool sphere) | |
| 00F0 | bool result = locateStoppedCharOnFoot2d(Ped ped, float pointX, float pointY, float radiusX, float radiusY, bool sphere) | |
| 00F1 | bool result = locateStoppedCharInCar2d(Ped ped, float pointX, float pointY, float radiusX, float radiusY, bool sphere) | |
| 00F2 | bool result = locateCharAnyMeansChar2d(Ped ped, Ped nearPed, float radiusX, float radiusY, bool sphere) | |
| 00F3 | locateCharOnFootChar2d(Ped ped, Ped nearPed, float radiusX, float radiusY, bool sphere) | |
| 00F4 | bool result = locateCharInCarChar2d(Ped ped, Ped nearPed, float radiusX, float radiusY, bool sphere) | |
| 00FE | bool result = locateCharAnyMeans3d(Ped ped, float sphereX, float sphereY, float sphereZ, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 00FF | bool result = locateCharOnFoot3d(Ped ped, float sphereX, float sphereY, float sphereZ, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0100 | bool result = locateCharInCar3d(Ped ped, float sphereX, float sphereY, float sphereZ, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0101 | bool result = locateStoppedCharAnyMeans3d(Ped ped, float sphereX, float sphereY, float sphereZ, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0102 | bool result = locateStoppedCharOnFoot3d(Ped ped, float sphereX, float sphereY, float sphereZ, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0103 | bool result = locateStoppedCharInCar3d(Ped ped, float sphereX, float sphereY, float sphereZ, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0104 | bool result = locateCharAnyMeansChar3d(Ped ped, Ped nearPed, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0105 | bool result = locateCharOnFootChar3d(Ped ped, Ped nearPed, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0106 | bool result = locateCharInCarChar3d(Ped ped, Ped nearPed, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0107 | Object object = createObject(Model modelId, float atX, float atY, float atZ) | |
| 0108 | deleteObject(Object object) | |
| 0109 | givePlayerMoney(Player player, int money) | |
| 010A | [3:4] | |
| 010B | int money = getPlayerMoney(Player player) | |
| 010C | giveRemoteControlledCarToPlayer(Player player, float float2, float float3, float float4) | |
| 010D | alterWantedLevel(Player player, int wantedLevel) | |
| 010E | alterWantedLevelNoDrop(Player player, int minimumWantedLevel) | |
| 010F | bool result = isWantedLevelGreater(Player player, int level) | |
| 0110 | clearWantedLevel(Player player) | |
| 0111 | setDeatharrestState(bool value) | |
| 0112 | bool result = hasDeatharrestBeenExecuted() | |
| 0114 | addAmmoToChar(Ped ped, int weapon, int ammo) | |
| 0117 | bool result = isPlayerDead(Player player) | |
| 0118 | bool result = isCharDead(Ped ped) | |
| 0119 | bool result = isCarDead(Vehicle car) | |
| 0122 | bool result = isPlayerPressingHorn(Player player) | |
| 0129 | Ped ped = createCharInsideCar(Vehicle car, Model pedtype, int model) | |
| 0137 | bool result = isCarModel(Vehicle car, Model modelId) | |
| 014B | int carGenerator = createCarGenerator(float atX, float atY, float atZ, float angle, Model modelId, int color1, int color2, bool forceSpawn, int alarm, int doorLock, int minDelay, int maxDelay) | |
| 014C | switchCarGenerator(int carGenerator, int carsToGenerate) | |
| 014E | displayOnscreenTimer(VarId var, bool countInDirection) | |
| 014F | clearOnscreenTimer(VarId var) | |
| 0151 | clearOnscreenCounter(VarId var) | |
| 0154 | bool result = isCharInZone(Ped ped, GxtString zoneName) | |
| 0158 | pointCameraAtCar(Vehicle car, int mode, int switchstyle) | |
| 0159 | pointCameraAtChar(Ped ped, int mode, int switchstyle) | |
| 015A | restoreCamera() | |
| 015B | shakePad(Player player, int time, int intensity) | |
| 015D | setTimeScale(float gamespeed) | |
| 015F | setFixedCameraPosition(float positionX, float positionY, float positionZ, float rotationX, float rotationY, float rotationZ) | |
| 0160 | pointCameraAtPoint(float pointAtX, float pointAtY, float pointAtZ, int switchstyle) | |
| 0161 | Marker marker = addBlipForCarOld(Vehicle car, int unused, bool visibility) | |
| 0162 | Marker marker = addBlipForCharOld(Ped ped, int int2, int int3) | |
| 0164 | removeBlip(Marker marker) | |
| 0165 | changeBlipColour(Marker marker, int color) | |
| 0167 | Marker marker = addBlipForCoordOld(float atX, float atY, float atZ, int color, int flag) | |
| 0168 | changeBlipScale(Marker marker, int size) | |
| 0169 | setFadingColour(int r, int g, int b) | |
| 016A | doFade(bool in, int time) | |
| 016B | bool result = getFadingStatus() | |
| 016C | addHospitalRestart(float atX, float atY, float atZ, float angle, int townNumber) | |
| 016D | addPoliceRestart(float atX, float atY, float atZ, float angle, int townNumber) | |
| 016E | overrideNextRestart(float atX, float atY, float atZ, float angle) | |
| 016F | drawShadow(Particle particle, float atX, float atY, float atZ, float rotationFactor, float size, int intensity, int flags1, int flags2, int flags3) | |
| 0172 | float angle = getCharHeading(Ped ped) | |
| 0173 | setCharHeading(Ped ped, float angle) | |
| 0174 | float angle = getCarHeading(Vehicle car) | |
| 0175 | setCarHeading(Vehicle car, float angle) | |
| 0176 | float angle = getObjectHeading(Object object) | |
| 0177 | setObjectHeading(Object object, float angle) | |
| 0179 | bool result = isCharTouchingObject(Ped ped, Object object) | |
| 017B | setCharAmmo(Ped ped, int weapon, int ammo) | |
| 0180 | declareMissionFlag(VarId flag) | |
| 0184 | [3:5] | |
| 0185 | [3:6] | |
| 0186 | Marker marker = addBlipForCar(Vehicle car) | |
| 0187 | Marker marker = addBlipForChar(Ped ped) | |
| 0188 | Marker marker = addBlipForObject(Object object) | |
| 018A | Checkpoint checkpoint = addBlipForCoord(float atX, float atY, float atZ) | |
| 018B | changeBlipDisplay(Marker marker, int mode) | |
| 018C | addOneOffSound(float atX, float atY, float atZ, int sound) | |
| 018D | int unk = addContinuousSound(float atX, float atY, float atZ, int sound) | |
| 018E | removeSound(int sound) | |
| 018F | bool result = isCarStuckOnRoof(Vehicle car) | |
| 0190 | addUpsidedownCarCheck(Vehicle car) | |
| 0191 | removeUpsidedownCarCheck(Vehicle car) | |
| 01A1 | bool result = isCharInAreaOnFoot2d(Ped ped, float cornerAX, float cornerAY, float cornerBX, float cornerBY, bool sphere) | |
| 01A2 | bool result = isCharInAreaInCar2d(Ped ped, float cornerAX, float cornerAY, float cornerBX, float cornerBY, bool sphere) | |
| 01A3 | bool result = isCharStoppedInArea2d(Ped ped, float cornerAX, float cornerAY, float cornerBX, float cornerBY, bool sphere) | |
| 01A4 | bool result = isCharStoppedInAreaOnFoot2d(Ped ped, float cornerAX, float cornerAY, float cornerBX, float cornerBY, bool sphere) | |
| 01A5 | bool result = isCharStoppedInAreaInCar2d(Ped ped, float cornerAX, float cornerAY, float cornerBX, float cornerBY, bool sphere) | |
| 01A6 | bool result = isCharInAreaOnFoot3d(Ped ped, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool sphere) | |
| 01A7 | bool result = isCharInAreaInCar3d(Ped ped, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool sphere) | |
| 01A8 | bool result = isCharStoppedInArea3d(Ped ped, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool sphere) | |
| 01A9 | bool result = isCharStoppedInAreaOnFoot3d(Ped ped, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool sphere) | |
| 01AA | bool result = isCharStoppedInAreaInCar3d(Ped ped, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool sphere) | |
| 01AB | bool result = isCarStoppedInArea2d(Vehicle car, float cornerAX, float cornerAY, float cornerBX, float cornerBY, bool sphere) | |
| 01AC | bool result = isCarStoppedInArea3d(Vehicle car, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool sphere) | |
| 01AD | bool result = locateCar2d(Vehicle car, float pointX, float pointY, float radiusX, float radiusY, bool sphere) | |
| 01AE | bool result = locateStoppedCar2d(Vehicle car, float pointX, float pointY, float radiusX, float radiusY, bool sphere) | |
| 01AF | bool result = locateCar3d(Vehicle car, float sphereX, float sphereY, float sphereZ, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 01B0 | bool result = locateStoppedCar3d(Vehicle car, float sphereX, float sphereY, float sphereZ, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 01B2 | giveWeaponToChar(Ped ped, int weapon, int ammo) | |
| 01B4 | bool result = setPlayerControl(Player player, bool canMove) | |
| 01B5 | bool result = forceWeather(int weather) | |
| 01B6 | bool result = forceWeatherNow(int weather) | |
| 01B7 | releaseWeather() | |
| 01B9 | setCurrentCharWeapon(Ped ped, int weapon) | |
| 01BB | bool result, float positionX, float positionY, float positionZ = getObjectCoordinates(Object object) | |
| 01BC | bool result = setObjectCoordinates(Object object, float atX, float atY, float atZ) | |
| 01BD | int timeMs = getGameTimer() | |
| 01C0 | bool result, int level = storeWantedLevel(Player player) | |
| 01C1 | bool result = isCarStopped(Vehicle car) | |
| 01C2 | markCharAsNoLongerNeeded(Ped ped) | |
| 01C3 | markCarAsNoLongerNeeded(Vehicle car) | |
| 01C4 | markObjectAsNoLongerNeeded(Object object) | |
| 01C5 | dontRemoveChar(Ped ped) | |
| 01C7 | dontRemoveObject(Object object) | |
| 01C8 | bool result, Ped ped = createCharAsPassenger(Vehicle car, Model pedtype, int model, int passengerSeat) | |
| 01E3 | bool result = printWithNumberBig(GxtString gxtString, int number, int time, int style) | |
| 01E4 | bool result = printWithNumber(GxtString gxtString, int number, int time, int flag) | |
| 01E5 | bool result = printWithNumberNow(GxtString gxtString, int number, int time, int flag) | |
| 01E7 | bool result = switchRoadsOn(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 01E8 | switchRoadsOff(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 01E9 | bool result, int passengers = getNumberOfPassengers(Vehicle car) | |
| 01EA | int maxPassengers = getMaximumNumberOfPassengers(Vehicle car) | |
| 01EB | bool result = setCarDensityMultiplier(float multiplier) | |
| 01EC | bool result = setCarHeavy(Vehicle car, bool heavy) | |
| 01F0 | setMaxWantedLevel(int level) | |
| 01F3 | bool result = isCarInAirProper(Vehicle car) | |
| 01F4 | bool result = isCarUpsidedown(Vehicle car) | |
| 01F5 | bool result, Ped ped = getPlayerChar(Player player) | |
| 01F6 | bool result = cancelOverrideRestart() | |
| 01F7 | bool result = setPoliceIgnorePlayer(Player player, bool ignored) | |
| 01F9 | bool result = startKillFrenzy(GxtString gxtString, int weapon, int timeLimit, int targets, Model targetModels1, Model targetModels2, Model targetModels3, Model targetModels4, bool completedText) | |
| 01FA | bool result, int status = readKillFrenzyStatus() | |
| 01FB | math.sqrt |
[2:7] |
| 0202 | bool result = locateCharAnyMeansCar2d(Ped ped, Vehicle car, float radiusX, float radiusY, bool sphere) | |
| 0203 | bool result = locateCharOnFootCar2d(Ped ped, Vehicle car, float radiusX, float radiusY, bool flag) | |
| 0204 | bool result = locateCharInCarCar2d(Ped ped, Vehicle car, float radiusX, float radiusY, bool sphere) | |
| 0205 | bool result = locateCharAnyMeansCar3d(Ped ped, Vehicle car, float radiusX, float radiusY, float radiusZ, bool flag) | |
| 0206 | bool result = locateCharOnFootCar3d(Ped ped, Vehicle car, float radiusX, float radiusY, float radiusZ, bool flag) | |
| 0207 | bool result = locateCharInCarCar3d(Ped ped, Vehicle car, float radiusX, float radiusY, float radiusZ, bool flag) | |
| 0208 | math.random |
[2:8] |
| 0209 | math.random |
[2:9] |
| 020A | lockCarDoors(Vehicle car, int status) | |
| 020B | bool result = explodeCar(Vehicle car) | |
| 020C | bool result = addExplosion(float atX, float atY, float atZ, int radius) | |
| 020D | bool result = isCarUpright(Vehicle car) | |
| 0213 | bool result, Pickup pickup = createPickup(Model modelId, int type, float atX, float atY, float atZ) | |
| 0214 | bool result = hasPickupBeenCollected(Pickup pickup) | |
| 0215 | bool result = removePickup(Pickup pickup) | |
| 0216 | bool result = setTaxiLights(Vehicle taxi, bool light) | |
| 0217 | bool result = printBigQ(GxtString gxtString, int time, int style) | |
| 021B | bool result = setTargetCarForMissionGarage(GxtString garage, Vehicle car) | |
| 0221 | bool result = applyBrakesToPlayersCar(Player player, bool apply) | |
| 0223 | setCharHealth(Ped ped, int health) | |
| 0224 | setCarHealth(Vehicle car, int health) | |
| 0226 | int health = getCharHealth(Ped ped) | |
| 0227 | int health = getCarHealth(Vehicle car) | |
| 0229 | bool result = changeCarColour(Vehicle car, int primaryColor, int secondaryColor) | |
| 022A | switchPedRoadsOn(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 022B | switchPedRoadsOff(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 0235 | [1:3] | |
| 0236 | [1:4] | |
| 0237 | setGangWeapons(int gang, int weapons1, int weapons2, int weapons3) | |
| 023B | bool result = isCharTouchingObjectOnFoot(Ped ped, Object object) | |
| 023C | loadSpecialCharacter(GxtString gxtString, int id) | |
| 023D | bool result = hasSpecialCharacterLoaded(int id) | |
| 0241 | bool result = isPlayerInRemoteMode(Player player) | |
| 0244 | setCutsceneOffset(float posX, float posY, float posZ) | |
| 0245 | setAnimGroupForChar(Ped ped, string style) | |
| 0247 | requestModel(Model modelId) | |
| 0248 | bool result = hasModelLoaded(Model modelId) | |
| 0249 | markModelAsNoLongerNeeded(Model modelId) | |
| 024F | drawCorona(float atX, float atY, float atZ, float radius, int type, bool lensflares, int r, int g, int b) | |
| 0253 | storeClock() | |
| 0254 | restoreClock() | |
| 0256 | bool result = isPlayerPlaying(Player player) | |
| 0293 | int mode = getControllerMode() | |
| 0294 | setCanResprayCar(Vehicle car, bool sprayable) | |
| 0296 | unloadSpecialCharacter(int id) | |
| 0297 | resetNumOfModelsKilledByPlayer(Player player) | |
| 0298 | int quantity = getNumOfModelsKilledByPlayer(Player player, Model modelId) | |
| 0299 | activateGarage(GxtString garage) | |
| 029B | Object object = createObjectNoOffset(Model modelId, float atX, float atY, float atZ) | |
| 02A0 | bool result = isCharStopped(Ped ped) | |
| 02A3 | switchWidescreen(bool enable) | |
| 02A4 | [1:5] | |
| 02A5 | [1:6] | |
| 02A7 | Marker marker = addSpriteBlipForContactPoint(float atX, float atY, float atZ, int icon) | |
| 02A8 | Marker marker = addSpriteBlipForCoord(float atX, float atY, float atZ, int type) | |
| 02A9 | setCharOnlyDamagedByPlayer(Ped ped, bool enabled) | |
| 02AA | setCarOnlyDamagedByPlayer(Vehicle car, bool enabled) | |
| 02AB | setCharProofs(Ped ped, bool BP, bool FP, bool EP, bool CP, bool MP) | |
| 02AC | setCarProofs(Vehicle car, bool BP, bool FP, bool EP, bool CP, bool MP) | |
| 02B9 | deactivateGarage(GxtString garage) | |
| 02BF | bool result = isCarInWater(Vehicle car) | |
| 02C0 | float nodeX, float nodeY, float nodeZ = getClosestCharNode(float closestToX, float closestToY, float closestToZ) | |
| 02C1 | float nodeX, float nodeY, float nodeZ = getClosestCarNode(float closestToX, float closestToY, float closestToZ) | |
| 02C2 | carGotoCoordinatesAccurate(Vehicle car, float toX, float toY, float toZ) | |
| 02CA | bool result = isCarOnScreen(Vehicle car) | |
| 02CB | bool result = isCharOnScreen(Ped ped) | |
| 02CC | bool result = isObjectOnScreen(Object object) | |
| 02CE | float z = getGroundZFor3dCoord(float atX, float atY, float atZ) | |
| 02CF | int fire = startScriptFire(float atX, float atY, float atZ, int propagation, int size) | |
| 02D0 | bool result = isScriptFireExtinguished(int fire) | |
| 02D1 | removeScriptFire(int fire) | |
| 02D3 | boatGotoCoords(Vehicle boat, float toX, float toY, float toZ) | |
| 02D4 | boatStop(Vehicle car) | |
| 02D6 | bool result = isCharShootingInArea(Ped ped, float cornerAX, float cornerAY, float cornerBX, float cornerBY, int weapon) | |
| 02D8 | bool result = isCurrentCharWeapon(Ped ped, int weapon) | |
| 02DB | setBoatCruiseSpeed(Vehicle boat, float speed) | |
| 02DD | Ped ped = getRandomCharInZone(GxtString zone, bool pedtype, bool gang, bool criminal_prostitute) | |
| 02E0 | bool result = isCharShooting(Ped ped) | |
| 02E1 | Pickup pickup = createMoneyPickup(float atX, float atY, float atZ, int cash, bool permanenceFlag) | |
| 02E2 | setCharAccuracy(Ped ped, int accuracy) | |
| 02E3 | float speed = getCarSpeed(Vehicle car) | |
| 02E4 | loadCutscene(GxtString cutscene) | |
| 02E5 | Object object = createCutsceneObject(Model modelId) | |
| 02E6 | setCutsceneAnim(int cutscene, GxtString anim) | |
| 02E7 | startCutscene() | |
| 02E8 | int time = getCutsceneTime() | |
| 02E9 | bool result = hasCutsceneFinished() | |
| 02EA | clearCutscene() | |
| 02EB | restoreCameraJumpcut() | |
| 02EC | [1:7] | |
| 02ED | setCollectable1Total(int total) | |
| 02EE | bool result = isProjectileInArea(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 02F2 | bool result = isCharModel(Ped ped, Model modelId) | |
| 02F3 | loadSpecialModel(Model modelId, GxtString gxtString) | |
| 02F6 | math.sin |
[2:10] |
| 02F7 | math.cos |
[2:11] |
| 02F8 | float forwardX = getCarForwardX(Vehicle car) | |
| 02F9 | float forwardY = getCarForwardY(Vehicle car) | |
| 02FA | changeGarageType(GxtString garage, int type) | |
| 02FD | printWith2NumbersNow(GxtString gxtString, int numbers1, int numbers2, int time, int flag) | |
| 02FF | printWith3Numbers(GxtString gxtString, int numbers1, int numbers2, int numbers3, int time, int flag) | |
| 0302 | printWith4Numbers(GxtString gxtString, int numbers1, int numbers2, int numbers3, int numbers4, int time, int flag) | |
| 0303 | printWith4NumbersNow(GxtString gxtString, int numbers1, int numbers2, int numbers3, int numbers4, int time, int flag) | |
| 0308 | printWith6Numbers(GxtString gxtString, int numbers1, int numbers2, int numbers3, int numbers4, int numbers5, int numbers6, int time, int flag) | |
| 030C | playerMadeProgress(int progress) | |
| 030D | setProgressTotal(int maxProgress) | |
| 0317 | registerMissionGiven() | |
| 0318 | registerMissionPassed(GxtString mission) | |
| 0319 | [1:8] | |
| 031A | removeAllScriptFires() | |
| 031D | bool result = hasCharBeenDamagedByWeapon(Ped ped, int weapon) | |
| 031E | bool result = hasCarBeenDamagedByWeapon(Vehicle car, int weapon) | |
| 0321 | explodeCharHead(Ped ped) | |
| 0323 | anchorBoat(Vehicle boat, bool anchor) | |
| 0325 | int fire = startCarFire(Vehicle car) | |
| 0326 | int fire = startCharFire(Ped ped) | |
| 0327 | Vehicle car = getRandomCarOfTypeInArea(float cornerAX, float cornerAY, float cornerBX, float cornerBY, Model modelId) | |
| 0329 | bool result = hasResprayHappened(Vehicle car) | |
| 032A | setCameraZoom(int mode) | |
| 032B | Pickup pickup = createPickupWithAmmo(Model modelId, int type, int ammo, float atX, float atY, float atZ) | |
| 032C | setCarRamCar(Vehicle car, Vehicle car) | |
| 0330 | setPlayerNeverGetsTired(Player player, bool infiniteRun) | |
| 0331 | setPlayerFastReload(Player player, bool fastReload) | |
| 0332 | setCharBleeding(Ped ped, bool bleeding) | |
| 0335 | setFreeResprays(bool enable) | |
| 0337 | setCharVisible(Ped ped, bool visible) | |
| 0338 | setCarVisible(Vehicle car, bool visible) | |
| 0339 | bool result = isAreaOccupied(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool solid, bool car, bool actor, bool object, bool particle) | |
| 033E | displayText(float posX, float posY, GxtString gxtString) | |
| 033F | setTextScale(float sizeX, float sizeY) | |
| 0340 | setTextColour(int r, int g, int b, int a) | |
| 0341 | setTextJustify(bool alignJustify) | |
| 0342 | setTextCentre(bool centered) | |
| 0343 | setTextWrapx(float linewidth) | |
| 0344 | setTextCentreSize(float linewidth) | |
| 0345 | setTextBackground(bool background) | |
| 0348 | setTextProportional(bool proportional) | |
| 0349 | setTextFont(int font) | |
| 034D | bool result = rotateObject(Object object, float fromAngle, float toAngle, bool flag) | |
| 034E | bool result = slideObject(Object object, float toX, float toY, float toZ, float speedX, float speedY, float speedZ, bool collisionCheck) | |
| 034F | removeCharElegantly(Ped ped) | |
| 0350 | setCharStayInSamePlace(Ped ped, bool enabled) | |
| 0356 | bool result = isExplosionInArea(int explosionType, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 035C | placeObjectRelativeToCar(Object object, Vehicle car, float offsetX, float offsetY, float offsetZ) | |
| 035D | makeObjectTargettable(Object object, bool targetable) | |
| 035F | addArmourToChar(Ped ped, int points) | |
| 0360 | openGarage(GxtString garage) | |
| 0361 | closeGarage(GxtString garage) | |
| 0362 | warpCharFromCarToCoord(Ped ped, float placeAtX, float placeAtY, float placeAtZ) | |
| 0363 | setVisibilityOfClosestObjectOfType(float atX, float atY, float atZ, float radius, Model modelId, bool visibility) | |
| 0364 | bool result = hasCharSpottedChar(Ped ped, Ped ped) | |
| 0366 | bool result = hasObjectBeenDamaged(Object object) | |
| 036A | warpCharIntoCar(Ped ped, Vehicle car) | |
| 036D | printWith2NumbersBig(GxtString gxtString, int numbers1, int numbers2, int time, int style) | |
| 0373 | setCameraBehindPlayer() | |
| 0376 | Ped ped = createRandomChar(float atX, float atY, float atZ) | |
| 037E | bool result = isSniperBulletInArea(float float1, float float2, float float3, float float4, float float5, float float6) | |
| 0381 | setObjectVelocity(Object object, float velocityInDirectionX, float velocityInDirectionY, float velocityInDirectionZ) | |
| 0382 | setObjectCollision(Object object, bool collision) | |
| 0383 | [1:9] | |
| 0384 | printStringInStringNow(GxtString gxtString, GxtString string, int time1, int time2) | |
| 038A | bool result = isPointObscuredByAMissionEntity(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 038B | loadAllModelsNow() | |
| 038C | addToObjectVelocity(Object object, float velocityX, float velocityY, float velocityZ) | |
| 038D | drawSprite(int texture, float positionX, float positionY, float width, float height, int r, int g, int b, int a) | |
| 038E | drawRect(float positionX, float positionY, float width, float height, int r, int g, int b, int a) | |
| 038F | int id = loadSprite(string name) | |
| 0390 | bool result = loadTextureDictionary(zstring txd) | |
| 0391 | removeTextureDictionary() | |
| 0392 | setObjectDynamic(Object object, bool moveable) | |
| 0393 | setCharAnimSpeed(Ped ped, string animation, float speed) | |
| 0394 | playMissionPassedTune(int music) | |
| 0395 | clearArea(float atX, float atY, float atZ, float radius, bool area) | |
| 0396 | freezeOnscreenTimer(bool timer) | |
| 0397 | switchCarSiren(Vehicle car, bool siren) | |
| 039C | setCarWatertight(Vehicle car, bool watertight) | |
| 039E | setCharCantBeDraggedOut(Ped ped, bool locked) | |
| 039F | turnCarToFaceCoord(Vehicle car, float coordX, float coordY) | |
| 03A1 | drawSphere(float atX, float atY, float atZ, float radius) | |
| 03A2 | setCarStatus(Vehicle car, int action) | |
| 03A3 | bool result = isCharMale(Ped ped) | |
| 03A4 | [3:7] | |
| 03A7 | [1:10] | |
| 03A8 | [1:11] | |
| 03AA | policeRadioMessage(float float1, float float2, float float3) | |
| 03AB | setCarStrong(Vehicle car, bool strong) | |
| 03AD | switchRubbish(bool int1) | |
| 03AF | switchStreaming(bool streaming) | |
| 03B0 | bool result = isGarageOpen(GxtString garage) | |
| 03B1 | bool result = isGarageClosed(GxtString garage) | |
| 03B6 | swapNearestBuildingModel(float atX, float atY, float atZ, float radius, Model from, Model to) | |
| 03B7 | switchWorldProcessing(bool cutsceneOnly) | |
| 03BA | clearAreaOfCars(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 03BC | int sphere = addSphere(float atX, float atY, float atZ, float radius) | |
| 03BD | removeSphere(int sphere) | |
| 03BF | setEveryoneIgnorePlayer(Player player, bool ignored) | |
| 03C0 | Vehicle car = storeCarCharIsInNoSave(Ped ped) | |
| 03C3 | displayOnscreenTimerWithString(VarId timer, int type, GxtString gxtString) | |
| 03C4 | displayOnscreenCounterWithString(VarId var, bool type, GxtString gxtString) | |
| 03C5 | createRandomCarForCarPark(float coordsX, float coordsY, float coordsZ, float zAngle) | |
| 03C7 | setWantedMultiplier(float sensitivity) | |
| 03C8 | setCameraInFrontOfPlayer() | |
| 03C9 | bool result = isCarVisiblyDamaged(Vehicle car) | |
| 03CA | bool result = doesObjectExist(Object object) | |
| 03CB | loadScene(float atX, float atY, float atZ) | |
| 03CC | addStuckCarCheck(Vehicle car, float stuckCheckDistance, int time) | |
| 03CD | removeStuckCarCheck(Vehicle car) | |
| 03CE | bool result = isCarStuck(Vehicle car) | |
| 03CF | loadMissionAudio(int asId, int name) | |
| 03D0 | bool result = hasMissionAudioLoaded(int id) | |
| 03D1 | playMissionAudio(int id) | |
| 03D2 | bool result = hasMissionAudioFinished(int id) | |
| 03D3 | float nodeX, float nodeY, float nodeZ, float angle = getClosestCarNodeWithHeading(float X, float Y, float Z) | |
| 03D4 | bool result = hasImportGarageSlotBeenFilled(int int1, int int2) | |
| 03D5 | clearThisPrint(GxtString text) | |
| 03D6 | clearThisBigPrint(GxtString text) | |
| 03D7 | setMissionAudioPosition(int id, float locationX, float locationY, float locationZ) | |
| 03D8 | activateSaveMenu() | |
| 03D9 | bool result = hasSaveGameFinished() | |
| 03DA | noSpecialCameraForThisGarage(int int1) | |
| 03DC | Marker marker = addBlipForPickup(Pickup pickup) | |
| 03DE | setPedDensityMultiplier(float multiplier) | |
| 03E0 | setTextDrawBeforeFade(bool int1) | |
| 03E1 | int collected = getCollectable1sCollected() | |
| 03E3 | setSpritesDrawBeforeFade(bool antialiased) | |
| 03E4 | setTextRightJustify(bool alignRight) | |
| 03E5 | printHelp(GxtString gxtString) | |
| 03E6 | clearHelp() | |
| 03E7 | flashHudObject(int hudComponent) | |
| 03E8 | [1:12] | |
| 03EA | setGenerateCarsAroundCamera(bool int1) | |
| 03EB | clearSmallPrints() | |
| 03ED | setUpsidedownCarNotDamaged(Vehicle car, bool disableFlippedExplosion) | |
| 03EE | bool result = isPlayerControllable(Player player) | |
| 03EF | makePlayerSafe(Player player) | |
| 03F0 | useRenderCommands | [2:12] |
| 03F0 | useRenderCommands(bool enable) | [4] |
| 03F3 | int primaryColor, int secondaryColor = getCarColours(Vehicle car) | |
| 03F4 | setAllCarsCanBeDamaged(bool enable) | |
| 03F5 | setCarCanBeDamaged(Vehicle car, bool enable) | |
| 03FD | setDrunkInputDelay(Player player, int handlingResponsiveness) | |
| 03FE | setCharMoney(Ped ped, int money) | |
| 0400 | float X, float Y, float Z = getOffsetFromObjectInWorldCoords(Object object, float offsetX, float offsetY, float offsetZ) | |
| 0407 | float X, float Y, float Z = getOffsetFromCarInWorldCoords(Vehicle car, float offsetX, float offsetY, float offsetZ) | |
| 0409 | [1:13] | |
| 040B | [1:14] | |
| 040C | [1:15] | |
| 040D | clearMissionAudio(int id) | |
| 0414 | setFreeHealthCare(Player player, bool free) | |
| 0416 | [1:16] | |
| 0417 | loadAndLaunchMissionInternal(int mission) | |
| 0418 | setObjectDrawLast(Object object, bool drawLast) | |
| 041A | int ammo = getAmmoInCharWeapon(Ped ped, int int) | |
| 041D | setNearClip(float clip) | |
| 041E | setRadioChannel(int radioStation) | |
| 0423 | setCarTraction(Vehicle car, float traction) | |
| 0424 | bool result = areMeasurementsInMetres() | |
| 0425 | float feet = convertMetresToFeet(float meters) | |
| 0428 | setCarAvoidLevelTransitions(Vehicle car, bool avoidLevelTransitions) | |
| 042B | clearAreaOfChars(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 042C | setTotalNumberOfMissions(int totalMissions) | |
| 042D | int imperial = convertMetresToFeetInt(int metric) | |
| 042E | registerFastestTime(int stat, int to) | |
| 042F | registerHighestScore(int int1, int int2) | |
| 0430 | warpCharIntoCarAsPassenger(Ped ped, Vehicle car, int passengerSeat) | |
| 0431 | bool result = isCarPassengerSeatFree(Vehicle car, int seat) | |
| 0432 | Ped ped = getCharInCarPassengerSeat(Vehicle car, int seat) | |
| 0433 | setCharIsChrisCriminal(Ped ped, bool flag) | |
| 0434 | startCredits() | |
| 0435 | stopCredits() | |
| 0436 | bool result = areCreditsFinished() | |
| 043C | setMusicDoesFade(bool enable) | |
| 043E | [1:17] | |
| 043F | [1:18] | |
| 0440 | [1:19] | |
| 0441 | Model modelId = getCarModel(Vehicle veh) | |
| 0445 | bool result = areAnyCarCheatsActivated() | |
| 0446 | setCharSuffersCriticalHits(Ped ped, bool enable) | |
| 0448 | bool result = isCharSittingInCar(Ped ped, Vehicle car) | |
| 0449 | bool result = isCharSittingInAnyCar(Ped ped) | |
| 044B | bool result = isCharOnFoot(Ped ped) | |
| 044D | loadSplashScreen(GxtString gxtString) | |
| 0450 | setJamesCarOnPathToPlayer(int int1) | |
| 0451 | [1:20] | |
| 0453 | setObjectRotation(Object object, float rotationX, float rotationY, float rotationZ) | |
| 0454 | float X, float Y, float Z = getDebugCameraCoordinates() | |
| 0457 | bool result = isPlayerTargettingChar(Player player, Ped ped) | |
| 0458 | bool result = isPlayerTargettingObject(Player player, Object object) | |
| 0459 | [3:8] | |
| 045A | displayTextWithNumber(float x, float y, GxtString gxtString, int number) | |
| 045B | displayTextWith2Numbers(float x, float y, GxtString gxtString, int numbersX, int numbersY) | |
| 045C | failCurrentMission() | |
| 045D | [1:21] | |
| 0460 | setInterpolationParameters(float delay, int time) | |
| 0463 | float X, float Y, float Z = getDebugCameraPointAt() | |
| 0464 | attachCharToCar(Ped ped, Vehicle car, float offsetX, float offsetY, float offsetZ, int position, float shootingAngleLimit, int weapon) | |
| 0465 | detachCharFromCar(Ped ped) | |
| 0466 | setCarStayInFastLane(Vehicle car, bool flag) | |
| 0467 | clearCharLastWeaponDamage(Ped ped) | |
| 0468 | clearCarLastWeaponDamage(Vehicle car) | |
| 0469 | int int10 = getRandomCopInArea(float float1, float float2, float float3, float float4, bool int5, bool int6, bool int7, bool int8, bool int9) | |
| 046C | Ped ped = getDriverOfCar(Vehicle car) | |
| 046D | int followers = getNumberOfFollowers(Ped ped) | |
| 046E | giveRemoteControlledModelToPlayer(Player player, float atX, float atY, float atZ, float angle, Model RCModel) | |
| 0470 | int weapon = getCurrentCharWeapon(Ped ped) | |
| 0471 | bool result = locateCharAnyMeansObject2d(Ped ped, Object object, float radiusX, float radiusY, bool sphere) | |
| 0472 | bool result = locateCharOnFootObject2d(Ped ped, Object object, float radiusX, float radiusY, bool sphere) | |
| 0473 | bool result = locateCharInCarObject2d(Ped ped, Object object, float radiusX, float radiusY, bool sphere) | |
| 0474 | bool result = locateCharAnyMeansObject3d(Ped ped, Object object, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0475 | bool result = locateCharOnFootObject3d(Ped ped, Object object, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0476 | bool result = locateCharInCarObject3d(Ped ped, Object object, float radiusX, float radiusY, float radiusZ, bool sphere) | |
| 0477 | setCarTempAction(Vehicle car, int action, int time) | |
| 047A | bool result = isCharOnAnyBike(Ped ped) | |
| 0480 | bool result = canCharSeeDeadChar(Ped ped, int pedtype) | |
| 0481 | setEnterCarRangeMultiplier(float float1) | |
| 0482 | [1:22] | |
| 0484 | Vehicle car = getRemoteControlledCar(Player player) | |
| 0485 | bool result = isPcVersion() | |
| 0488 | bool result = isModelAvailable(Model modelId) | |
| 0489 | shutCharUp(Ped ped, bool muted) | |
| 048A | setEnableRcDetonate(bool detonation) | |
| 048B | setCarRandomRouteSeed(Vehicle car, int routeSeed) | |
| 048C | bool result = isAnyPickupAtCoords(float pickupX, float pickupY, float pickupZ) | |
| 048F | removeAllCharWeapons(Ped ped) | |
| 0491 | bool result = hasCharGotWeapon(Ped ped, int weapon) | |
| 0493 | setTankDetonateCars(int tank, bool detonate) | |
| 0494 | int offset1, int offset2, int offset3, int offset4 = getPositionOfAnalogueSticks(int joystick) | |
| 0495 | bool result = isCarOnFire(Vehicle car) | |
| 0496 | bool result = isCarTireBurst(Vehicle car, int tire) | |
| 049C | initialiseObjectPath(int int1, float float2) | |
| 049E | setObjectPathSpeed(int int1, int int2) | |
| 049F | setObjectPathPosition(int int1, float float2) | |
| 04A1 | clearObjectPath(int int1) | |
| 04A2 | heliGotoCoords(Vehicle heli, float toX, float toY, float toZ, float altitudeMin, float altitudeMax) | |
| 04A3 | [3:9] | |
| 04A4 | [3:10] | |
| 04A5 | float coordsX, float coordsY, float coordsZ = getDeadCharPickupCoords(Ped ped) | |
| 04A6 | Pickup pickup = createProtectionPickup(float atX, float atY, float atZ, int int4, int int5) | |
| 04A7 | bool result = isCharInAnyBoat(Ped ped) | |
| 04A9 | bool result = isCharInAnyHeli(Ped ped) | |
| 04AB | bool result = isCharInAnyPlane(Ped ped) | |
| 04AD | bool result = isCharInWater(Ped ped) | |
| 04AE | [3:11] | |
| 04AF | [3:12] | |
| 04B0 | [3:13] | |
| 04B1 | [3:14] | |
| 04B2 | [3:15] | |
| 04B3 | [3:16] | |
| 04B4 | [3:17] | |
| 04B5 | [3:18] | |
| 04B6 | [3:19] | |
| 04B7 | [3:20] | |
| 04B8 | int weapon, int ammo, Model modelId = getCharWeaponInSlot(Ped ped, int slot) | |
| 04B9 | float float6, float float7, float float8, float float9, float float10, float float11, float float12 = getClosestStraightRoad(float atX, float atY, float atZ, float height, float radius) | |
| 04BA | setCarForwardSpeed(Vehicle car, float speed) | |
| 04BB | setInteriorVisible(int interior) | |
| 04BC | [1:23] | |
| 04BD | markCarAsConvoyCar(Vehicle car, bool convoy) | |
| 04BE | resetHavocCausedByPlayer(int int1) | |
| 04BF | int int2 = getHavocCausedByPlayer(int int1) | |
| 04C0 | createScriptRoadblock(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, int type) | |
| 04C1 | clearAllScriptRoadblocks() | |
| 04C4 | float X, float Y, float Z = getOffsetFromCharInWorldCoords(Ped ped, float offsetX, float offsetY, float offsetZ) | |
| 04C5 | bool result = hasCharBeenPhotographed(Ped ped) | |
| 04C7 | switchSecurityCamera(bool int1) | |
| 04C8 | bool result = isCharInFlyingVehicle(Ped ped) | |
| 04CE | Marker marker = addShortRangeSpriteBlipForCoord(float atX, float atY, float atZ, int icon) | |
| 04D0 | setHeliOrientation(Vehicle heli, float angle) | |
| 04D1 | clearHeliOrientation(Vehicle heli) | |
| 04D2 | planeGotoCoords(int plane, float X, float Y, float Z, float z1, float z2) | |
| 04D3 | float X, float Y, float Z = getNthClosestCarNode(float X, float Y, float Z, int type) | |
| 04D5 | drawWeaponshopCorona(float X, float Y, float Z, float radius, int type, int flare, int r, int g, int b) | |
| 04D6 | setEnableRcDetonateOnContact(bool enable) | |
| 04D7 | freezeCharPosition(Ped ped, bool locked) | |
| 04D8 | setCharDrownsInWater(Ped ped, bool drowns) | |
| 04D9 | setObjectRecordsCollisions(Object object, bool set) | |
| 04DA | bool result = hasObjectCollidedWithAnything(Object object) | |
| 04DB | removeRcBuggy() | |
| 04DD | int armour = getCharArmour(Ped ped) | |
| 04DF | setHeliStabiliser(Vehicle heli, bool limiter) | |
| 04E0 | setCarStraightLineDistance(Vehicle car, int radius) | |
| 04E1 | popCarBoot(Vehicle car) | |
| 04E2 | shutPlayerUp(Player player, bool shut) | |
| 04E3 | setPlayerMood(Player player, int flag, int time) | |
| 04E4 | requestCollision(float X, float Y) | |
| 04E5 | bool result = locateObject2d(Object object, float X, float Y, float radiusX, float radiusY, bool sphere) | |
| 04E6 | bool result = locateObject3d(Object object, float X, float Y, float Z, float radiusX, float radiusY, float radiusZ, bool flag) | |
| 04E7 | bool result = isObjectInWater(Object object) | |
| 04E9 | bool result = isObjectInArea2d(Object object, float cornerAX, float cornerAY, float cornerBX, float cornerBY, bool sphere) | |
| 04EA | bool result = isObjectInArea3d(Object object, float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ, bool flag) | |
| 04EB | taskToggleDuck(Ped ped, bool crouch) | |
| 04ED | requestAnimation(string animation) | |
| 04EE | bool result = hasAnimationLoaded(string animation) | |
| 04EF | removeAnimation(string animation) | |
| 04F0 | bool result = isCharWaitingForWorldCollision(Ped ped) | |
| 04F1 | bool result = isCarWaitingForWorldCollision(Vehicle car) | |
| 04F4 | attachCharToObject(Ped ped, Object object, float offsetX, float offsetY, float offsetZ, int orientation, float angle, int lockWeapon) | |
| 04F5 | [1:24] | |
| 04F7 | displayNthOnscreenCounterWithString(VarId text, int type, int line, GxtString gxtString) | |
| 04F8 | addSetPiece(int type, float rectX1, float rectY1, float rectX2, float rectY2, float spawnAX, float spawnAY, float headedTowards1X, float headedTowards1Y, float spawnBX, float spawnBY, float headedTowards2X, float headedTowards2Y) | |
| 04F9 | setExtraColours(int color, bool fade) | |
| 04FA | clearExtraColours(bool fade) | |
| 04FC | int twowheelstime, float twowheelsdistance, int wheelietime, float wheelieDistance, int stoppieTime, float stoppieDistance = getWheelieStats(Player player) | |
| 04FE | burstCarTire(Vehicle car, int tire) | |
| 0500 | bool result = isPlayerWearing(Player player, string bodypart, int skin) | |
| 0501 | setPlayerCanDoDriveBy(Player player, bool mode) | |
| 0503 | int handleAs = createSwatRope(int pedtype, Model modelId, float X, float Y, float Z) | |
| 0506 | setCarModelComponents(Model car, int variation1, int variation2) | |
| 0507 | [1:25] | |
| 0508 | closeAllCarDoors(Vehicle car) | |
| 0509 | float distance = getDistanceBetweenCoords2d(float x1, float y1, float x2, float y2) | |
| 050A | float distance = getDistanceBetweenCoords3d(float x1, float y1, float z1, float x2, float y2, float z2) | |
| 050B | [1:26] | |
| 050E | sortOutObjectCollisionWithCar(Object object, Vehicle car) | |
| 050F | int level = getMaxWantedLevel() | |
| 0512 | printHelpForever(GxtString text) | |
| 0513 | printHelpForeverWithNumber(GxtString text, int number) | |
| 0515 | [1:27] | |
| 0517 | Pickup pickup = createLockedPropertyPickup(float pX, float pY, float pZ, GxtString gxtString) | |
| 0518 | Pickup pickup = createForsalePropertyPickup(float pX, float pY, float pZ, int price, GxtString gxtString) | |
| 0519 | freezeCarPosition(Vehicle car, bool locked) | |
| 051A | bool result = hasCharBeenDamagedByChar(Ped ped, Ped byActor) | |
| 051B | bool result = hasCharBeenDamagedByCar(Ped ped, Vehicle byCar) | |
| 051C | bool result = hasCarBeenDamagedByChar(Vehicle car, Ped byActor) | |
| 051D | bool result = hasCarBeenDamagedByCar(Vehicle car, Vehicle byCar) | |
| 051E | int radio = getRadioChannel() | |
| 0521 | [1:28] | |
| 0522 | [1:29] | |
| 0523 | [1:30] | |
| 0524 | [1:31] | |
| 0525 | [1:32] | |
| 0526 | setCharStayInCarWhenJacked(Ped ped, bool stay) | |
| 052C | setPlayerDrunkenness(Player player, int drunk) | |
| 053E | Vehicle car = getRandomCarOfTypeInAreaNoSave(float x1, float y1, float x2, float y2, Model modelId) | |
| 053F | setCanBurstCarTires(Vehicle car, bool vulnerability) | |
| 0540 | [1:33] | |
| 0541 | fireHunterGun(Vehicle car) | |
| 0545 | [1:34] | |
| 0547 | bool result = isCharTouchingVehicle(Ped ped, Vehicle car) | |
| 0548 | [1:35] | |
| 054A | setCharCanBeShotInVehicle(Ped ped, bool can) | |
| 054B | [1:36] | |
| 054C | loadMissionText(GxtString table) | |
| 054D | [1:37] | |
| 054E | clearCharLastDamageEntity(Ped ped) | |
| 054F | clearCarLastDamageEntity(Vehicle car) | |
| 0550 | freezeObjectPosition(Object object, bool freeze) | |
| 0551 | [1:38] | |
| 0552 | [1:39] | |
| 0555 | removeWeaponFromChar(Ped ped, int weapon) | |
| 0557 | [1:40] | |
| 055B | [1:41] | |
| 055D | makePlayerFireProof(Player player, bool fireproof) | |
| 055E | increasePlayerMaxHealth(Player player, int increase) | |
| 055F | increasePlayerMaxArmour(Player player, int increase) | |
| 0560 | Ped ped = createRandomCharAsDriver(Vehicle car) | |
| 0561 | Ped ped = createRandomCharAsPassenger(Vehicle car, int seat) | |
| 0563 | ensurePlayerHasDriveByWeapon(Player player, int ammo) | |
| 0564 | makeHeliComeCrashingDown(Vehicle heli) | |
| 0565 | addExplosionNoSound(float pX, float pY, float pZ, int type) | |
| 0566 | linkObjectToInterior(Object object, int interior) | |
| 0568 | setCharNeverTargetted(Ped ped, bool untargetable) | |
| 0569 | [1:42] | |
| 056A | bool result = wasCutsceneSkipped() | |
| 056C | bool result = isCharInAnyPoliceVehicle(Ped ped) | |
| 056D | bool result = doesCharExist(Ped ped) | |
| 056E | bool result = doesVehicleExist(Vehicle car) | |
| 0570 | Marker blip = addShortRangeSpriteBlipForContactPoint(float pX, float pY, float pZ, int icon) | |
| 0572 | setAllTaxisHaveNitro(bool toggle) | |
| 0574 | freezeCarPositionAndDontLoadCollision(Vehicle car, bool keep) | |
| 0575 | freezeCharPositionAndDontLoadCollision(Ped ped, bool keep) | |
| 057B | [1:43] | |
| 057D | [1:44] | |
| 057E | setPlayerIsInStadium(bool set) | |
| 057F | [1:45] | |
| 0581 | displayRadar(bool enable) | |
| 0582 | registerBestPosition(int stat, float float) | |
| 0583 | bool result = isPlayerInInfoZone(Player player, GxtString zone) | |
| 0585 | [1:46] | |
| 0587 | setLoadCollisionForCarFlag(Vehicle car, bool enable) | |
| 0588 | setLoadCollisionForCharFlag(Ped ped, bool enable) | |
| 058A | addBigGunFlash(float fromX, float fromY, float fromZ, float toX, float toY, float toZ) | |
| 058C | float progress = getProgressPercentage() | |
| 058D | [1:47] | |
| 058E | [1:48] | |
| 0591 | [1:49] | |
| 0592 | [1:50] | |
| 0594 | setVehicleToFadeIn(Vehicle car, int flag) | |
| 0595 | registerOddjobMissionPassed() | |
| 0596 | bool result = isPlayerInShortcutTaxi(Player player) | |
| 0597 | bool result = isCharDucking(Ped ped) | |
| 059A | [1:51] | |
| 059B | [1:52] | |
| 059C | setOnscreenCounterFlashWhenFirstDisplayed(VarId text, bool flashing) | |
| 059D | shuffleCardDecks(bool shuffle) | |
| 059E | int card = fetchNextCard() | |
| 059F | float vecX, float vecY, float vecZ = getObjectVelocity(Object object) | |
| 05A0 | bool result = isDebugCameraOn() | |
| 05A1 | addToObjectRotationVelocity(Object object, float vecX, float vecY, float vecZ) | |
| 05A2 | setObjectRotationVelocity(Object object, float vecX, float vecY, float vecZ) | |
| 05A3 | bool result = isObjectStatic(Object object) | |
| 05A4 | float angle = getAngleBetween2dVectors(float vecX, float vecY, float vecX, float vecY) | |
| 05A5 | bool result = do2dRectanglesCollide(float areaX, float areaY, float scaleX, float scaleY, float overlapareaX, float overlapareaY, float overlapscaleX, float overlapscaleY) | |
| 05A6 | float axisX, float axisY, float axisZ = getObjectRotationVelocity(Object object) | |
| 05A7 | addVelocityRelativeToObjectVelocity(Object object, float vecX, float vecY, float vecZ) | |
| 05A8 | float speed = getObjectSpeed(Object object) | |
| 05A9 | [3:21] | |
| 05AA | [3:22] | |
| 05AD | [3:23] | |
| 05AE | [3:24] | |
| 05B0 | bool result, float X, float Y = get2dLinesIntersectPoint(float l1x1, float l1y1, float l1x2, float l1y2, float l2x1, float l2y1, float l2x2, float l2y2) | |
| 05B1 | [1:53] | |
| 05B2 | [1:54] | |
| 05B3 | [1:55] | |
| 05B5 | [1:56] | |
| 05B6 | [1:57] | |
| 05B7 | [1:58] | |
| 05B8 | [1:59] | |
| 05B9 | taskPause(Ped ped, int timeMS) | |
| 05BA | taskStandStill(Ped ped, int timeMS) | |
| 05BB | taskFallAndGetUp(Ped ped, bool int2, int time) | |
| 05BC | taskJump(Ped ped, bool jump) | |
| 05BD | taskTired(Ped ped, int timeMS) | |
| 05BE | taskDie(Ped ped) | |
| 05BF | taskLookAtChar(Ped ped, int lookAt, int timeMS) | |
| 05C0 | taskLookAtVehicle(Ped ped, int lookAt, int timeMS) | |
| 05C1 | taskSay(Ped ped, int audio) | |
| 05C2 | taskShakeFist(Ped ped) | |
| 05C3 | taskCower(Ped ped) | |
| 05C4 | taskHandsUp(Ped ped, int timeMS) | |
| 05C5 | taskDuck(Ped ped, int timeMS) | |
| 05C6 | [1:60] | |
| 05C7 | taskUseAtm(Ped ped) | |
| 05C8 | taskScratchHead(Ped ped) | |
| 05C9 | taskLookAbout(Ped ped, int timeMS) | |
| 05CA | taskEnterCarAsPassenger(Ped ped, Vehicle car, int time, int passengerSeat) | |
| 05CB | taskEnterCarAsDriver(Ped ped, Vehicle car, int timeMS) | |
| 05CC | [1:61] | |
| 05CD | taskLeaveCar(Ped ped, Vehicle car) | |
| 05CE | [1:62] | |
| 05CF | taskLeaveCarAndFlee(Ped ped, Vehicle car, float X, float Y, float Z) | |
| 05D0 | [1:63] | |
| 05D1 | taskCarDriveToCoord(Ped ped, Vehicle car, float toX, float toY, float toZ, float speed, int int7, int model, int int9) | |
| 05D2 | taskCarDriveWander(Ped ped, Vehicle hijackCar, float searchRadius, int trafficBehavior) | |
| 05D3 | taskGoStraightToCoord(Ped ped, float toX, float toY, float toZ, int mode, int time) | |
| 05D4 | taskAchieveHeading(Ped ped, float angle) | |
| 05D5 | [1:64] | |
| 05D6 | flushRoute() | |
| 05D7 | extendRoute(float pointX, float pointY, float pointZ) | |
| 05D8 | taskFollowPointRoute(Ped ped, int flags1, int flags2) | |
| 05D9 | taskGotoChar(Ped ped, Ped toActor, int timelimit, float stopWithinRadius) | |
| 05DA | taskFleePoint(Ped ped, float fromX, float fromY, float fromZ, float awayRadius, int timelimit) | |
| 05DB | taskFleeChar(Ped ped, Ped fromActor, float radius, int timelimit) | |
| 05DC | taskSmartFleePoint(Ped ped, float fromX, float fromY, float fromZ, float stopAtRadius, int timelimit) | |
| 05DD | taskSmartFleeChar(Ped ped, Ped fromActor, float originRadius, int timelimit) | |
| 05DE | taskWanderStandard(Ped ped) | |
| 05E2 | taskKillCharOnFoot(Ped ped, Ped killActor) | |
| 05E5 | [1:65] | |
| 05E6 | [1:66] | |
| 05E7 | [1:67] | |
| 05E8 | [1:68] | |
| 05E9 | [1:69] | |
| 05EA | [1:70] | |
| 05EB | startPlaybackRecordedCar(Vehicle car, int path) | |
| 05EC | stopPlaybackRecordedCar(Vehicle car) | |
| 05ED | pausePlaybackRecordedCar(Vehicle car) | |
| 05EE | unpausePlaybackRecordedCar(Vehicle car) | |
| 05EF | [1:71] | |
| 05F0 | [1:72] | |
| 05F1 | setCarEscortCarLeft(Vehicle car, Vehicle followCar) | |
| 05F2 | setCarEscortCarRight(Vehicle car, Vehicle followCar) | |
| 05F3 | setCarEscortCarRear(Vehicle car, Vehicle followCar) | |
| 05F4 | setCarEscortCarFront(Vehicle car, Vehicle followCar) | |
| 05F5 | taskFollowPathNodesToCoord(Ped ped, float pathX, float pathY, float pathZ, int mode, int time) | |
| 05F6 | bool result = isCharInAngledArea2d(Ped ped, float x1, float y1, float x2, float y2, float angle, bool sphere) | |
| 05F7 | bool result = isCharInAngledAreaOnFoot2d(Ped ped, float x1, float y1, float x2, float y2, float angle, bool sphere) | |
| 05F8 | bool result = isCharInAngledAreaInCar2d(Ped ped, float x1, float y1, float x2, float y2, float angle, bool sphere) | |
| 05F9 | bool result = isCharStoppedInAngledArea2d(Ped ped, float x1, float y1, float x2, float y2, float height, bool flag) | |
| 05FA | bool result = isCharStoppedInAngledAreaOnFoot2d(Ped ped, float x1, float y1, float x2, float y2, float angle, bool sphere) | |
| 05FB | bool result = isCharStoppedInAngledAreaInCar2d(Ped ped, float x1, float y1, float x2, float y2, float height, bool flag) | |
| 05FC | bool result = isCharInAngledArea3d(Ped ped, float x1, float y1, float z1, float x2, float y2, float z2, float angle, bool sphere) | |
| 05FD | bool result = isCharInAngledAreaOnFoot3d(Ped ped, float x1, float y1, float z1, float x2, float y2, float z2, float angle, bool sphere) | |
| 05FE | bool result = isCharInAngledAreaInCar3d(Ped ped, float x1, float y1, float z1, float x2, float y2, float z2, float depth, bool flag) | |
| 05FF | bool result = isCharStoppedInAngledArea3d(Ped ped, float x1, float y1, float z1, float x2, float y2, float z2, float depth, bool flag) | |
| 0600 | bool result = isCharStoppedInAngledAreaOnFoot3d(Ped ped, float x1, float y1, float z1, float x2, float y2, float z2, float depth, bool flag) | |
| 0601 | bool result = isCharStoppedInAngledAreaInCar3d(Ped ped, float x1, float y1, float z1, float x2, float y2, float z2, float depth, bool flag) | |
| 0602 | bool result = isCharInTaxi(Ped ped) | |
| 0603 | taskGoToCoordAnyMeans(Ped ped, float toX, float toY, float toZ, int mode, Vehicle useCar) | |
| 0604 | float zAngle = getHeadingFromVector2d(float pX, float pY) | |
| 0605 | taskPlayAnim(Ped ped, string animation, string IFP, float framedelta, bool loop, bool lockX, bool lockY, bool lockF, int time) | |
| 0606 | loadPathNodesInArea(float x1, float y1, float x2, float y2) | |
| 0607 | releasePathNodes() | |
| 0608 | [1:73] | |
| 0609 | [1:74] | |
| 060A | int maker = loadCharDecisionMaker(int type) | |
| 060B | setCharDecisionMaker(Ped ped, int maker) | |
| 060C | [1:75] | |
| 060D | setTextDropshadow(int shadow, int r, int g, int b, int a) | |
| 060E | bool result = isPlaybackGoingOnForCar(Vehicle car) | |
| 060F | setSenseRange(Ped ped, float accuracy) | |
| 0610 | [1:76] | |
| 0611 | bool result = isCharPlayingAnim(Ped ped, string animation) | |
| 0612 | setCharAnimPlayingFlag(Ped ped, string animation, bool flag) | |
| 0613 | float time = getCharAnimCurrentTime(Ped ped, string animation) | |
| 0614 | setCharAnimCurrentTime(Ped ped, string animation, float time) | |
| 0615 | int task = openSequenceTask() | |
| 0616 | closeSequenceTask(int task) | |
| 0617 | [1:77] | |
| 0618 | performSequenceTask(Ped ped, int task) | |
| 0619 | setCharCollision(Ped ped, bool enable) | |
| 061A | float totalTime = getCharAnimTotalTime(Ped ped, string animation) | |
| 061B | clearSequenceTask(int task) | |
| 061C | [1:78] | |
| 061D | int handle = addAttractor(float originX, float originY, float originZ, float zAngle, float unknownAngle, int taskSequence) | |
| 061E | clearAttractor(int handle) | |
| 061F | [1:79] | |
| 0620 | [1:80] | |
| 0621 | Ped ped = createCharAtAttractor(int pedtype, Model modelId, int ASOrigin, int task) | |
| 0622 | taskLeaveCarImmediately(Ped ped, Vehicle car) | |
| 0623 | incrementIntStat(int stat, int add) | |
| 0624 | incrementFloatStat(int stat, float add) | |
| 0625 | decrementIntStat(int stat, int int) | |
| 0626 | decrementFloatStat(int stat, float float) | |
| 0627 | registerIntStat(int stat, int int) | |
| 0628 | registerFloatStat(int stat, float value) | |
| 0629 | setIntStat(int stat, int int) | |
| 062A | setFloatStat(int stat, float float) | |
| 062B | [1:81] | |
| 062C | [1:82] | |
| 062D | [1:83] | |
| 062E | int status = getScriptTaskStatus(Ped ped, int task) | |
| 062F | int group = createGroup(int type) | |
| 0630 | setGroupLeader(int group, Ped ped) | |
| 0631 | setGroupMember(int group, Ped ped) | |
| 0632 | removeGroup(int group) | |
| 0633 | taskLeaveAnyCar(Ped ped) | |
| 0634 | taskKillCharOnFootWhileDucking(Ped ped, int weapon, int flags, int time, int chance) | |
| 0635 | taskAimGunAtChar(Ped ped, int aimAt, int timeMS) | |
| 0636 | [1:84] | |
| 0637 | taskGoToCoordWhileShooting(Ped ped, float toX, float toY, float toZ, int mode, float turnRadius, float stopRadius, int lookAtActor) | |
| 0638 | taskStayInSamePlace(Ped ped, bool stay) | |
| 0639 | taskTurnCharToFaceChar(Ped ped, int rotateTo) | |
| 0642 | bool result = isCharAtScriptedAttractor(Ped ped, int origin) | |
| 0643 | setSequenceToRepeat(int pack, bool loop) | |
| 0646 | int progess = getSequenceProgress(Ped ped) | |
| 0647 | clearLookAt(Ped ped) | |
| 0648 | setFollowNodeThresholdDistance(Ped ped, float dist) | |
| 064A | [1:85] | |
| 064B | Particle particle = createFxSystem(string particle, float pX, float pY, float pZ, int type) | |
| 064C | playFxSystem(Particle particle) | |
| 064D | [1:86] | |
| 064E | stopFxSystem(Particle particle) | |
| 064F | playAndKillFxSystem(Particle particle) | |
| 0650 | killFxSystem(Particle particle) | |
| 0651 | [1:87] | |
| 0652 | int stat = getIntStat(int stat) | |
| 0653 | float stat = getFloatStat(int stat) | |
| 0654 | setObjectRenderScorched(Object object, bool fireproof) | |
| 0655 | taskLookAtObject(Ped ped, int lookAt, int timeMS) | |
| 0656 | float float = limitAngle(float angle) | |
| 0657 | openCarDoor(Vehicle car, int door) | |
| 0659 | [1:88] | |
| 065A | [1:89] | |
| 065B | float X, float Y, float Z = getPickupCoordinates(Pickup pickup) | |
| 065C | removeDecisionMaker(int maker) | |
| 065D | [1:90] | |
| 065E | [1:91] | |
| 065F | [1:92] | |
| 0660 | [1:93] | |
| 0661 | [1:94] | |
| 0662 | [1:95] | |
| 0663 | [1:96] | |
| 0664 | [1:97] | |
| 0665 | Model modelId = getCharModel(Ped ped) | |
| 0666 | [1:98] | |
| 0667 | taskAimGunAtCoord(Ped ped, float atX, float atY, float atZ, int timeMS) | |
| 0668 | taskShootAtCoord(Ped ped, float atX, float atY, float atZ, int timeMS) | |
| 0669 | Particle particle = createFxSystemOnChar(string particle, Ped ped, float offsetX, float offsetY, float offsetZ, int type) | |
| 066A | Particle particle = createFxSystemOnCharWithDirection(string particle, Ped ped, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ, int type) | |
| 066B | Particle particle = createFxSystemOnCar(string particle, Vehicle car, float offsetX, float offsetY, float offsetZ, int type) | |
| 066C | Particle particle = createFxSystemOnCarWithDirection(string particle, Vehicle car, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ, int type) | |
| 066D | Particle particle = createFxSystemOnObject(string particle, Object object, float offsetX, float offsetY, float offsetZ, int type) | |
| 066E | Particle particle = createFxSystemOnObjectWithDirection(string particle, Object object, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ, int flag) | |
| 066F | [1:99] | |
| 0670 | [1:100] | |
| 0671 | [1:101] | |
| 0672 | taskDestroyCar(Ped ped, Vehicle car) | |
| 0673 | taskDiveAndGetUp(Ped ped, float toOffsetX, float toOffsetY, int time) | |
| 0674 | customPlateForNextCar(Model modelId, string numberplate) | |
| 0675 | [1:102] | |
| 0676 | taskShuffleToNextCarSeat(Ped ped, Vehicle car) | |
| 0677 | taskChatWithChar(Ped ped, int withActor, bool flag, int unknownFlag) | |
| 0678 | [1:103] | |
| 0679 | attachCameraToVehicle(Vehicle car, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ, float tilt, int switchstyle) | |
| 067A | attachCameraToVehicleLookAtVehicle(Vehicle car, float offsetX, float offsetY, float offsetZ, int toCar, float tilt, int switchstyle) | |
| 067B | attachCameraToVehicleLookAtChar(Vehicle car, float offsetX, float offsetY, float offsetZ, Ped ped, float tilt, int switchstyle) | |
| 067C | attachCameraToChar(Ped ped, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ, float tilt, int switchstyle) | |
| 067E | attachCameraToCharLookAtChar(Ped ped, float offsetX, float offsetY, float offsetZ, int targetActor, float tilt, int switchstyle) | |
| 067F | forceCarLights(Vehicle car, int lights) | |
| 0680 | addPedtypeAsAttractorUser(int ASOrigin, int pedtype) | |
| 0681 | attachObjectToCar(Object object, Vehicle car, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ) | |
| 0682 | detachObject(Object object, float X, float Y, float Z, bool collisionDetection) | |
| 0683 | attachCarToCar(Vehicle car, int toCar, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ) | |
| 0684 | detachCar(Vehicle car, float X, float Y, float Z, bool collisionDetection) | |
| 0685 | bool result = isObjectAttached(Object object) | |
| 0686 | bool result = isVehicleAttached(Vehicle car) | |
| 0687 | clearCharTasks(Ped ped) | |
| 0688 | taskTogglePedThreatScanner(Ped ped, bool unknownFlag1, bool unknownFlag2, bool unknownFlag3) | |
| 0689 | popCarDoor(Vehicle car, int door, bool visible) | |
| 068A | fixCarDoor(Vehicle car, int door) | |
| 068B | taskEveryoneLeaveCar(Vehicle car) | |
| 068C | bool result = isPlayerTargettingAnything(Player player) | |
| 068D | float X, float Y, float Z = getActiveCameraCoordinates() | |
| 068E | float X, float Y, float Z = getActiveCameraPointAt() | |
| 068F | [1:104] | |
| 0697 | popCarPanel(Vehicle car, int component, bool effectFlag) | |
| 0698 | fixCarPanel(Vehicle car, int componentB) | |
| 0699 | fixCarTire(Vehicle car, int tire) | |
| 069A | attachObjectToObject(Object object, int toObject, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ) | |
| 069B | attachObjectToChar(Object object, Ped ped, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ) | |
| 069C | [1:105] | |
| 069D | [1:106] | |
| 069E | [1:107] | |
| 069F | [1:108] | |
| 06A0 | [1:109] | |
| 06A1 | [1:110] | |
| 06A2 | float vecX, float vecY, float vecZ = getCarSpeedVector(Vehicle car) | |
| 06A3 | float mass = getCarMass(Vehicle car) | |
| 06A4 | [1:111] | |
| 06A5 | taskDiveFromAttachmentAndGetUp(Ped ped, int timeMS) | |
| 06A6 | [1:112] | |
| 06A7 | attachCharToBike(Ped ped, Vehicle car, float offsetX, float offsetY, float offsetZ, int position, float shootingAngle1, float shootingAngle2, int weapon) | |
| 06A8 | taskGotoCharOffset(Ped ped, int toActor, int timelimit, float approachDistance, float approachAngle) | |
| 06A9 | taskLookAtCoord(Ped ped, float toX, float toY, float toZ, int timeMS) | |
| 06AA | [1:113] | |
| 06AB | hideCharWeaponForScriptedCutscene(Ped ped, bool hide) | |
| 06AC | float speed = getCharSpeed(Ped ped) | |
| 06AD | setGroupDecisionMaker(int group, int maker) | |
| 06AE | int maker = loadGroupDecisionMaker(int type) | |
| 06AF | disablePlayerSprint(Player player, bool mode) | |
| 06B0 | taskSitDown(Ped ped, int timeMS) | |
| 06B1 | Searchlight searchlight = createSearchlight(float atX, float atY, float atZ, float targetX, float targetY, float targetZ, float radius1, float radius2) | |
| 06B2 | deleteSearchlight(Searchlight searchlight) | |
| 06B3 | bool result = doesSearchlightExist(Searchlight searchlight) | |
| 06B4 | moveSearchlightBetweenCoords(Searchlight searchlight, float fromX, float fromY, float fromZ, float toX, float toY, float toZ, float speed) | |
| 06B5 | pointSearchlightAtCoord(Searchlight searchlight, float toX, float toY, float toZ, float speed) | |
| 06B6 | pointSearchlightAtChar(Searchlight searchlight, Ped ped, float speed) | |
| 06B7 | bool result = isCharInSearchlight(Searchlight searchlight, Ped ped) | |
| 06B9 | bool result = hasCutsceneLoaded() | |
| 06BA | taskTurnCharToFaceCoord(Ped ped, float atX, float atY, float atZ) | |
| 06BB | taskDrivePointRoute(Ped ped, Vehicle car, float speed) | |
| 06BC | fireSingleBullet(float fromX, float fromY, float fromZ, float targetX, float targetY, float targetZ, int energy) | |
| 06BD | bool result = isLineOfSightClear(float fromX, float fromY, float fromZ, float toX, float toY, float toZ, bool checkBuildings, bool checkVehicles, bool checkActors, bool checkObjects, bool checkParticles) | |
| 06BE | float roll = getCarRoll(Vehicle car) | |
| 06BF | pointSearchlightAtVehicle(Searchlight searchlight, Vehicle car, float speed) | |
| 06C0 | bool result = isVehicleInSearchlight(int int, Vehicle car) | |
| 06C1 | Searchlight searchlight = createSearchlightOnVehicle(Vehicle car, float offsetX, float offsetY, float offsetZ, float targetX, float targetY, float targetZ, float radius, float radius) | |
| 06C2 | taskGoToCoordWhileAiming(Ped ped, float toX, float toY, float toZ, int mode, float turnRadius, float stopRadius, Ped ped, float offsetX, float offsetY, float offsetZ) | |
| 06C3 | int num = getNumberOfFiresInRange(float atX, float atY, float atZ, float radius) | |
| 06C4 | Marker marker = addBlipForSearchlight(Searchlight searchlight) | |
| 06C5 | skipToEndAndStopPlaybackRecordedCar(Vehicle car) | |
| 06C6 | [1:114] | |
| 06C7 | taskCarTempAction(Ped ped, Vehicle car, int performAction, int timelimit) | |
| 06C8 | setLaRiots(bool enable) | |
| 06C9 | removeCharFromGroup(Ped ped) | |
| 06CA | attachSearchlightToSearchlightObject(Searchlight searchlight, int tower, int housing, int bulb, float offsetX, float offsetY, float offsetZ) | |
| 06CB | [1:115] | |
| 06CE | [1:116] | |
| 06CF | [1:117] | |
| 06D0 | switchEmergencyServices(bool enable) | |
| 06D1 | [3:25] | |
| 06D2 | [3:26] | |
| 06D5 | Checkpoint checkpoint = createCheckpoint(int type, float atX, float atY, float atZ, float pointX, float pointY, float pointZ, float radius) | |
| 06D6 | deleteCheckpoint(Checkpoint checkpoint) | |
| 06D7 | switchRandomTrains(bool enable) | |
| 06D8 | Vehicle train = createMissionTrain(int type, float atX, float atY, float atZ, bool direction) | |
| 06D9 | deleteMissionTrains() | |
| 06DA | markMissionTrainsAsNoLongerNeeded() | |
| 06DB | deleteAllTrains() | |
| 06DC | setTrainSpeed(Vehicle train, float speed) | |
| 06DD | setTrainCruiseSpeed(Vehicle train, float speed) | |
| 06DE | int caboose = getTrainCaboose(Vehicle train) | |
| 06DF | deletePlayer(Player player) | |
| 06E0 | setTwoPlayerCameraMode(bool mode) | |
| 06E1 | taskCarMission(Ped ped, Vehicle car, int targetCar, int order, float maxSpeed, int trafficFlag) | |
| 06E2 | taskGoToObject(Ped ped, int toObject, int timelimit, float stopWithinRadius) | |
| 06E3 | taskWeaponRoll(Ped ped, bool roll) | |
| 06E4 | taskCharArrestChar(Ped ped, int bustActor) | |
| 06E5 | Model itemID = getAvailableVehicleMod(Vehicle car, int poolIndex) | |
| 06E6 | int type = getVehicleModType(Model component) | |
| 06E7 | int componentId = addVehicleMod(Vehicle car, Model component) | |
| 06E8 | removeVehicleMod(Vehicle car, int componentId) | |
| 06E9 | requestVehicleMod(Model component) | |
| 06EA | bool result = hasVehicleModLoaded(Model component) | |
| 06EB | markVehicleModAsNoLongerNeeded(Model component) | |
| 06EC | int num = getNumAvailablePaintjobs(Vehicle car) | |
| 06ED | giveVehiclePaintjob(int set, int paintjob) | |
| 06EE | bool result = isGroupMember(Ped ped, int group) | |
| 06EF | bool result = isGroupLeader(Ped ped, int group) | |
| 06F0 | setGroupSeparationRange(int group, float range) | |
| 06F1 | limitTwoPlayerDistance(float distance) | |
| 06F2 | releaseTwoPlayerDistance() | |
| 06F3 | setPlayerPlayerTargetting(bool can) | |
| 06F4 | [1:118] | |
| 06F5 | float X, float Y, float Z = getScriptFireCoords(int fire) | |
| 06F6 | [1:119] | |
| 06F7 | [1:120] | |
| 06F8 | float X, float Y, float Z, float ZAngle = getNthClosestCarNodeWithHeading(float forX, float forY, float forZ, int direction) | |
| 06F9 | [1:121] | |
| 06FA | setPlayersCanBeInSeparateCars(bool allow) | |
| 06FB | [1:122] | |
| 06FC | bool result = doesCarHaveStuckCarCheck(Vehicle car) | |
| 06FD | setPlaybackSpeed(Vehicle car, float speed) | |
| 06FE | [1:123] | |
| 06FF | bool result = areAnyCharsNearChar(Ped ped, float range) | |
| 0700 | [1:124] | |
| 0701 | skipCutsceneEnd() | |
| 0702 | int percentage = getPercentageTaggedInArea(float x1, float y1, float x2, float y2) | |
| 0703 | setTagStatusInArea(float x1, float y1, float x2, float y2, bool value) | |
| 0704 | carGotoCoordinatesRacing(Vehicle car, float toX, float toY, float toZ) | |
| 0705 | startPlaybackRecordedCarUsingAi(Vehicle car, int path) | |
| 0706 | skipInPlaybackRecordedCar(Vehicle car, float path) | |
| 0707 | [3:27] | |
| 0708 | clearCharDecisionMakerEventResponse(int maker, int event) | |
| 0709 | addCharDecisionMakerEventResponse(int maker, int event, int taskID, float respect, float hate, float like, float dislike, bool inCar, bool onFoot) | |
| 070A | taskPickUpObject(Ped ped, Object object, float offsetX, float offsetY, float offsetZ, int boneId1, int boneId2, string performAnimation, int IFPFile, int time) | |
| 070B | dropObject(Ped ped, bool object) | |
| 070C | explodeCarInCutscene(Vehicle car) | |
| 070D | buildPlayerModel(Player player) | |
| 070E | planeAttackPlayer(int hydra, Vehicle car, float radius) | |
| 070F | planeFlyInDirection(int plane, float direction, float altitudemin, float altitudemax) | |
| 0710 | planeFollowEntity(int plane, Ped ped, Vehicle car, float radius) | |
| 0711 | [1:125] | |
| 0712 | [1:126] | |
| 0713 | taskDriveBy(Ped ped, int drivebyActor, Vehicle car, float pX, float pY, float pZ, float radiusX, int radiusY, bool radiusZ, int firingRate) | |
| 0714 | setCarStayInSlowLane(Vehicle car, bool stay) | |
| 0715 | takeRemoteControlOfCar(Player player, Vehicle car) | |
| 0716 | bool result = isClosestObjectOfTypeSmashedOrDamaged(Model object, float atX, float atY, float atZ, float radius, bool smashed, bool damaged) | |
| 0717 | startSettingUpConversation(Ped ped) | |
| 0718 | [1:127] | |
| 0719 | finishSettingUpConversation() | |
| 071A | bool result = isConversationAtNode(Ped ped, GxtString gxtString) | |
| 071B | [1:128] | |
| 071C | [1:129] | |
| 071D | [1:130] | |
| 071E | int health = getObjectHealth(Object object) | |
| 071F | setObjectHealth(Object object, int health) | |
| 0720 | [1:131] | |
| 0721 | [1:132] | |
| 0722 | [1:133] | |
| 0723 | breakObject(Object object, int intensity) | |
| 0724 | heliAttackPlayer(Vehicle heli, Player player, float radius) | |
| 0725 | [1:134] | |
| 0726 | heliFollowEntity(Vehicle heli, Ped ped, Vehicle car, float radius) | |
| 0727 | policeHeliChaseEntity(Vehicle heli, Ped ped, Vehicle car, float radius) | |
| 0728 | [1:135] | |
| 0729 | taskUseMobilePhone(Ped ped, bool hold) | |
| 072A | taskWarpCharIntoCarAsDriver(Ped ped, Vehicle car) | |
| 072B | taskWarpCharIntoCarAsPassenger(Ped ped, Vehicle car, int passengerseat) | |
| 072C | switchCopsOnBikes(bool generate) | |
| 072D | bool result = isFlameInAngledArea2d(float x1, float y1, float x2, float y2, float angle, bool sphere) | |
| 072E | bool result = isFlameInAngledArea3d(float x1, float y1, float z1, float x2, float y2, float z2, float angle, bool sphere) | |
| 072F | addStuckCarCheckWithWarp(Vehicle car, float checkDistance, int time, bool stuck, bool flipped, bool warp, int path) | |
| 0730 | damageCarPanel(Vehicle car, int door) | |
| 0731 | setCarRoll(Vehicle car, float roll) | |
| 0732 | bool result = suppressCarModel(Model modelId) | |
| 0733 | dontSuppressCarModel(Model modelId) | |
| 0734 | dontSuppressAnyCarModels() | |
| 0735 | bool result = isPs2KeyboardKeyPressed(int key) | |
| 0736 | bool result = isPs2KeyboardKeyJustPressed(int key) | |
| 0737 | bool result = isCharHoldingObject(Ped ped, int liftingObject) | |
| 0738 | [1:136] | |
| 0739 | [1:137] | |
| 073A | [1:138] | |
| 073B | setCarCanGoAgainstTraffic(Vehicle car, bool can) | |
| 073C | damageCarDoor(Vehicle car, int door) | |
| 073D | [1:139] | |
| 073E | Vehicle car = getRandomCarInSphereNoSave(float X, float Y, float Z, float radius, int model) | |
| 073F | Ped ped = getRandomCharInSphere(float X, float Y, float Z, float radius, bool pedtypeCivilian, bool gang, bool prostitute) | |
| 0740 | [1:140] | |
| 0741 | bool result = hasCharBeenArrested(Ped ped) | |
| 0742 | setPlaneThrottle(int plane, float throttle) | |
| 0743 | heliLandAtCoords(Vehicle heli, float X, float Y, float Z, float minaltitude, float maxaltitude) | |
| 0744 | [1:141] | |
| 0745 | planeStartsInAir(int hydra) | |
| 0746 | setRelationship(int acquaintance, int pedtype, int toPedtype) | |
| 0747 | clearRelationship(int acquaintance, int pedtype, int toPedtype) | |
| 0748 | [1:142] | |
| 0749 | clearGroupDecisionMakerEventResponse(int maker, int event) | |
| 074A | addGroupDecisionMakerEventResponse(int maker, int event, int taskID, float respect, float hate, float like, float dislike, bool inCar, bool onFoot) | |
| 074B | drawSpriteWithRotation(int texture, float x, float y, float scaleX, float scaleY, float angle, int r, int g, int b, int a) | |
| 074C | taskUseAttractor(Ped ped, int attractor) | |
| 074D | taskShootAtChar(Ped ped, int atActor, int timelimit) | |
| 074E | setInformRespectedFriends(int flags, float radius, int pedsToScan) | |
| 074F | bool result = isCharRespondingToEvent(Ped ped, int event) | |
| 0750 | setObjectVisible(Object object, bool visibility) | |
| 0751 | taskFleeCharAnyMeans(Ped ped, int fleeFrom, float runDistance, int time, bool changeCourse, int unkTime1, int unkTime2, float awayRadius) | |
| 0752 | [1:143] | |
| 0754 | flushPatrolRoute() | |
| 0755 | extendPatrolRoute(float X, float Y, float Z, string animation, string IFPFile) | |
| 0758 | [1:144] | |
| 0759 | [1:145] | |
| 075A | bool result = playObjectAnim(Object object, string animation, string IFPFile, float framedelta, bool lockF, bool loop) | |
| 075B | setRadarZoom(int zoom) | |
| 075C | bool result = doesBlipExist(Marker marker) | |
| 075D | loadPrices(GxtString shopping) | |
| 075E | loadShop(GxtString shopping) | |
| 075F | int num = getNumberOfItemsInShop() | |
| 0760 | int item = getItemInShop(int index) | |
| 0761 | int price = getPriceOfItem(int item) | |
| 0762 | taskDead(Ped ped) | |
| 0763 | setCarAsMissionCar(Vehicle car) | |
| 0764 | [1:146] | |
| 0765 | [1:147] | |
| 0766 | [1:148] | |
| 0767 | setZonePopulationType(GxtString zone, int popcycle) | |
| 076A | setZoneDealerStrength(GxtString zone, int density) | |
| 076B | int strength = getZoneDealerStrength(GxtString zone) | |
| 076C | setZoneGangStrength(GxtString zone, int gang, int density) | |
| 076D | int density = getZoneGangStrength(GxtString zone, int gang) | |
| 076E | [1:149] | |
| 076F | bool result = isMessageBeingDisplayed() | |
| 0770 | setCharIsTargetPriority(Ped ped, bool targetPriority) | |
| 0771 | customPlateDesignForNextCar(Model modelNumplate, int townTexture) | |
| 0772 | taskGotoCar(Ped ped, Vehicle car, int timeMS, float stopAtDistance) | |
| 0773 | [1:150] | |
| 0774 | [1:151] | |
| 0775 | [1:152] | |
| 0776 | requestIpl(string group) | |
| 0777 | removeIpl(string group) | |
| 0778 | removeIplDiscreetly(string group) | |
| 0779 | [1:153] | |
| 077A | setCharRelationship(Ped ped, int acquaintance, int pedtype) | |
| 077B | clearCharRelationship(Ped ped, int acquaintance, int pedtype) | |
| 077C | clearAllCharRelationships(Ped ped, int acquaintance) | |
| 077D | float pitch = getCarPitch(Vehicle car) | |
| 077E | int interior = getActiveInterior() | |
| 077F | [1:154] | |
| 0780 | heliKeepEntityInView(Vehicle heli, Ped ped, Vehicle car, float minaltitude, float maxaltitude) | |
| 0781 | int model = getWeapontypeModel(int id) | |
| 0782 | int slot = getWeapontypeSlot(int id) | |
| 0783 | int info = getShoppingExtraInfo(int item, int flag) | |
| 0784 | givePlayerClothes(Player player, int texture, int model, int bodypart) | |
| 0785 | [1:155] | |
| 0786 | int num = getNumberOfFiresInArea(float x1, float y1, float z1, float x2, float y2, float z2) | |
| 0787 | [1:156] | |
| 0788 | attachWinchToHeli(Vehicle heli, bool magnet) | |
| 0789 | releaseEntityFromWinch(Vehicle heli) | |
| 078A | int carriage = getTrainCarriage(Vehicle train, int handle) | |
| 078B | Vehicle carHandle, Ped pedHandle, Object objectHandle = grabEntityOnWinch(Vehicle heli) | |
| 078C | GxtString name = getNameOfItem(int item) | |
| 078D | [1:157] | |
| 078E | [1:158] | |
| 078F | taskClimb(Ped ped, bool climb) | |
| 0790 | buyItem(int item) | |
| 0791 | [1:159] | |
| 0792 | clearCharTasksImmediately(Ped ped) | |
| 0793 | storeClothesState() | |
| 0794 | restoreClothesState() | |
| 0795 | [1:160] | |
| 0796 | float length = getRopeHeightForObject(int magnet) | |
| 0797 | setRopeHeightForObject(int magnet, float length) | |
| 0798 | Vehicle carHandle, Ped pedHandle, Object objectHandle = grabEntityOnRopeForObject(int magnet) | |
| 0799 | releaseEntityFromRopeForObject(int magnet) | |
| 079A | [1:161] | |
| 079B | [1:162] | |
| 079C | [1:163] | |
| 079D | playerEnteredDockCrane() | |
| 079E | playerEnteredBuildingsiteCrane() | |
| 079F | playerLeftCrane() | |
| 07A0 | performSequenceTaskFromProgress(Ped ped, int sequence, int unkProgress1, int unkProgress2) | |
| 07A1 | setNextDesiredMoveState(int speed) | |
| 07A2 | [1:164] | |
| 07A3 | taskGotoCharAiming(Ped ped, int followActor, float minradius, float maxradius) | |
| 07A4 | int unkProgress1, int unkProgress2 = getSequenceProgressRecursive(Ped ped) | |
| 07A5 | taskKillCharOnFootTimed(Ped ped, int attackActor, int time) | |
| 07A6 | float X, float Y, float Z = getNearestTagPosition(float X, float Y, float Z) | |
| 07A7 | taskJetpack(Ped ped) | |
| 07A8 | setArea51SamSite(bool enable) | |
| 07A9 | bool result, Searchlight searchlight = isCharInAnySearchlight(Ped ped) | |
| 07AA | [1:165] | |
| 07AB | bool result = isTrailerAttachedToCab(Vehicle trailer, Vehicle car) | |
| 07AC | detachTrailerFromCab(Vehicle trailer, Vehicle cab) | |
| 07AD | [1:166] | |
| 07AE | [1:167] | |
| 07AF | int group = getPlayerGroup(Player player) | |
| 07B0 | GxtString shop = getLoadedShop() | |
| 07B1 | int int2, int int3, int int4 = getBeatProximity(int track) | |
| 07B2 | [1:168] | |
| 07B3 | setGroupDefaultTaskAllocator(int group, int command) | |
| 07B4 | setPlayerGroupRecruitment(Player player, bool enabled) | |
| 07B5 | [1:169] | |
| 07B6 | [1:170] | |
| 07B7 | [1:171] | |
| 07B8 | [1:172] | |
| 07BA | [1:173] | |
| 07BB | activateHeliSpeedCheat(Vehicle heli, int power) | |
| 07BC | taskSetCharDecisionMaker(Ped ped, int maker) | |
| 07BD | deleteMissionTrain(Vehicle train) | |
| 07BE | markMissionTrainAsNoLongerNeeded(Vehicle train) | |
| 07BF | setBlipAlwaysDisplayOnZoomedRadar(Marker marker, bool displayAlways) | |
| 07C0 | requestCarRecording(int path) | |
| 07C1 | bool result = hasCarRecordingBeenLoaded(int path) | |
| 07C2 | [1:174] | |
| 07C3 | float x, float y, float z, float w = getObjectQuaternion(Object object) | [4:1] |
| 07C4 | setObjectQuaternion(Object object, float x, float y, float z, float w) | [4:2] |
| 07C5 | float x, float y, float z, float w = getVehicleQuaternion(Vehicle car) | [4:3] |
| 07C6 | setVehicleQuaternion(Vehicle car, float x, float y, float z, float w) | [4:4] |
| 07C7 | setMissionTrainCoordinates(Vehicle train, float X, float Y, float Z) | |
| 07C8 | [1:175] | |
| 07C9 | taskComplexPickupObject(Ped ped, Object object) | |
| 07CA | [1:176] | |
| 07CB | listenToPlayerGroupCommands(Ped ped, bool listen) | |
| 07CC | setPlayerEnterCarButton(Player player, bool can) | |
| 07CD | taskCharSlideToCoord(Ped ped, float toX, float toY, float toZ, float angle, float withinRadius) | |
| 07CE | [1:177] | |
| 07CF | [1:178] | |
| 07D0 | int weekday = getCurrentDayOfWeek() | |
| 07D1 | [1:179] | |
| 07D2 | [1:180] | |
| 07D3 | registerScriptBrainForCodeUse(int id, GxtString gxtString) | |
| 07D4 | [1:181] | |
| 07D5 | applyForceToCar(Vehicle car, float vecX, float vecY, float vecZ, float rotationX, float rotationY, float rotationZ) | |
| 07D6 | [3:28] | |
| 07D7 | [3:29] | |
| 07DA | addToCarRotationVelocity(Vehicle car, float vecX, float vecY, float vecZ) | |
| 07DB | setCarRotationVelocity(Vehicle car, float vecX, float vecY, float vecZ) | |
| 07DC | [1:182] | |
| 07DD | setCharShootRate(Ped ped, int rate) | |
| 07DE | bool result = isModelInCdimage(Model modelId) | |
| 07DF | removeOilPuddlesInArea(float x1, float y1, float x2, float y2) | |
| 07E0 | setBlipAsFriendly(Marker marker, bool type) | |
| 07E1 | taskSwimToCoord(Ped ped, float toX, float toY, float toZ) | |
| 07E2 | [1:183] | |
| 07E3 | [1:184] | |
| 07E4 | float x1, float y1, float z1, float x2, float y2, float z2 = getModelDimensions(Model modelId) | |
| 07E5 | int maker = copyCharDecisionMaker(Ped ped) | |
| 07E6 | int maker = copyGroupDecisionMaker(int group) | |
| 07E7 | taskDrivePointRouteAdvanced(Ped ped, Vehicle car, float speed, int flag1, int flag2, int flag3) | |
| 07E8 | bool result = isRelationshipSet(int acquaintance, int ofActors, int toActors) | |
| 07E9 | [1:185] | |
| 07EA | [1:186] | |
| 07EB | [1:187] | |
| 07EC | [1:188] | |
| 07ED | [1:189] | |
| 07EE | setCarAlwaysCreateSkids(Vehicle car, bool enable) | |
| 07EF | int city = getCityFromCoords(float X, float Y, float Z) | |
| 07F0 | bool result = hasObjectOfTypeBeenSmashed(float X, float Y, float Z, float radius, Model modelId) | |
| 07F1 | bool result = isPlayerPerformingWheelie(Player player) | |
| 07F2 | bool result = isPlayerPerformingStoppie(Player player) | |
| 07F3 | setCheckpointCoords(Checkpoint checkpoint, float X, float Y, float Z) | |
| 07F4 | [1:190] | |
| 07F5 | controlCarHydraulics(Vehicle car, float f1, float f2, float f3, float f4) | |
| 07F6 | int numberOfLeaders, int numberOfMembers = getGroupSize(int group) | |
| 07F7 | setObjectCollisionDamageEffect(Object object, bool destructible) | |
| 07F8 | setCarFollowCar(Vehicle car, int followCar, float radius) | |
| 07F9 | playerEnteredQuarryCrane() | |
| 07FA | playerEnteredLasVegasCrane() | |
| 07FB | switchEntryExit(GxtString interior, bool access) | |
| 07FC | displayTextWithFloat(float X, float Y, GxtString GXT, float value, int flag) | |
| 07FD | bool result = doesGroupExist(int group) | |
| 07FE | giveMeleeAttackToChar(Ped ped, int fightingStyle, int moves) | |
| 07FF | setCarHydraulics(Vehicle car, bool hydraulics) | |
| 0800 | bool result = is2playerGameGoingOn() | |
| 0801 | float fov = getCameraFov() | |
| 0803 | bool result = doesCarHaveHydraulics(Vehicle car) | |
| 0804 | taskCharSlideToCoordAndPlayAnim(Ped ped, float toX, float toY, float toZ, float angle, float radius, string animation, int ifp1, float ifp2, bool LA, bool LX, bool LY, bool LF, int LT) | |
| 0805 | [1:191] | |
| 0806 | int number = getTotalNumberOfPedsKilledByPlayer(Player player) | |
| 0807 | [1:192] | |
| 0808 | [1:193] | |
| 0809 | [1:194] | |
| 080A | float X, float Y, float Z = getLevelDesignCoordsForObject(Object object, int spoot) | |
| 080B | [1:195] | |
| 080C | [1:196] | |
| 080D | [1:197] | |
| 080E | int event = getCharHighestPriorityEvent(Ped ped) | |
| 080F | [1:198] | |
| 0810 | float X, float Y, float Z = getParkingNodeInArea(float x1, float y1, float z1, float x2, float y2, float z2) | |
| 0811 | Vehicle car = getCarCharIsUsing(Ped ped) | |
| 0812 | taskPlayAnimNonInterruptable(Ped ped, string animation, string IFP, float framedelta, bool loopA, bool lockX, bool lockY, bool lockF, int time) | |
| 0813 | [1:199] | |
| 0814 | addStuntJump(float startX, float startY, float startZ, float radiusX, float radiusY, float radiusZ, float goalX, float goalY, float goalZ, float radius2X, float radius2Y, float radius2Z, float cameraX, float cameraY, float cameraZ, int reward) | |
| 0815 | setObjectCoordinatesAndVelocity(Object object, float X, float Y, float Z) | |
| 0816 | setCharKindaStayInSamePlace(Ped ped, bool stay) | |
| 0817 | taskFollowPatrolRoute(Ped ped, int walkMode, int routeMode) | |
| 0818 | bool result = isCharInAir(Ped ped) | |
| 0819 | float height = getCharHeightAboveGround(Ped ped) | |
| 081A | setCharWeaponSkill(Ped ped, int skill) | |
| 081B | [1:200] | |
| 081C | setTextEdge(int size, int r, int g, int b, int a) | |
| 081D | setCarEngineBroken(Vehicle car, bool broken) | |
| 081E | bool result = isThisModelABoat(Model modelId) | |
| 081F | bool result = isThisModelAPlane(Model modelId) | |
| 0820 | bool result = isThisModelAHeli(Model modelId) | |
| 0821 | [1:201] | |
| 0822 | setFirstPersonInCarCameraMode(bool enable) | |
| 0823 | taskGreetPartner(Ped ped, Ped ped2, float unk1, int unk2) | |
| 0824 | [1:202] | |
| 0825 | setHeliBladesFullSpeed(Vehicle heli) | |
| 0826 | displayHud(bool enable) | |
| 0827 | connectLods(Object object, int lod) | |
| 0828 | setMaxFireGenerations(int max) | |
| 0829 | taskDieNamedAnim(Ped ped, string animation, string ifp1, float ifp2, int time) | |
| 082A | setPlayerDuckButton(Player player, bool able) | |
| 0830 | setPoolTableCoords(float x1, float y1, float z1, float x2, float y2, float z2) | |
| 0831 | [1:203] | |
| 0832 | [1:204] | |
| 0833 | bool result = hasObjectBeenPhotographed(Object object) | |
| 0834 | doCameraBump(float rotationZ, float rotationY) | |
| 0835 | int day, int month = getCurrentDate() | |
| 0836 | setObjectAnimSpeed(Object object, string animation, float speed) | |
| 0837 | bool result = isObjectPlayingAnim(Object object, string anim) | |
| 0838 | [1:205] | |
| 0839 | float progress = getObjectAnimCurrentTime(Object object, string animation) | |
| 083A | setObjectAnimCurrentTime(Object object, string animation, float progress) | |
| 083B | [1:206] | |
| 083C | setCharVelocity(Ped ped, float vecX, float vecY, float vecZ) | |
| 083D | float vecX, float vecY, float vecZ = getCharVelocity(Ped ped) | |
| 083E | setCharRotation(Ped ped, float vecX, float vecY, float vecZ) | |
| 083F | float value = getCarUprightValue(Vehicle car) | |
| 0840 | setVehicleInterior(Vehicle car, int interior) | |
| 0841 | selectWeaponsForVehicle(Vehicle car, bool gun) | |
| 0842 | int city = getCityPlayerIsIn(Player player) | |
| 0843 | GxtString name = getNameOfZone(float X, float Y, float Z) | |
| 0844 | [3:30] | |
| 0845 | [3:31] | |
| 0846 | [3:32] | |
| 0847 | [3:33] | |
| 0848 | [1:207] | |
| 0849 | [1:208] | |
| 084A | [1:209] | |
| 084B | [1:210] | |
| 084C | [1:211] | |
| 084D | activateInteriorPeds(bool activate) | |
| 084E | setVehicleCanBeTargetted(Vehicle car, bool unk) | |
| 084F | [1:212] | |
| 0850 | taskFollowFootsteps(Ped ped, int followActor) | |
| 0851 | damageChar(Ped ped, int health, bool affectArmour) | |
| 0852 | setCarCanBeVisiblyDamaged(Vehicle car, bool can) | |
| 0853 | setHeliReachedTargetDistance(Vehicle heli, int dist) | |
| 0855 | float level = getSoundLevelAtCoords(Ped ped, float X, float Y, float Z) | |
| 0856 | setCharAllowedToDuck(Ped ped, bool enable) | |
| 0857 | [1:213] | |
| 0858 | setHeadingForAttachedPlayer(Player player, float toAngle, float rotationSpeed) | |
| 0859 | taskWalkAlongsideChar(Ped ped, int alongisdeActor) | |
| 085A | createEmergencyServicesCar(Model car, float X, float Y, float Z) | |
| 085B | taskKindaStayInSamePlace(Ped ped, bool stay) | |
| 085C | [1:214] | |
| 085D | [1:215] | |
| 085E | startPlaybackRecordedCarLooped(Vehicle car, int path) | |
| 085F | [1:216] | |
| 0860 | setCharInterior(Ped ped, int interior) | |
| 0861 | bool result = isAttachedPlayerHeadingAchieved(Player player) | |
| 0862 | [1:217] | |
| 0863 | [1:218] | |
| 0864 | enableEntryExitPlayerGroupWarping(float X, float Y, float radius, bool access) | |
| 0866 | Object object = getClosestStealableObject(float X, float Y, float Z, float radius) | |
| 0867 | bool result = isProceduralInteriorActive(int interior) | |
| 0868 | [1:219] | |
| 0869 | [1:220] | |
| 086A | [1:221] | |
| 086B | [1:222] | |
| 086C | [1:223] | |
| 086D | [1:224] | |
| 086E | [1:225] | |
| 086F | [1:226] | |
| 0870 | [1:227] | |
| 0871 | [3:34] | |
| 0872 | [3:35] | |
| 0873 | removeCarRecording(int path) | |
| 0874 | setZonePopulationRace(GxtString zone, int popcycle) | |
| 0875 | setObjectOnlyDamagedByPlayer(Object object, bool player) | |
| 0876 | createBirds(float x1, float y1, float z1, float x2, float y2, float z2, int flag1, int flag2) | |
| 0877 | [1:228] | |
| 0878 | setVehicleDirtLevel(Vehicle car, float level) | |
| 0879 | setGangWarsActive(bool enable) | |
| 087A | bool result = isGangWarGoingOn() | |
| 087B | givePlayerClothesOutsideShop(Player player, string clothes, string model, int bodyPart) | |
| 087C | clearLoadedShop() | |
| 087D | setGroupSequence(int group, int Aspack) | |
| 087E | setCharDropsWeaponsWhenDead(Ped ped, bool droppable) | |
| 087F | setCharNeverLeavesGroup(Ped ped, bool set) | |
| 0880 | [1:229] | |
| 0881 | setPlayerFireButton(Player player, bool able) | |
| 0882 | [1:230] | |
| 0883 | attachFxSystemToCharBone(Particle particle, Ped ped, int mode) | |
| 0884 | registerAttractorScriptBrainForCodeUse(int handle, GxtString script) | |
| 0885 | [1:231] | |
| 0886 | [1:232] | |
| 0887 | setHeadingLimitForAttachedChar(Ped ped, int orientation, float limit) | |
| 0888 | Marker blip = addBlipForDeadChar(Ped ped) | |
| 0889 | float X, float Y, float Z = getDeadCharCoordinates(Ped ped) | |
| 088A | taskPlayAnimWithFlags(Ped ped, string animation, string ifp, float framedelta, bool loopA, bool lockX, bool lockY, bool lockF, int time, bool force, bool lockZ) | |
| 088B | setVehicleAirResistanceMultiplier(Vehicle car, float multiplier) | |
| 088C | setCarCoordinatesNoOffset(Vehicle car, float X, float Y, float Z) | |
| 088D | setUsesCollisionOfClosestObjectOfType(float X, float Y, float Z, float radius, Model modelId, bool collisionDetection) | |
| 088E | setTimeOneDayForward() | |
| 088F | [1:233] | |
| 0890 | setTimerBeepCountdownTime(VarId timer, int reach) | |
| 0891 | [1:234] | |
| 0892 | [1:235] | |
| 0893 | attachTrailerToCab(int trailer, int cab) | |
| 0894 | [1:236] | |
| 0895 | [1:237] | |
| 0896 | [1:238] | |
| 0897 | bool result = isVehicleTouchingObject(Vehicle car, Object object) | |
| 0898 | enableCraneControls(bool UP, bool DOWN, bool RELEASE) | |
| 0899 | [1:239] | |
| 089A | [1:240] | |
| 089B | bool result = isPlayerInPositionForConversation(Ped ped) | |
| 089C | enableConversation(Ped ped, bool enable) | |
| 089D | [1:241] | |
| 089E | Ped ped = getRandomCharInSphereOnlyDrugsBuyers(float X, float Y, float Z, float radius) | |
| 089F | int pedtype = getPedType(Ped ped) | |
| 08A0 | bool result = taskUseClosestMapAttractor(Ped ped, float radius, Model nearModel, float offsetX, float offsetY, float offsetZ, string scriptNamed) | |
| 08A1 | [1:242] | |
| 08A2 | planeAttackPlayerUsingDogFight(int hydra, Player player, float radius) | |
| 08A3 | canTriggerGangWarWhenOnAMission(bool can) | |
| 08A4 | controlMovableVehiclePart(Vehicle car, float angle) | |
| 08A5 | winchCanPickVehicleUp(Vehicle car, bool attractive) | |
| 08A6 | openCarDoorABit(Vehicle car, int door, float rotation) | |
| 08A7 | bool result = isCarDoorFullyOpen(Vehicle car, int door) | |
| 08A8 | setAlwaysDraw3dMarkers(bool set) | |
| 08A9 | streamScript(int script) | |
| 08AA | [1:243] | |
| 08AB | bool result = hasStreamedScriptLoaded(int script) | |
| 08AC | setGangWarsTrainingMission(bool set) | |
| 08AD | setCharHasUsedEntryExit(Ped ped, float X, float Y, float radius) | |
| 08AE | [1:244] | |
| 08AF | setCharMaxHealth(Ped ped, int health) | |
| 08B0 | [1:245] | |
| 08B1 | setNightVision(bool enable) | |
| 08B2 | setInfraredVision(bool enable) | |
| 08B3 | setZoneForGangWarsTraining(GxtString zone) | |
| 08B4 | [3:36] | |
| 08B5 | [3:37] | |
| 08B6 | [3:38] | |
| 08B7 | [3:39] | |
| 08B8 | [3:40] | |
| 08B9 | [3:41] | |
| 08BA | [3:42] | |
| 08BB | [3:43] | |
| 08BC | [3:44] | |
| 08BD | [3:45] | |
| 08BE | [3:46] | |
| 08BF | [3:47] | |
| 08C0 | [3:48] | |
| 08C1 | [3:49] | |
| 08C2 | [3:50] | |
| 08C3 | [3:51] | |
| 08C4 | [3:52] | |
| 08C5 | [3:53] | |
| 08C6 | setCharCanBeKnockedOffBike(Ped ped, bool can) | |
| 08C7 | setCharCoordinatesDontWarpGang(Ped ped, float X, float Y, float Z) | |
| 08C8 | addPriceModifier(int item, int price) | |
| 08C9 | removePriceModifier(int item) | |
| 08CA | initZonePopulationSettings() | |
| 08CB | explodeCarInCutsceneShakeAndBits(Vehicle car, bool shake, bool effect, bool sound) | |
| 08CC | [1:246] | |
| 08CD | [1:247] | |
| 08CE | [1:248] | |
| 08CF | [1:249] | |
| 08D0 | bool result = isSkipCutsceneButtonPressed() | |
| 08D1 | bool result, float X, float Y, float Z = getCutsceneOffset() | |
| 08D2 | setObjectScale(Object object, float scale) | |
| 08D3 | int popcycle = getCurrentPopulationZoneType() | |
| 08D4 | int menu = createMenu(GxtString title, float posX, float posY, float width, int columns, bool interactive, bool background, int alignment) | |
| 08D5 | [1:250] | |
| 08D6 | setMenuColumnOrientation(int menu, int column, int alignment) | |
| 08D7 | int item = getMenuItemSelected(int menu) | |
| 08D8 | int item = getMenuItemAccepted(int menu) | |
| 08D9 | activateMenuItem(int menu, int row, bool enable) | |
| 08DA | deleteMenu(int menu) | |
| 08DB | setMenuColumn(int menu, int column, GxtString header, GxtString data1, GxtString data2, GxtString data3, GxtString data4, GxtString data5, GxtString data6, GxtString data7, GxtString data8, GxtString data9, GxtString data10, GxtString data11, GxtString data12) | |
| 08DC | setBlipEntryExit(Marker marker, float X, float Y, float radius) | |
| 08DD | switchDeathPenalties(bool lose) | |
| 08DE | switchArrestPenalties(bool lose) | |
| 08DF | setExtraHospitalRestartPoint(float X, float Y, float Z, float radius, float angle) | |
| 08E0 | setExtraPoliceStationRestartPoint(float X, float Y, float Z, float radius, float angle) | |
| 08E1 | int num = findNumberTagsTagged() | |
| 08E2 | int percentage = getTerritoryUnderControlPercentage() | |
| 08E3 | bool result = isObjectInAngledArea2d(Object object, float x1, float y1, float x2, float y2, float radius, bool sphere) | |
| 08E4 | bool result = isObjectInAngledArea3d(Object object, float x1, float y1, float z1, float x2, float y2, float z2, float depth, bool flag) | |
| 08E5 | Ped ped = getRandomCharInSphereNoBrain(float X, float Y, float Z, float radius) | |
| 08E6 | setPlaneUndercarriageUp(int plane, bool set) | |
| 08E7 | disableAllEntryExits(bool disable) | |
| 08E8 | attachAnimsToModel(Model modelId, GxtString externalScript) | |
| 08E9 | setObjectAsStealable(Object object, bool liftable) | |
| 08EA | setCreateRandomGangMembers(bool enable) | |
| 08EB | addSparks(float posX, float posY, float posZ, float vecX, float vecY, float vecZ, int density) | |
| 08EC | int class = getVehicleClass(Vehicle car) | |
| 08ED | clearConversationForChar(Ped ped) | |
| 08EE | setMenuItemWithNumber(int panel, int column, int row, GxtString gxtString, int number) | |
| 08EF | setMenuItemWith2Numbers(int panel, int column, int row, GxtString gxtString, int numbers1, int numbers2) | |
| 08F0 | setCutsceneModelTexture(GxtString cutsceneModel, GxtString textureName) | |
| 08F1 | GxtString nameB = getNameOfInfoZone(float atX, float atY, float atZ) | |
| 08F2 | vehicleCanBeTargettedByHsMissile(Vehicle car, bool targetable) | |
| 08F3 | setFreebiesInVehicle(Vehicle car, bool containsGoodies) | |
| 08F4 | setScriptLimitToGangSize(bool max) | |
| 08F5 | makePlayerGangDisappear() | |
| 08F6 | makePlayerGangReappear() | |
| 08F7 | int textureCRC, int modelCRC = getClothesItem(Player player, int bodypart) | |
| 08F8 | showUpdateStats(bool display) | |
| 08F9 | [3:54] | |
| 08FA | [3:55] | |
| 08FB | setCoordBlipAppearance(Checkpoint checkpoint, int type) | |
| 08FC | [1:251] | |
| 08FD | setHeathazeEffect(bool enable) | |
| 08FE | bool result = isHelpMessageBeingDisplayed() | |
| 08FF | bool result = hasObjectBeenDamagedByWeapon(Object object, int type) | |
| 0900 | clearObjectLastWeaponDamage(Object object) | |
| 0901 | setPlayerJumpButton(Player player, bool enable) | |
| 0902 | [1:252] | |
| 0903 | [1:253] | |
| 0904 | int r, int g, int b, int a = getHudColour(int interface) | |
| 0905 | lockDoor(int door, bool lock) | |
| 0906 | setObjectMass(Object object, float mass) | |
| 0907 | float mass = getObjectMass(int int) | |
| 0908 | setObjectTurnMass(Object object, float turnMass) | |
| 0909 | float turnMass = getObjectTurnMass(Object object) | |
| 090A | [1:254] | |
| 090B | [1:255] | |
| 090C | setSpecificZoneToTriggerGangWar(GxtString zone) | |
| 090D | clearSpecificZonesToTriggerGangWar() | |
| 090E | setActiveMenuItem(int panel, int activeRow) | |
| 090F | markStreamedScriptAsNoLongerNeeded(int externalScript) | |
| 0910 | removeStreamedScript(int externalScript) | |
| 0911 | [1:256] | |
| 0912 | setMessageFormatting(bool priority, int leftmargin, int maxwidth) | |
| 0913 | startNewStreamedScript(int externalScript, table args) | |
| 0914 | [1:257] | |
| 0915 | setWeatherToAppropriateTypeNow() | |
| 0916 | winchCanPickObjectUp(Object object, bool enable) | |
| 0917 | switchAudioZone(GxtString zone, bool enableSound) | |
| 0918 | setCarEngineOn(Vehicle car, bool on) | |
| 0919 | setCarLightsOn(Vehicle car, bool lights) | |
| 091A | [1:258] | |
| 091B | [1:259] | |
| 091C | Ped ped = getUserOfClosestMapAttractor(float sphereX, float sphereY, float sphereZ, float radius, Model modelId, string externalScriptNamed) | |
| 091D | switchRoadsBackToOriginal(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 091E | switchPedRoadsBackToOriginal(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 091F | int landingGearStatus = getPlaneUndercarriagePosition(int plane) | |
| 0920 | cameraSetVectorTrack(float pointX, float pointY, float pointZ, float transverseX, float transverseY, float transverseZ, int time, bool smooth) | |
| 0921 | [1:260] | |
| 0922 | cameraSetLerpFov(float from, float to, int timelimit, bool smoothTransition) | |
| 0923 | switchAmbientPlanes(bool enable) | |
| 0924 | setDarknessEffect(bool enable, int value) | |
| 0925 | cameraResetNewScriptables() | |
| 0926 | int value = getNumberOfInstancesOfStreamedScript(int externalScript) | |
| 0927 | [1:261] | |
| 0928 | allocateStreamedScriptToRandomPed(int externalScript, Model actorModel, int priority) | |
| 0929 | allocateStreamedScriptToObject(int externalScript, Model objectModel, int priority, float radius, int type) | |
| 092A | [1:262] | |
| 092B | int handle = getGroupMember(int group, int member) | |
| 092C | [1:263] | |
| 092D | [1:264] | |
| 092E | float height = getWaterHeightAtCoords(float atX, float atY, bool ignoreWaves) | |
| 092F | cameraPersistTrack(bool lock) | |
| 0930 | cameraPersistPos(bool lock) | |
| 0931 | cameraPersistFov(bool lock) | |
| 0932 | [1:265] | |
| 0933 | bool result = cameraIsVectorMoveRunning() | |
| 0934 | bool result = cameraIsVectorTrackRunning() | |
| 0935 | [1:266] | |
| 0936 | cameraSetVectorMove(float cameraX, float cameraY, float cameraZ, float positionX, float positionY, float positionZ, int time, bool smoothTransition) | |
| 0937 | drawWindow(float cornerAX, float cornerAY, float cornerBX, float cornerBY, GxtString gxtString, int style) | |
| 0938 | [1:267] | |
| 0939 | attachCarToObject(Vehicle car, Object object, float offsetX, float offsetY, float offsetZ, float rotationX, float rotationY, float rotationZ) | |
| 093A | setGarageResprayFree(GxtString garage, bool free) | |
| 093B | setCharBulletproofVest(Ped ped, bool enable) | |
| 093C | [1:268] | |
| 093D | setCinemaCamera(bool lock) | |
| 093E | setCharFireDamageMultiplier(Ped ped, float multiplier) | |
| 093F | [1:269] | |
| 0940 | setGroupFollowStatus(int group, bool status) | |
| 0941 | setSearchlightClipIfColliding(Searchlight searchlight, bool flag) | |
| 0942 | bool result = hasPlayerBoughtItem(int item) | |
| 0943 | [1:270] | |
| 0944 | setCameraInFrontOfChar(Ped ped) | |
| 0945 | int maxArmour = getPlayerMaxArmour(Player player) | |
| 0946 | setCharUsesUpperbodyDamageAnimsOnly(Ped ped, bool uninterupted) | |
| 0947 | int spokenPhrase = setCharSayContext(Ped ped, int speech) | |
| 0948 | addExplosionVariableShake(float atX, float atY, float atZ, int type, float cameraShake) | |
| 0949 | attachMissionAudioToChar(int id, Ped ped) | |
| 094A | updatePickupMoneyPerDay(Pickup pickup, int cash) | |
| 094B | GxtString interiorName = getNameOfEntryExitCharUsed(Ped ped) | |
| 094C | float coordX, float coordY, float coordZ, int number = getPositionOfEntryExitCharUsed(Ped ped) | |
| 094D | bool result = isCharTalking(Ped ped) | |
| 094E | disableCharSpeech(Ped ped, bool disable) | |
| 094F | enableCharSpeech(Ped ped) | |
| 0950 | setUpSkip(float posX, float posY, float posZ, float angle) | |
| 0951 | clearSkip() | |
| 0952 | preloadBeatTrack(int soundtrack) | |
| 0953 | int status = getBeatTrackStatus() | |
| 0954 | playBeatTrack() | |
| 0955 | stopBeatTrack() | |
| 0956 | int max = findMaxNumberOfGroupMembers() | |
| 0957 | vehicleDoesProvideCover(Vehicle car, bool providesCover) | |
| 0958 | Pickup pickup = createSnapshotPickup(float atX, float atY, float atZ) | |
| 0959 | Pickup pickup = createHorseshoePickup(float atX, float atY, float atZ) | |
| 095A | Pickup pickup = createOysterPickup(float atX, float atY, float atZ) | |
| 095B | bool result = hasObjectBeenUprooted(Object object) | |
| 095C | addSmokeParticle(float atX, float atY, float atZ, float velocityX, float velocityY, float velocityZ, int r, int g, int b, int a, float size, float factor) | |
| 095D | bool result = isCharStuckUnderCar(Ped ped) | |
| 095E | controlCarDoor(Vehicle car, int door, int unlatch, float angle) | |
| 095F | float angle = getDoorAngleRatio(Vehicle car, int door) | |
| 0960 | setPlayerDisplayVitalStatsButton(Player player, bool display) | |
| 0961 | setCharKeepTask(Ped ped, bool keepTasks) | |
| 0962 | [1:271] | |
| 0963 | [1:272] | |
| 0964 | int id = createMenuGrid(GxtString gxtString, int positionX, int positionY, float width, int columns, bool interactive, bool background, int alignment) | |
| 0965 | bool result = isCharSwimming(Ped ped) | |
| 0966 | int status = getCharSwimState(Ped ped) | |
| 0967 | startCharFacialTalk(Ped ped, int time) | |
| 0968 | stopCharFacialTalk(Ped ped) | |
| 0969 | bool result = isBigVehicle(Vehicle car) | |
| 096A | switchPoliceHelis(bool enable) | |
| 096B | storeCarModState() | |
| 096C | restoreCarModState() | |
| 096D | Model modelId = getCurrentCarMod(Vehicle car, int slot) | |
| 096E | bool result = isCarLowRider(Vehicle car) | |
| 096F | bool result = isCarStreetRacer(Vehicle car) | |
| 0970 | forceDeathRestart() | |
| 0971 | syncWater() | |
| 0972 | setCharCoordinatesNoOffset(Ped ped, float atX, float atY, float atZ) | |
| 0973 | bool result = doesScriptFireExist(int fire) | |
| 0974 | resetStuffUponResurrection() | |
| 0975 | bool result = isEmergencyServicesVehicle(Vehicle car) | |
| 0976 | killFxSystemNow(Particle particle) | |
| 0977 | bool result = isObjectWithinBrainActivationRange(Player player) | |
| 0978 | int to = copySharedCharDecisionMaker(int from) | |
| 0979 | [1:273] | |
| 097A | reportMissionAudioEventAtPosition(float atX, float atY, float atZ, int event) | |
| 097B | reportMissionAudioEventAtObject(int at, int event) | |
| 097C | attachMissionAudioToObject(int id, Object object) | |
| 097D | int colours = getNumCarColours(Vehicle car) | |
| 097E | [1:274] | |
| 097F | [1:275] | |
| 0980 | extinguishFireAtPoint(float atX, float atY, float atZ, float radius) | |
| 0981 | bool result = hasTrainDerailed(Vehicle train) | |
| 0982 | setCharForceDieInCar(Ped ped, bool stayInCarWhenDead) | |
| 0983 | setOnlyCreateGangMembers(bool enable) | |
| 0984 | Model modelId = getObjectModel(Object object) | |
| 0985 | setCharUsesCollisionClosestObjectOfType(float sphereX, float sphereY, float sphereZ, float radius, Model modelId, bool solid, int forActor) | |
| 0986 | clearAllScriptFireFlags() | |
| 0987 | int blockingCar = getCarBlockingCar(Vehicle car) | |
| 0988 | int paintjob = getCurrentVehiclePaintjob(Vehicle car) | |
| 0989 | setHelpMessageBoxSize(int width) | |
| 098A | setGunshotSenseRangeForRiot2(float range) | |
| 098B | [3:56] | |
| 098C | [3:57] | |
| 098D | float angle = getCarMovingComponentOffset(Vehicle car) | |
| 098E | setNamedEntryExitFlag(GxtString interior, int bitmask, bool flag) | |
| 098F | [1:276] | |
| 0990 | [1:277] | |
| 0991 | pauseCurrentBeatTrack(bool paused) | |
| 0992 | setPlayerWeaponsScrollable(Player player, bool scrollable) | |
| 0993 | [1:278] | |
| 0994 | markRoadNodeAsDontWander(float atX, float atY, float atZ) | |
| 0995 | unmarkAllRoadNodesAsDontWander() | |
| 0996 | setCheckpointHeading(Checkpoint checkpoint, float angle) | |
| 0997 | setMissionRespectTotal(int respect) | |
| 0998 | awardPlayerMissionRespect(int respect) | |
| 0999 | [1:279] | |
| 099A | setCarCollision(Vehicle car, bool collision) | |
| 099B | changePlaybackToUseAi(Vehicle car) | |
| 099C | cameraSetShakeSimulationSimple(int type, float timelimit, float intensity) | |
| 099D | bool result = isNightVisionActive() | |
| 099E | setCreateRandomCops(bool enable) | |
| 099F | taskSetIgnoreWeaponRangeFlag(Ped ped, bool ignore) | |
| 09A0 | taskPickUpSecondObject(Ped ped, Object object, float offsetX, float offsetY, float offsetZ, int bone, int int7, string animation, string file, int time) | |
| 09A1 | dropSecondObject(Ped ped, bool to) | |
| 09A2 | removeObjectElegantly(Object object) | |
| 09A3 | drawCrosshair(bool draw) | |
| 09A4 | setUpConversationNodeWithSpeech(GxtString question, GxtString answerY, GxtString answerN, int questionWav, int answerYWav, int answerNWav) | |
| 09A5 | [1:280] | |
| 09A6 | showBlipsOnAllLevels(bool enable) | |
| 09A7 | setCharDruggedUp(Ped ped, bool druggedUp) | |
| 09A8 | bool result = isCharHeadMissing(Ped ped) | |
| 09A9 | int CRC32 = getHashKey(string string) | |
| 09AA | setUpConversationEndNodeWithSpeech(GxtString gxtString, int speech) | |
| 09AB | randomPassengerSay(int passengers, int audioTable) | |
| 09AC | hideAllFrontendBlips(bool hide) | |
| 09AD | setPlayerInCarCameraMode(int mode) | |
| 09AE | bool result = isCharInAnyTrain(Ped ped) | |
| 09AF | setUpSkipAfterMission(float posX, float posY, float posZ, float angle) | |
| 09B0 | setVehicleIsConsideredByPlayer(Vehicle car, bool accessible) | |
| 09B1 | [1:281] | |
| 09B2 | Model modelId, int class = getRandomCarModelInMemory(bool unk) | |
| 09B3 | int doorStatus = getCarDoorLockStatus(Vehicle car) | |
| 09B4 | setClosestEntryExitFlag(float atX, float atY, float radius, int bitmask, bool flag) | |
| 09B5 | setCharSignalAfterKill(Ped ped, bool signal) | |
| 09B6 | setCharWantedByPolice(Ped ped, bool wanted) | |
| 09B7 | setZoneNoCops(GxtString zone, bool disableCops) | |
| 09B8 | addBlood(float atX, float atY, float atZ, float offsetX, float offsetY, float offsetZ, int density, int onActor) | |
| 09B9 | displayCarNames(bool show) | |
| 09BA | displayZoneNames(bool show) | |
| 09BB | bool result = isCarDoorDamaged(Vehicle car, int door) | |
| 09BC | setCharCoordinatesDontWarpGangNoOffset(Ped ped, float atX, float atY, float atZ) | |
| 09BD | setMinigameInProgress(bool enable) | |
| 09BE | bool result = isMinigameInProgress() | |
| 09BF | setForceRandomCarModel(Model modelId) | |
| 09C0 | Vehicle car = getRandomCarOfTypeInAngledAreaNoSave(float x1, float y1, float x2, float y2, float angle, int int6) | |
| 09C1 | addNextMessageToPreviousBriefs(bool int1) | |
| 09C2 | failKillFrenzy() | |
| 09C3 | bool result = isCopVehicleInArea3dNoSave(float cornerAX, float cornerAY, float cornerAZ, float cornerBX, float cornerBY, float cornerBZ) | |
| 09C4 | setPetrolTankWeakpoint(Vehicle car, bool enabled) | |
| 09C5 | bool result = isCharUsingMapAttractor(Ped ped) | |
| 09C6 | [1:282] | |
| 09C7 | setPlayerModel(Player player, Model modelId) | |
| 09C8 | bool result = areSubtitlesSwitchedOn() | |
| 09C9 | removeCharFromCarMaintainPosition(Ped ped, Vehicle car) | |
| 09CA | setObjectProofs(Object object, bool BP, bool FP, bool EP, bool CP, bool MP) | |
| 09CB | bool result = isCarTouchingCar(Vehicle car1, Vehicle car2) | |
| 09CC | bool result = doesObjectHaveThisModel(Object object, Model modelId) | |
| 09CF | setTrainForcedToSlowDown(Vehicle train, bool forced) | |
| 09D0 | bool result = isVehicleOnAllWheels(Vehicle car) | |
| 09D1 | bool result = doesPickupExist(Pickup pickup) | |
| 09D2 | enableAmbientCrime(bool enable) | |
| 09D3 | [1:283] | |
| 09D4 | clearWantedLevelInGarage() | |
| 09D5 | int unk = setCharSayContextImportant(Ped ped, int soundslot, bool flags1, bool flags2, bool flags3) | |
| 09D6 | setCharSayScript(Ped ped, int sound, bool flags1, bool flags2, bool flags3) | |
| 09D7 | forceInteriorLightingForPlayer(Player player, bool force) | |
| 09D8 | [1:284] | |
| 09D9 | useDetonator() | |
| 09DA | bool result = isMoneyPickupAtCoords(float atX, float atY, float atZ) | |
| 09DB | setMenuColumnWidth(int panel, int column, int width) | |
| 09DC | [1:285] | |
| 09DD | makeRoomInPlayerGangForMissionPeds(int group) | |
| 09DE | bool result = isCharGettingInToACar(Ped ped) | |
| 09E0 | setUpSkipForSpecificVehicle(float posX, float posY, float posZ, float angle, Vehicle car) | |
| 09E1 | int price = getCarModelValue(Model modelId) | |
| 09E2 | int generator = createCarGeneratorWithPlate(float atX, float atY, float atZ, float angle, Model modelId, int color1, int color2, bool forceSpawn, int alarm, int doorLock, int minDelay, int maxDelay, string plate) | |
| 09E3 | bool result = findTrainDirection(Vehicle train) | |
| 09E4 | setAircraftCarrierSamSite(bool enable) | |
| 09E5 | drawLightWithRange(float atX, float atY, float atZ, int r, int g, int b, float radius) | |
| 09E6 | enableBurglaryHouses(bool enable) | |
| 09E7 | bool result = isPlayerControlOn(Player player) | |
| 09E8 | int interior = getCharActiveInterior(Ped ped) | |
| 09E9 | giveNonPlayerCarNitro(Vehicle car) | |
| 09EA | [1:286] | |
| 09EB | playerTakeOffGoggles(Player player, bool useAnim) | |
| 09EC | allowFixedCameraCollision(bool allow) | |
| 09ED | bool result = hasCharSpottedCharInFront(Ped ped, Ped ped2) | |
| 09EE | forceBigMessageAndCounter(bool stayOnScreen) | |
| 09EF | setVehicleCameraTweak(Model carModel, float distance, float altitudeMultiplier, float angleX) | |
| 09F0 | resetVehicleCameraTweak() | |
| 09F1 | reportMissionAudioEventAtChar(Ped ped, int event) | |
| 09F2 | bool result = doesDecisionMakerExist(int maker) | |
| 09F3 | [1:287] | |
| 09F4 | ignoreHeightDifferenceFollowingNodes(Ped ped, bool ignore) | |
| 09F5 | shutAllCharsUp(bool enable) | |
| 09F6 | setCharGetOutUpsideDownCar(Ped ped, bool canGetOut) | |
| 09F7 | reportMissionAudioEventAtCar(Vehicle car, int event) | |
| 09F8 | doWeaponStuffAtStartOf2pGame() | |
| 09F9 | [1:288] | |
| 09FA | bool result = hasGameJustReturnedFromFrontend() | |
| 09FB | int language = getCurrentLanguage() | |
| 09FC | bool result = isObjectIntersectingWorld(Object object) | |
| 09FD | int width = getStringWidth(GxtString gxtString) | |
| 09FE | resetVehicleHydraulics(Vehicle car) | |
| 09FF | setRespawnPointForDurationOfMission(float posX, float posY, float posZ) | |
| 0A00 | [1:289] | |
| 0A01 | bool result = isThisModelACar(Model modelId) | |
| 0A02 | switchOnGroundSearchlight(Searchlight searchlight, bool lightsThroughObstacles) | |
| 0A03 | bool result = isGangWarFightingGoingOn() | |
| 0A04 | [1:290] | |
| 0A05 | [1:291] | |
| 0A06 | bool result = isNextStationAllowed(Vehicle train) | |
| 0A07 | skipToNextAllowedStation(Vehicle train) | |
| 0A08 | int width = getStringWidthWithNumber(GxtString gxtString, int number) | |
| 0A09 | shutCharUpForScriptedSpeech(Ped ped, bool muted) | |
| 0A0A | enableDisabledAttractorsOnObject(Object object, bool enable) | |
| 0A0B | loadSceneInDirection(float coordX, float coordY, float coordZ, float angle) | |
| 0A0C | bool result = isPlayerUsingJetpack(Player player) | |
| 0A0D | [1:292] | |
| 0A0E | clearThisPrintBigNow(int style) | |
| 0A0F | bool result = hasLanguageChanged() | |
| 0A10 | incrementIntStatNoMessage(int stat, int value) | |
| 0A11 | setExtraCarColours(Vehicle car, int tertiaryColor, int quaternaryColor) | |
| 0A12 | int tertiaryColor, int quaternaryColor = getExtraCarColours(Vehicle car) | |
| 0A13 | manageAllPopulation() | |
| 0A14 | setNoResprays(bool enable) | |
| 0A15 | bool result = hasCarBeenResprayed(Vehicle car) | |
| 0A16 | attachMissionAudioToCar(int audioId, Vehicle car) | |
| 0A17 | setHasBeenOwnedForCarGenerator(int generator, bool owned) | |
| 0A18 | setUpConversationNodeWithScriptedSpeech(GxtString questionGXT, GxtString answerYesGXT, GxtString answerNoGXT, int questionWAV, int answerYesWAV, int answerNoWAV) | |
| 0A19 | setAreaName(GxtString gxtString) | |
| 0A1A | taskPlayAnimSecondary(Ped ped, string animation, string IFP, float framedelta, bool loopA, bool lockX, bool lockY, bool lockF, int time) | |
| 0A1B | bool result = isCharTouchingChar(Ped ped, Ped ped2) | |
| 0A1C | disableHeliAudio(Vehicle helicopter, bool disable) | |
| 0A1D | taskHandGesture(Ped ped, Ped ped2) | |
| 0A1E | takePhoto(bool unk) | |
| 0A1F | incrementFloatStatNoMessage(int stat, float value) | |
| 0A20 | setPlayerGroupToFollowAlways(Player player, bool followAlways) | |
| 0A21 | improveCarByCheating(Vehicle car, bool affectedByCheats) | |
| 0A22 | changeCarColourFromMenu(int panelID, Vehicle car, int colorslot, int activeRow) | |
| 0A23 | highlightMenuItem(int panel, int row, bool highlight) | |
| 0A24 | setDisableMilitaryZones(bool disable) | |
| 0A25 | setCameraPositionUnfixed(float xAngle, float zAngle) | |
| 0A26 | setRadioToPlayersFavouriteStation() | |
| 0A27 | setDeathWeaponsPersist(Ped ped, bool persist) | |
| 0A28 | setCharSwimSpeed(Ped ped, float speed) | |
| 0A29 | bool result = isPlayerClimbing(Player player) | |
| 0A2A | bool result = isThisHelpMessageBeingDisplayed(GxtString gxtString) | |
| 0A2B | bool result = isWidescreenOnInOptions() | |
| 0A2C | drawSubtitlesBeforeFade(bool flag) | |
| 0A2D | drawOddjobTitleBeforeFade(bool flag) | |
| 0A2E | taskFollowPathNodesToCoordWithRadius(Ped ped, float toX, float toY, float toZ, int mode, int time, float stopRadius) | |
| 0A2F | setPhotoCameraEffect(bool firstPersonView) | |
| 0A30 | fixCar(Vehicle car) | |
| 0A31 | setPlayerGroupToFollowNever(Player player, bool neverFollow) | |
| 0A32 | bool result = isCharAttachedToAnyCar(Ped ped) | |
| 0A33 | Ped ped = storeCarCharIsAttachedToNoSave(Vehicle car) | |
| 0A34 | [1:293] | |
| 0A35 | setUpSkipForVehicleFinishedByScript(float posX, float posY, float posZ, float angle, Vehicle car) | |
| 0A36 | bool result = isSkipWaitingForScriptToFadeIn() | |
| 0A37 | forceAllVehicleLightsOff(bool off) | |
| 0A38 | [1:294] | |
| 0A39 | int mode = getPlayerInCarCameraMode() | |
| 0A3A | bool result = isLastBuildingModelShotByPlayer(Player player, Model modelId) | |
| 0A3B | clearLastBuildingModelShotByPlayer(Player player) | |
| 0A3C | setUpConversationEndNodeWithScriptedSpeech(GxtString dialogueGxt, int wav) | |
| 0A3D | activatePimpCheat(bool enable) | |
| 0A3E | Ped ped = getRandomCharInAreaOffsetNoSave(float sphereX, float sphereY, float sphereZ, float radiusX, float radiusY, float radiusZ) | |
| 0A3F | setScriptCoopGame(bool enable) | |
| 0A40 | Marker marker = createUser3dMarker(float atX, float atY, float atZ, int color) | |
| 0A41 | removeUser3dMarker(Marker marker) | |
| 0A42 | [1:295] | |
| 0A43 | getRidOfPlayerProstitute() | |
| 0A44 | displayNonMinigameHelpMessages(bool display) | |
| 0A45 | setRailtrackResistanceMult(float tracksFriction) | |
| 0A46 | switchObjectBrains(int externalScript, bool canBeStreamedIn) | |
| 0A47 | finishSettingUpConversationNoSubtitles() | |
| 0A48 | allowPauseInWidescreen(bool enable) | |
| 0A49 | [1:296] | |
| 0A4A | float x, float y = getPcMouseMovement() | |
| 0A4B | bool result = isPcUsingJoypad() | |
| 0A4C | bool result = isMouseUsingVerticalInversion() | |
| 0A4D | [1:297] | |
| 0A4E | [1:298] | |
| 0A8C | writeMemory(uint address, uint size, int value, bool virtualProtect) | [4:5] |
| 0A8D | int value = readMemory(uint address, uint size, bool virtualProtect) | [4:6] |
| 0A8E | [3:58] | |
| 0A8F | [3:59] | |
| 0A90 | [3:60] | |
| 0A91 | [3:61] | |
| 0A92 | bool result = startNewCustomScript(zstring filepath, table args) | |
| 0A93 | [3:62] | |
| 0A94 | launchCustomMission(zstring filepath, table args) | |
| 0A95 | [3:63] | |
| 0A96 | uint ptr = getCharPointer(Ped ped) | [4:7] |
| 0A97 | uint ptr = getCarPointer(Vehicle car) | [4:8] |
| 0A98 | uint struct = getObjectPointer(Object object) | [4:9] |
| 0A9A | io.open |
[2:13] |
| 0A9B | io.close |
[2:14] |
| 0A9C | file:seek("end") |
[2:15] |
| 0A9D | file:read |
[2:16] |
| 0A9E | file:write |
[2:17] |
| 0A9F | [3:64] | |
| 0AA0 | [3:65] | |
| 0AA1 | [3:66] | |
| 0AA2 | bool result, uint handle = loadDynamicLibrary(string library) | [4:10] |
| 0AA3 | freeDynamicLibrary(uint handle) | [4:11] |
| 0AA4 | bool result, uint proc = getDynamicLibraryProcedure(string proc, uint handle) | [4:12] |
| 0AA7 | callFunction | [2:18] |
| 0AA7 | int returnValue = callFunction(uint address, int params, int pop, ...) | [4:13] |
| 0AA8 | callMethod | [2:19] |
| 0AA8 | int returnValue = callMethod(uint address, int struct, int params, int pop, ...) | [4:14] |
| 0AA9 | bool result = isGameVersionOriginal() | [4:15] |
| 0AAA | int handle = getScmThreadStructNamed(GxtString thread) | |
| 0AAB | bool result = doesFileExist(string file) | [4:16] |
| 0AAC | AudioStream handle = loadAudioStream(zstring audio) | [4:17] |
| 0AAD | setAudioStreamState(AudioStream handle, int state) | [4:18] |
| 0AAE | releaseAudioStream(AudioStream handle) | [4:19] |
| 0AAF | double length = getAudioStreamLength(AudioStream handle) | [4:20] |
| 0AB0 | isKeyDown | [2:20] |
| 0AB0 | bool state = isKeyDown(int keyId) | [4:21] |
| 0AB1 | [3:67] | |
| 0AB2 | [3:68] | |
| 0AB3 | setCleoSharedVar(int var, int value) | |
| 0AB4 | int value = getCleoSharedVar(int var) | |
| 0AB5 | Vehicle car, Ped ped = storeClosestEntities(Ped ped) | [4:22] |
| 0AB6 | bool result, float posX, float posY, float posZ = getTargetBlipCoordinates() | [4:23] |
| 0AB7 | int gears = getCarNumberOfGears(Vehicle car) | [4:24] |
| 0AB8 | int gear = getCarCurrentGear(Vehicle car) | [4:25] |
| 0AB9 | int state = getAudioStreamState(AudioStream handle) | [4:26] |
| 0ABA | [3:69] | |
| 0ABB | float volume = getAudioStreamVolume(AudioStream audio) | [4:27] |
| 0ABC | setAudioStreamVolume(AudioStream audio, float volume) | [4:28] |
| 0ABD | bool state = isCarSirenOn(Vehicle car) | [4:29] |
| 0ABE | bool state = isCarEngineOn(Vehicle car) | [4:30] |
| 0ABF | switchCarEngine(Vehicle car, bool state) | [4:31] |
| 0AC0 | setAudioStreamLooped(AudioStream audio, bool loop) | [4:32] |
| 0AC1 | AudioStream handle = load3dAudioStream(zstring audio) | [4:33] |
| 0AC2 | setPlay3dAudioStreamAtCoordinates(AudioStream handle, float posX, float posY, float posZ) | [4:34] |
| 0AC3 | setPlay3dAudioStreamAtObject(AudioStream audio, Object object) | [4:35] |
| 0AC4 | setPlay3dAudioStreamAtChar(AudioStream audio, Ped ped) | [4:36] |
| 0AC5 | setPlay3dAudioStreamAtCar(AudioStream audio, Vehicle car) | [4:37] |
| 0AC6 | [3:70] | |
| 0AC7 | [3:71] | |
| 0AC8 | uint memory = allocateMemory(uint size) | [4:38] |
| 0AC9 | freeMemory(uint memory) | [4:39] |
| 0ACA | printHelpString(string text) | [4:40] |
| 0ACB | printStyledString(string text, int time, int style) | [4:41] |
| 0ACC | printString(string text, int time) | [4:42] |
| 0ACD | printStringNow(string text, int time) | [4:43] |
| 0ACE | [5] | |
| 0ACF | [5:1] | |
| 0AD0 | [5:2] | |
| 0AD1 | [5:3] | |
| 0AD2 | bool result, Ped ped = getCharPlayerIsTargeting(Player player) | [4:44] |
| 0AD3 | string.format |
[2:21] |
| 0AD4 | string.match |
[2:22] |
| 0AD5 | file:seek |
[2:23] |
| 0AD6 | file:read(0) |
[2:24] |
| 0AD7 | file:read |
[2:25] |
| 0AD8 | file:write |
[2:26] |
| 0AD9 | [5:4] | |
| 0ADA | [6] | |
| 0ADB | GxtString name = getNameOfVehicleModel(Model modelId) | [4:45] |
| 0ADC | bool result = testCheat(string text) | [4:46] |
| 0ADD | bool result = spawnVehicleByCheating(Model modelId) | [4:47] |
| 0ADE | getGxtText | [2:27] |
| 0ADE | string text = getGxtText(string key) | [4:48] |
| 0ADF | setGxtEntry | [2:28] |
| 0ADF | setGxtEntry(string key, string text) | [4:49] |
| 0AE0 | clearGxtEntry | [2:29] |
| 0AE0 | clearGxtEntry(string key) | [4:50] |
| 0AE1 | bool result, Ped ped = findAllRandomCharsInSphere(float posX, float posY, float posZ, float radius, bool findNext, bool skipDead) | [4:51] |
| 0AE2 | bool result, Vehicle car = findAllRandomVehiclesInSphere(float posX, float posY, float posZ, float radius, bool findNext, bool skipWrecked) | [4:52] |
| 0AE3 | bool result, Object object = findAllRandomObjectsInSphere(float posX, float posY, float posZ, float radius, bool findNext) | [4:53] |
| 0AE4 | bool result = doesDirectoryExist(string directory) | [4:54] |
| 0AE5 | bool result = createDirectory(string directory) | [4:55] |
| 0AE6 | Filesearch handle, string name = findFirstFile(string mask) | [4:56] |
| 0AE7 | string file = findNextFile(Filesearch handle) | [4:57] |
| 0AE8 | findClose(Filesearch handle) | [4:58] |
| 0AE9 | float val = popFloat() | [4:59] |
| 0AEA | Ped handle = getCharPointerHandle(uint ptr) | [4:60] |
| 0AEB | Vehicle handle = getVehiclePointerHandle(uint ptr) | [4:61] |
| 0AEC | Object handle = getObjectPointerHandle(uint ptr) | [4:62] |
| 0AED | string.format |
[2:30] |
| 0AEE | math.exp |
[2:31] |
| 0AEF | math.log |
[2:32] |
| 0AF0 | [7] | |
| 0AF1 | [7:1] | |
| 0AF2 | [7:2] | |
| 0AF3 | [7:3] | |
| 0AF4 | [7:4] | |
| 0AF5 | [7:5] | |
| 0AF6 | sampSpawnPlayer() | |
| 0AF7 | uint handle = sampGetBase() | |
| 0AF8 | sampAddChatMessage(zstring text, uint color) | |
| 0AF9 | sampSendChat(zstring text) | |
| 0AFA | bool result = isSampAvailable() | |
| 0AFB | sampRequestClass(int class) | |
| 0AFC | sampSendScmEvent(int event, int id, int param1, int param2) | |
| 0AFD | sampSetSpecialAction(int action) | |
| 0AFE | sampSendDeathByPlayer(int playerId, int reason) | |
| 0AFF | bool result, Vehicle car = sampGetCarHandleBySampVehicleId(int id) | |
| 0B00 | os.remove |
[2:33] |
| 0B01 | os.remove |
[2:34] может удалять только пустые директории |
| 0B02 | [8] | |
| 0B03 | [8:1] | |
| 0B04 | [8:2] | |
| 0B05 | [8:3] | |
| 0B10 | bit.band |
[2:35] |
| 0B11 | bit.bor |
[2:36] |
| 0B12 | bit.bxor |
[2:37] |
| 0B13 | bit.bnot |
[2:38] |
| 0B14 | math.fmod |
[2:39] |
| 0B15 | bit.rshift |
[2:40] |
| 0B16 | bit.lshift |
[2:41] |
| 0B20 | bool result, Ped ped = sampGetCharHandleBySampPlayerId(int id) | |
| 0B21 | bool result = sampIsChatInputActive() | |
| 0B22 | sampSetSendrate(int type, int rate) | |
| 0B23 | bool result = sampIsPlayerConnected(int id) | |
| 0B24 | uint structPtr = sampGetPlayerStructPtr(int id) | |
| 0B25 | int health = sampGetPlayerHealth(int id) | |
| 0B26 | int armor = sampGetPlayerArmor(int id) | |
| 0B27 | sampSetGamestate(int gamestate) | |
| 0B28 | sampDisconnectWithReason(bool timeout) | |
| 0B29 | sampSetLocalPlayerName(zstring name) | |
| 0B2A | int ping = sampGetPlayerPing(int id) | |
| 0B2B | bool result, int id = sampGetPlayerIdByCharHandle(Ped ped) | |
| 0B2C | bool result, int id = sampGetVehicleIdByCarHandle(Vehicle car) | |
| 0B2D | [9] | |
| 0B2E | [9:1] | |
| 0B2F | bool result, float posX, float posY, float posZ = sampGetStreamedOutPlayerPos(int id) | |
| 0B30 | sampSendEnterVehicle(int id, bool passenger) | |
| 0B31 | sampSendExitVehicle(int id) | |
| 0B32 | sampSendSpawn() | |
| 0B33 | sampSendDamageVehicle(Vehicle car, int panel, int doors, int lights, int tires) | |
| 0B34 | bool result = sampRegisterChatCommand(zstring cmd, function func) | |
| 0B35 | [10] | |
| 0B36 | zstring name = sampGetPlayerNickname(int id) | |
| 0B37 | uint color = sampGetPlayerColor(int id) | |
| 0B38 | sampConnectToServer(zstring ip, uint port) | |
| 0B39 | zstring ip, uint port = sampGetCurrentServerAddress() | |
| 0B3A | zstring name = sampGetCurrentServerName() | |
| 0B3B | sampShowDialog(int id, zstring caption, zstring text, zstring button1, zstring button2, int style) | |
| 0B3C | bool result, int button, int list, zstring input = sampHasDialogRespond(int id) | |
| 0B3D | Bitstream bs = raknetNewBitStream() | |
| 0B3E | raknetDeleteBitStream(Bitstream bs) | |
| 0B3F | raknetResetBitStream(Bitstream bs) | |
| 0B40 | raknetBitStreamWriteBitStream(Bitstream bs, Bitstream bitStream) | |
| 0B40 | raknetBitStreamWriteBool(Bitstream bs, bool value) | |
| 0B40 | raknetBitStreamWriteBuffer(Bitstream bs, uint dest, uint size) | |
| 0B40 | raknetBitStreamWriteFloat(Bitstream bs, float value) | |
| 0B40 | raknetBitStreamWriteInt16(Bitstream bs, int value) | |
| 0B40 | raknetBitStreamWriteInt32(Bitstream bs, int value) | |
| 0B40 | raknetBitStreamWriteInt8(Bitstream bs, int value) | |
| 0B40 | raknetBitStreamWriteString(Bitstream bs, string str) | |
| 0B41 | raknetSendRpcEx(int rpc, Bitstream bs, int priority, int reliability, int channel, bool timestamp) | |
| 0B42 | raknetSendBitStreamEx(Bitstream bs, int priority, int reliability, int channel) | |
| 0B43 | [3:72] | |
| 0B44 | int textlabel = sampCreate3dText(zstring text, uint color, float posX, float posY, float posZ, float distance, bool ignoreWalls, int playerId, int vehicleId) | |
| 0B45 | sampDestroy3dText(int textlabel) | |
| 0B46 | bool result = sampIs3dTextDefined(int 3dText) | |
| 0B47 | sampCloseCurrentDialogWithButton(int button) | |
| 0B48 | int list = sampGetCurrentDialogListItem() | |
| 0B49 | sampSetCurrentDialogListItem(int list) | |
| 0B4A | zstring text = sampGetCurrentDialogEditboxText() | |
| 0B4B | sampSetCurrentDialogEditboxText(zstring text) | |
| 0B4C | bool result = sampIsDialogActive() | |
| 0B4D | int type = sampGetCurrentDialogType() | |
| 0B4E | int id = sampGetCurrentDialogId() | |
| 0B4F | int gamestate = sampGetGamestate() | |
| 0B50 | Object object = sampGetObjectHandleBySampId(int id) | |
| 0B51 | Pickup pickup = sampGetPickupHandleBySampId(int id) | |
| 0B52 | int objectId = sampGetObjectSampIdByHandle(Object object) | |
| 0B53 | int pickupId = sampGetPickupSampIdByHandle(Pickup pickup) | |
| 0B54 | int count = sampGetListboxItemsCount() | |
| 0B55 | float wposX, float wposY = convert3DCoordsToScreen(float posX, float posY, float posZ) | [4:63] |
| 0B56 | setGameKeyState(int key, int state) | [4:64] |
| 0B57 | int animid = sampGetPlayerAnimationId(int playerId) | |
| 0B58 | zstring file, zstring name = sampGetAnimationNameAndFile(int animid) | |
| 0B59 | int id = sampFindAnimationIdByNameAndFile(zstring name, zstring file) | |
| 0B5A | int resX, int resY = getScreenResolution() | |
| 0B5B | zstring text = sampGetListboxItemText(int item) | |
| 0B5C | bool result = sampIsPlayerPaused(int id) | |
| 0B5D | sampToggleCursor(bool show) | |
| 0B5E | int posX, int posY = getCursorPos() | [4:65] |
| 0B5F | float gposX, float gposY = convertWindowScreenCoordsToGameScreenCoords(float wposX, float wposY) | [4:66] |
| 0B60 | float wposX, float wposY = convertGameScreenCoordsToWindowScreenCoords(float gposX, float gposY) | [4:67] |
| 0B61 | bool result = sampIsLocalPlayerSpawned() | |
| 0B62 | int action = sampGetPlayerSpecialAction(int id) | |
| 0B63 | bool result = sampUnregisterChatCommand(zstring cmd) | |
| 0B64 | bool result = sampIsPlayerNpc(int id) | |
| 0B65 | int score = sampGetPlayerScore(int id) | |
| 0B66 | [11] | |
| 0B67 | [11:1] | |
| 0B68 | renderDrawLine(float pos1X, float pos1Y, float pos2X, float pos2Y, float width, uint color) | [4:68] |
| 0B69 | renderDrawBox(float posX, float posY, float sizeX, float sizeY, uint color) | [4:69] |
| 0B6A | renderDrawBoxWithBorder(float posX, float posY, float sizeX, float sizeY, uint color, float bsize, uint bcolor) | [4:70] |
| 0B6B | float length = renderGetFontDrawTextLength(DxFont font, zstring text, [bool ignoreColorTags=false]) | [4:71] |
| 0B6C | float height = renderGetFontDrawHeight(DxFont font) | [4:72] |
| 0B6D | DxFont font = renderCreateFont(zstring font, int height, uint flags, [uint charset]) | [4:73] |
| 0B6E | renderReleaseFont(DxFont font) | [4:74] |
| 0B6F | renderFontDrawText(DxFont font, zstring text, float posX, float posY, uint color, [bool ignoreColorTags=false]) | [4:75] |
| 0B70 | renderDrawPolygon(float posX, float posY, float sizeX, float sizeY, int corners, float rotation, uint color) | [4:76] |
| 0B71 | DxTexture texture = renderLoadTextureFromFile(zstring file) | [4:77] |
| 0B72 | renderReleaseTexture(DxTexture texture) | [4:78] |
| 0B73 | renderDrawTexture(DxTexture texture, float posX, float posY, float sizeX, float sizeY, float rotation, uint color) | [4:79] |
| 0B74 | sampSetChatString(int id, zstring text, zstring prefix, uint color, uint pcolor) | |
| 0B75 | zstring text, zstring prefix, uint color, uint pcolor = sampGetChatString(int id) | |
| 0B76 | sampSetChatInputText(zstring text) | |
| 0B77 | zstring text = sampGetChatInputText() | |
| 0B78 | sampfuncsLog(zstring msg) | |
| 0B79 | sampSetChatInputEnabled(bool enabled) | |
| 0B7A | uint rakclientPtr = sampGetRakclientInterface() | |
| 0B7B | uint rakpeer = sampGetRakpeer() | |
| 0B7C | uint address = sampGetRakclientFuncAddressByIndex(int index) | |
| 0B7D | uint callbackAddress = sampGetRpcCallbackByRpcId(int index) | |
| 0B7E | uint node = sampGetRpcNodeByRpcId(int index) | |
| 0B7F | uint sampPtr = sampGetSampInfoPtr() | |
| 0B80 | DxutDialog dialog = dxutCreateDialog(zstring name) | |
| 0B81 | bool result, int event, int id = dxutPopEvent(DxutDialog dialog) | |
| 0B82 | dxutAddButton(DxutDialog dialog, int id, zstring text, int posX, int posY, int sizeX, int sizeY) | |
| 0B83 | dxutAddCheckbox(DxutDialog dialog, int id, zstring text, int posX, int posY, int sizeX, int sizeY) | |
| 0B84 | dxutSetDialogPos(DxutDialog dialog, int posX, int posY, int sizeX, int sizeY) | |
| 0B85 | int posX, int posY, int sizeX, int sizeY = dxutGetDialogPosAndSize(DxutDialog dialog) | |
| 0B86 | dxutSetDialogVisible(DxutDialog dialog, bool visible) | |
| 0B87 | bool result = dxutIsDialogVisible(DxutDialog dialog) | |
| 0B88 | dxutAddEditbox(DxutDialog dialog, int id, zstring text, int posX, int posY, int sizeX, int sizeY) | |
| 0B89 | zstring text = dxutGetControlText(DxutDialog dialog, int id) | |
| 0B8A | raknetSendRpc(int rpc, Bitstream bs) | |
| 0B8B | raknetSendBitStream(Bitstream bs) | |
| 0B8C | bool result = sampIsCursorActive() | |
| 0B8D | sampSetCursorMode(int mode) | |
| 0B8E | int mode = sampGetCursorMode() | |
| 0B8F | float posX, float posY, float posZ = convertScreenCoordsToWorld3D(float posX, float posY, float depth) | [4:80] |
| 0B90 | dxutSetControlVisible(DxutDialog dialog, int id, bool visible) | |
| 0B91 | dxutAddStatic(DxutDialog dialog, int id, zstring text, int posX, int posY, int sizeX, int sizeY) | |
| 0B92 | bool result = dxutIsCheckboxChecked(DxutDialog dialog, int id) | |
| 0B93 | dxutSetDialogBackgroundColor(DxutDialog dialog, uint color) | |
| 0B94 | dxutSetControlText(DxutDialog dialog, int id, zstring text) | |
| 0B95 | bool result = dxutControlIsVisible(DxutDialog dialog, int id) | |
| 0B96 | dxutAddSlider(DxutDialog dialog, int id, int posX, int posY, int sizeX, int sizeY, int max) | |
| 0B97 | int value = dxutGetSliderValue(DxutDialog dialog, int id) | |
| 0B98 | dxutSetSliderValue(DxutDialog dialog, int id, int value) | |
| 0B99 | dxutAddListbox(DxutDialog dialog, int id, int posX, int posY, int sizeX, int sizeY) | |
| 0B9A | dxutListboxInsertItem(DxutDialog dialog, int id, zstring element, uint data, int after) | |
| 0B9B | int element, int count = dxutGetListboxSelectedItemAndCount(DxutDialog dialog, int id) | |
| 0B9C | dxutListboxDeleteItem(DxutDialog dialog, int id, int element) | |
| 0B9D | zstring text, uint data = dxutGetListboxItemTextAndData(DxutDialog dialog, int id, int element) | |
| 0B9E | dxutCheckboxSetChecked(DxutDialog dialog, int id, bool checked) | |
| 0B9F | dxutEnableDialogCaption(DxutDialog dialog, bool enable) | |
| 0BA0 | bool result = dxutIsDialogCaptionEnabled(DxutDialog dialog) | |
| 0BA1 | dxutSetDialogMinimized(DxutDialog dialog, bool minimized) | |
| 0BA2 | bool result = dxutIsDialogMinimized(DxutDialog dialog) | |
| 0BA3 | dxutDeleteControl(DxutDialog dialog, int id) | |
| 0BA4 | dxutDeleteDialog(DxutDialog dialog) | |
| 0BA5 | dxutSetFocusOnControl(DxutDialog dialog, int id) | |
| 0BA6 | dxutSetControlSize(DxutDialog dialog, int id, int sizeX, int sizeY) | |
| 0BA7 | int sizeX, int sizeY = dxutGetControlSize(DxutDialog dialog, int id) | |
| 0BA8 | dxutSetControlPos(DxutDialog dialog, int id, int posX, int posY) | |
| 0BA9 | int posX, int posY = dxutGetControlPos(DxutDialog dialog, int id) | |
| 0BAA | dxutSetCheckboxColor(DxutDialog dialog, int id, uint color) | |
| 0BAB | bool result = dxutIsDialogExists(DxutDialog dialog) | |
| 0BAC | uint settingsPtr = sampGetServerSettingsPtr() | |
| 0BAD | uint poolsPtr = sampGetSampPoolsPtr() | |
| 0BAE | uint chatPtr = sampGetChatInfoPtr() | |
| 0BAF | uint inputPtr = sampGetInputInfoPtr() | |
| 0BB0 | uint dialogPtr = sampGetDialogInfoPtr() | |
| 0BB1 | uint kill = sampGetKillInfoPtr() | |
| 0BB2 | uint miscPtr = sampGetMiscInfoPtr() | |
| 0BB3 | uint tdpoolPtr = sampGetTextdrawPoolPtr() | |
| 0BB4 | int objpoolPtr = sampGetObjectPoolPtr() | |
| 0BB5 | uint gzpoolPtr = sampGetGangzonePoolPtr() | |
| 0BB6 | uint tlabelpoolPtr = sampGetTextlabelPoolPtr() | |
| 0BB7 | uint playerpoolPtr = sampGetPlayerPoolPtr() | |
| 0BB8 | uint vehpoolPtr = sampGetVehiclePoolPtr() | |
| 0BB9 | uint pickuppoolPtr = sampGetPickupPoolPtr() | |
| 0BBA | sampStorePlayerOnfootData(int id, uint dstBuffer) | |
| 0BBB | sampStorePlayerIncarData(int id, uint dstBuffer) | |
| 0BBC | sampStorePlayerPassengerData(int id, uint dstBuffer) | |
| 0BBD | sampStorePlayerTrailerData(int id, uint dstBuffer) | |
| 0BBE | sampStorePlayerAimData(int id, uint dstBuffer) | |
| 0BBF | sampSendRconCommand(zstring cmd) | |
| 0BC0 | sampSendOnfootData(uint dataPtr) | |
| 0BC1 | sampSendIncarData(uint dataPtr) | |
| 0BC2 | sampSendPassengerData(uint dataPtr) | |
| 0BC3 | sampSendAimData(uint dataPtr) | |
| 0BC4 | sampSendBulletData(uint dataPtr) | |
| 0BC5 | sampSendTrailerData(uint dataPtr) | |
| 0BC6 | sampSendUnoccupiedData(uint dataPtr) | |
| 0BC7 | sampSendSpectatorData(uint dataPtr) | |
| 0BC8 | sampSendClickPlayer(int id, int source) | |
| 0BC9 | sampSendDialogResponse(int id, int button, int listitem, zstring input) | |
| 0BCA | sampSendClickTextdraw(int id) | |
| 0BCB | sampSendGiveDamage(int id, float damage, int weapon, int bodypart) | |
| 0BCC | sampSendTakeDamage(int id, float damage, int weapon, int bodypart) | |
| 0BCD | sampSendEditObject(bool playerObject, int objectId, int response, float posX, float posY, float posZ, float rotX, float rotY, float rotZ) | |
| 0BCE | sampSendEditAttachedObject(int response, int index, int model, int bone, float offsetX, float offsetY, float offsetZ, float rotX, float rotY, float rotZ, float scaleX, float scaleY, float scaleZ) | |
| 0BCF | sampSendInteriorChange(int id) | |
| 0BD0 | sampSendRequestSpawn() | |
| 0BD1 | sampSendPickedUpPickup(int id) | |
| 0BD2 | sampSendMenuSelectRow(int id) | |
| 0BD3 | sampSendMenuQuit() | |
| 0BD4 | sampSendVehicleDestroyed(int id) | |
| 0BD5 | bool result = sampIsScoreboardOpen() | |
| 0BD6 | sampToggleScoreboard(bool show) | |
| 0BD7 | zstring text = sampGetDialogText() | |
| 0BD8 | zstring caption = sampGetDialogCaption() | |
| 0BD9 | sampSetDialogClientside(bool clientside) | |
| 0BDA | bool result = sampIsDialogClientside() | |
| 0BDB | bool result = sampIsChatVisible() | |
| 0BDC | int mode = sampGetChatDisplayMode() | |
| 0BDD | sampSetChatDisplayMode(int mode) | |
| 0BDE | pauseScmThread(uint thread) | |
| 0BDF | resumeScmThread(uint thread) | |
| 0BE0 | [12] | |
| 0BE1 | [12:1] | |
| 0BE2 | [12:2] | |
| 0BE3 | [12:3] | |
| 0BE4 | [12:4] | |
| 0BE5 | [10:1] | |
| 0BE6 | [12:5] | |
| 0BE7 | bool value = raknetBitStreamReadBool(Bitstream bs) | |
| 0BE7 | float value = raknetBitStreamReadFloat(Bitstream bs) | |
| 0BE7 | int value = raknetBitStreamReadInt16(Bitstream bs) | |
| 0BE7 | int value = raknetBitStreamReadInt32(Bitstream bs) | |
| 0BE7 | int value = raknetBitStreamReadInt8(Bitstream bs) | |
| 0BE8 | raknetBitStreamReadBuffer(Bitstream bs, uint dest, uint size) | |
| 0BE8 | string value = raknetBitStreamReadString(Bitstream bs, uint size) | |
| 0BE9 | raknetBitStreamResetReadPointer(Bitstream bs) | |
| 0BEA | raknetBitStreamResetWritePointer(Bitstream bs) | |
| 0BEB | raknetBitStreamIgnoreBits(Bitstream bs, int amount) | |
| 0BEC | raknetBitStreamSetWriteOffset(Bitstream bs, int offset) | |
| 0BED | raknetBitStreamSetReadOffset(Bitstream bs, int offset) | |
| 0BEE | uint value = raknetBitStreamGetNumberOfBitsUsed(Bitstream bs) | |
| 0BEF | uint value = raknetBitStreamGetNumberOfBytesUsed(Bitstream bs) | |
| 0BF0 | uint value = raknetBitStreamGetNumberOfUnreadBits(Bitstream bs) | |
| 0BF1 | int value = raknetBitStreamGetWriteOffset(Bitstream bs) | |
| 0BF2 | int value = raknetBitStreamGetReadOffset(Bitstream bs) | |
| 0BF3 | uint value = raknetBitStreamGetDataPtr(Bitstream bs) | |
| 0BF4 | zstring string = raknetBitStreamDecodeString(Bitstream bs, int size) | |
| 0BF5 | raknetBitStreamEncodeString(Bitstream bs, zstring string) | |
| 0BF6 | raknetEmulRpcReceiveBitStream(int rpc, Bitstream bs) | |
| 0BF7 | raknetEmulPacketReceiveBitStream(int packet, Bitstream bs) | |
| 0BF8 | zstring name = raknetGetRpcName(int rpc) | |
| 0BF9 | zstring name = raknetGetPacketName(int packet) | |
| 0BFA | [3:73] | |
| 0BFB | [3:74] | |
| 0BFC | bool result = setSampfuncsGlobalVar(zstring var, int value) | |
| 0BFD | bool result, int value = getSampfuncsGlobalVar(zstring var) | |
| 0BFE | os.clock/localClock |
[2:42] |
| 0BFF | bool result, table colPoint = processLineOfSight(float originX, float originY, float originZ, float targetX, float targetY, float targetZ, [bool checkSolid=true], [bool car=false], [bool ped=false], [bool object=false], [bool particle=false], [bool seeThrough=false], [bool ignoreSomeObjects=false], [bool shootThrough=false]) | [4:81] |
| 0C00 | math.abs |
[2:43] |
| 0C01 | math.deg |
[2:44] |
| 0C02 | math.rad |
[2:45] |
| 0C03 | math.sin |
[2:46] |
| 0C04 | math.asin |
[2:47] |
| 0C05 | math.cos |
[2:48] |
| 0C06 | math.acos |
[2:49] |
| 0C07 | math.tan |
[2:50] |
| 0C08 | math.atan |
[2:51] |
| 0C09 | math.pow |
[2:52] |
| 0C0A | math.ceil |
[2:53] |
| 0C0B | math.floor |
[2:54] |
| 0C0C | int value = getStructElement(uint struct, int offset, uint size, [bool unprotect=false]) | [4:82] |
| 0C0D | setStructElement(uint struct, int offset, uint size, int value, [bool unprotect=false]) | [4:83] |
| 0C0E | [13] | |
| 0C0F | [13:1] | |
| 0C10 | [14] | |
| 0C10 | memory.copy(uint destAddress, uint srcAddress, uint size, [bool unprotect=false]) | [4:84] |
| 0C11 | [14:1] | |
| 0C11 | memory.fill(uint address, int value, uint size, [bool unprotect=false]) | [4:85] |
| 0C12 | [14:2] | |
| 0C12 | bool result = memory.compare(uint address1, uint address2, uint size, [bool unprotect=false]) | [4:86] |
| 0C13 | [15] | |
| 0C14 | [15:1] | |
| 0C15 | [15:2] | |
| 0C16 | string.gmatch |
[2:55] |
| 0C17 | [15:3] | |
| 0C18 | string.find |
[2:56] |
| 0C19 | string.find |
[2:57] |
| 0C1A | tonumber |
[2:58] |
| 0C1B | tonumber |
[2:59] |
| 0C1C | tostring/string.format |
[2:60] |
| 0C1D | [13:2] | |
| 0C1E | [13:3] | |
| 0C1F | [13:4] | |
| 0C20 | [13:5] | |
| 0C21 | [6:1] | |
| 0C22 | [14:3] | |
| 0C22 | string hexstr = memory.tohex(uint address, uint size, [bool unprotect=false]) | [4:87] |
| 0C23 | [14:4] | |
| 0C23 | bool result = memory.hex2bin(string hex, uint dstAddress, uint size) | [4:88] |
| 0C24 | [6:2] | |
| 0C25 | [6:3] | |
| 0C26 | string.upper |
[2:61] |
| 0C27 | [6:4] | |
| 0C28 | string.lower |
[2:62] |
| 0C29 | [6:5] | |
| 0C2A | string.find |
[2:63] |
| 0C2B | [6:6] | |
| 0C2C | [6:7] | |
| 0C2D | string.reverse |
[2:64] |
| 0C2E | [6:8] | |
| 0C2F | tonumber |
[2:65] |
| 0C30 | [16] | |
| 0C31 | [16:1] | |
| 0C32 | float w, float x, float y, float z = convertMatrixToQuaternion(float rightX, float rightY, float rightZ, float frontX, float frontY, float frontZ, float upX, float upY, float upZ) | [4:89] |
| 0C33 | float rightX, float rightY, float rightZ, float frontX, float frontY, float frontZ, float upX, float upY, float upZ = convertQuaternionToMatrix(float w, float x, float y, float z) | [4:90] |
| 0C34 | [17] | |
| 0C35 | [17:1] | |
| 0C36 | [17:2] | |
| 0C37 | [17:3] | |
| 0C38 | [17:4] | |
| 0C39 | [17:5] | |
| 0C3A | [3:75] | |
| 0C3B | renderBegin(int type) | [4:91] |
| 0C3C | renderEnd() | [4:92] |
| 0C3D | renderColor(uint color) | [4:93] |
| 0C3E | renderVertex(float vX, float vY) | [4:94] |
| 0C3F | renderSetTexCoord(float posX, float posY) | [4:95] |
| 0C40 | renderBindTexture(DxTexture texture) | [4:96] |
| 0C41 | uint struct = renderGetTextureStruct(DxTexture texture) | [4:97] |
| 0C42 | uint sprite = renderGetTextureSprite(DxTexture texture) | [4:98] |
| 0C43 | uint sizeX, uint sizeY = renderGetTextureSize(DxTexture texture) | [4:99] |
| 0C44 | renderSetRenderState(int state, uint value) | [4:100] |
| 0C45 | sampCreate3dTextEx(int id, zstring text, uint color, float posX, float posY, float posZ, float distance, bool ignoreWalls, int playerId, int vehicleId) | |
| 0C46 | zstring string, uint color, float posX, float posY, float posZ, float distance, bool ignoreWalls, int playerId, int vehicleId = sampGet3dTextInfoById(int id) | |
| 0C47 | sampSet3dTextString(int id, zstring text) | |
| 0C48 | sampTextdrawCreate(int id, zstring text, float posX, float posY) | |
| 0C49 | sampTextdrawSetBoxColorAndSize(int id, int box, uint color, float sizeX, float sizeY) | |
| 0C4A | sampTextdrawSetAlign(int id, int align) | |
| 0C4B | sampTextdrawSetProportional(int id, int proportional) | |
| 0C4C | sampTextdrawSetStyle(int id, int style) | |
| 0C4D | sampTextdrawSetShadow(int id, int shadow, uint color) | |
| 0C4E | sampTextdrawSetOutlineColor(int id, int outline, uint color) | |
| 0C4F | sampTextdrawSetModelRotationZoomVehColor(int id, int model, float rotX, float rotY, float rotZ, float zoom, int clr1, int clr2) | |
| 0C50 | sampTextdrawSetString(int id, zstring text) | |
| 0C51 | sampTextdrawSetPos(int id, float posX, float posY) | |
| 0C52 | sampTextdrawSetLetterSizeAndColor(int id, float letSizeX, float letSizeY, uint color) | |
| 0C53 | int box, uint color, float sizeX, float sizeY = sampTextdrawGetBoxEnabledColorAndSize(int id) | |
| 0C54 | int align = sampTextdrawGetAlign(int id) | |
| 0C55 | int prop = sampTextdrawGetProportional(int id) | |
| 0C56 | int style = sampTextdrawGetStyle(int id) | |
| 0C57 | int shadow, uint color = sampTextdrawGetShadowColor(int id) | |
| 0C58 | int outline, uint color = sampTextdrawGetOutlineColor(int id) | |
| 0C59 | int model, float rotX, float rotY, float rotZ, float zoom, int clr1, int clr2 = sampTextdrawGetModelRotationZoomVehColor(int id) | |
| 0C5A | zstring text = sampTextdrawGetString(int id) | |
| 0C5B | float posX, float posY = sampTextdrawGetPos(int id) | |
| 0C5C | float letSizeX, float letSizeY, uint color = sampTextdrawGetLetterSizeAndColor(int id) | |
| 0C5D | bool result = sampTextdrawIsExists(int id) | |
| 0C5E | sampTextdrawDelete(int id) | |
| 0C5F | bool result = isSampfuncsGlobalVarDefined(zstring var) | |
| 0C60 | [3:76] | |
| 0C61 | bool read, bool write = getSampfuncsGlobalVarAccessForThread(zstring var, uint thread) | |
| 0C62 | runSampfuncsConsoleCommand(zstring cmd) | |
| 0C63 | bool result = sampfuncsRegisterConsoleCommand(zstring cmd, function func) | |
| 0C64 | bool result = sampfuncsUnregisterConsoleCommand(zstring cmd) | |
| 0C65 | int index = downloadUrlToFile(string url, string file, function statusCallback) | [4:101] |
| 0C66 | [18] | |
| 0C67 | os.getenv |
[2:66] |
| 0C68 | [19] | |
| 0C69 | [19:1] | |
| 0C6A | [3:77] | |
| 0C6B | uint thread = createScmThreadAtPointer(uint pointer, table args) | |
| 0C6C | setScmThreadLocalVar(uint thread, int var, any value) | |
| 0C6D | int value = getScmThreadLocalVar(uint thread, int var) | |
| 0C6E | destroyScmThread(uint thread) | |
| 0C6F | restartScmThread(uint thread, table args) | |
| 0C70 | uint handle = getModuleHandle(string module) | [4:102] |
| 0C71 | uint address = getModuleProcAddress(string module, string proc) | [4:103] |
| 0C72 | setVirtualKeyDown(int vkey, bool down) | [4:104] |
| 0C73 | setCharKeyDown(int ckey, bool down) | [4:105] |
| 0C74 | [20] | |
| 0C75 | [20:1] | |
| 0C76 | [20:2] | |
| 0C77 | [20:3] | |
| 0C78 | [20:4] | |
| 0C79 | [20:5] | |
| 0C7A | [20:6] | |
| 0C7B | [20:7] | |
| 0C7C | [20:8] | |
| 0C7D | [18:1] | |
| 0C7E | bool result = isSampfuncsConsoleActive() | |
| 0C7F | sampSetClientCommandDescription(zstring cmd, zstring text) | |
| 0C80 | setSampfuncsConsoleCommandDescription(zstring cmd, zstring text) | |
| 0C81 | sampForceVehicleSync(int id) | |
| 0C82 | sampForceUnoccupiedSyncSeatId(int id, int seatId) | |
| 0C83 | sampForceOnfootSync() | |
| 0C84 | sampForceAimSync() | |
| 0C85 | sampForceTrailerSync(int id) | |
| 0C86 | sampForcePassengerSyncSeatId(int id, int seatId) | |
| 0C87 | sampForceStatsSync() | |
| 0C88 | sampForceWeaponsSync() | |
| 0C89 | bool state = isKeyJustPressed(int key) | [4:106] |
| 0C8A | int id = sampGetMaxPlayerId(bool streamed) | |
| 0C8B | int count = sampGetPlayerCount(bool streamed) | |
| 0C8C | DxTexture texture = renderLoadTextureFromFileInMemory(uint pointer, uint size) | [4:107] |
| 0C8D | bool result = setClipboardText(string text) | [4:108] |
| 0C8E | string text = getClipboardText() | [4:109] |
| 0C8F | sampProcessChatInput(zstring text) | |
| 0C90 | bool result = sampIsChatCommandDefined(zstring cmd) | |
| 0C91 | bool result = isSampfuncsConsoleCommandDefined(zstring cmd) | |
| 0C92 | int version = getCleoLibraryVersion() |
Не имеют назначения ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
Не вошло в релиз, поскольку в Lua/MoonLoader есть функции, позволяющие сделать то же, что и опкод ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
Не нужны в Lua. Арифметические операции, функции управления SCM-переменными, параметрами потока и т.п. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
Были заменены встроенными функциями в обновлениях ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
Для форматирования текста используется функция string.format ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
Запланированы в будущих обновлениях (есть существующая реализация в виде модуля lfs) ↩︎ ↩︎ ↩︎ ↩︎
Реализовано путём автоматического вызова и передачи в качестве аргумента(ов) в обработчик ↩︎ ↩︎
Легко реализуется встроенными средствами Lua, возможно будет добавлено в обновлениях ↩︎ ↩︎
Запланированы в ближайших обновлениях (реализуются средствами FFI) ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
Внешние функции реализуются посредством модулей, а общие функции можно реализовать с помощью системы экспорта ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
Контроль над статусом загрузки осуществляется через downloadUrlToFile ↩︎ ↩︎
Были заменены скриптовыми потоками ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎