[Include] 3DTryg Functions
#1

Include contain professional functions for manipulating (coordinates / rotations / vectors / arc / areas / offset) supported (2D / 3D)

Videos:

1. Knife Shoot Thread

2. EngineV6 Thread

3. EngineX Thread

4. Missile Launch Thread

5. Vehicle Missile Launch (MapAndreas Version) Thread

6. Vehicle Missile Launch (ColAndreas Version) Thread

7. GetGroundRotation

8. GetPlayerCollisionFlags (ColAndreas)

9. Marica Mortar V1 Thread

10. Heavy Marica Mortar Thread

11. Acid Renia (FCNPC)

12. Beta Interceptor (FCNPC)

13. GoToPlayerOnGroundCol (FCNPC)

14. IsElementOnPlayerScreen (ColAndreas)

15. Arc Points

16. Missile Launcher Aim Player

17. GetRandomPointOnSphericalSector

18. Vehicle Missile Congreve Rocket Thread

19. Magic Wand Thread

20. Vehicle Parachute Thread

21. Portal Gun #1 Thread

22. Portal Gun #2 Thread

23. Random NPC Moving In Area

24. Marica Mortar V2 Thread

25. Stingers (Cops and Robbers) Thread

26. NPC Driver Eye

27. PET SAR v1.0

28. Vehicle Speed Control

29. Prototype Grenade Detection

PHP Code:
/*************************************************************************************************************************************
 *                                                                                                                                   *
 *                                                    )(   3DTryg Functions   )(                                                     *
 *                                                                                                                                   *
 *                                                  !!! THIS FILE IS READ ONLY !!!                                                   *
 *                                                                                                                                   *
 * Copyright © 2019 Abyss Morgan. All rights reserved.                                                                               *
 * Contributors: Crayder, IllidanS4, Nero_3D, RyDeR, Zoutdaxv, hesambia, Neil Lamoureux, Ivan_Ino, Ralfie, Unrea1, Katarina Calzaghe *
 * Mr.Reus                                                                                                                           *
 *                                                                                                                                   *
 * Website:  adm.ct8.pl                                                                                                              *
 * Download: adm.ct8.pl/r/download                                                                                                   *
 *                                                                                                                                   *
 * Plugins: MapAndreas, ColAndreas, YSF, Streamer, FCNPC, VehicleStreamer                                                            *
 * Modules: FoxForeach, Foreach                                                                                                      *
 * Internal Modules: Stream3D, Actor, ATM, Anims, VehicleCollision                                                                   *
 *                                                                                                                                   *
 * File Version: 4.8.3X                                                                                                              *
 * MapAndreas Version: 1.2.1                                                                                                         *
 * ColAndreas Version: 1.4.0                                                                                                         *
 * YSF Version: R19 (kurta999)                                                                                                       *
 * Streamer Version: 2.9.4                                                                                                           *
 * VehicleStreamer Version: 2.9.4                                                                                                    *
 * FCNPC Version: 2.0.0                                                                                                              *
 *                                                                                                                                   *
 * //3DTryg Collision Precision:                                                                                                     *
 * 1. ColAndreas   - The most accurate precision with ColAndreas plugin.                                                             *
 * 2. MapAndreas   - Average precision with MapAndreas plugin.                                                                       *
 *                                                                                                                                   *
 * //Foreach Types:                                                                                                                  *
 * 1. FoxForeach                                                                                                                     *
 * 2. YSIForeach                                                                                                                     *
 * 3. GetPlayerPoolSize                                                                                                              *
 *                                                                                                                                   *
 * //Compiler Options:                                                                                                               *
 * DISABLE_3D_TRYG_INIT         //Use before 3DTryg.inc for disable MapAndreas/ColAndreas Auto Init                                  *
 * DISABLE_3D_TRYG_ATM          //Use before 3DTryg.inc for disable ATM Module                                                       *
 * DISABLE_3D_TRYG_ACTOR        //Use before 3DTryg.inc for disable Actors Module                                                    *
 * DISABLE_3D_TRYG_FOXFOREACH   //Use before 3DTryg.inc for disable FoxForeach Module                                                *
 * DISABLE_3D_TRYG_YSIFOREACH   //Use before 3DTryg.inc for disable Foreach Module                                                   *
 * DISABLE_3D_TRYG_VEHICLECOL   //Use before 3DTryg.inc for disable VehicleCollision Module                                          *
 * DISABLE_3D_TRYG_MAPANDREAS   //Use before 3DTryg.inc for disable MapAndreas Module                                                *
 * DISABLE_3D_TRYG_COLANDREAS   //Use before 3DTryg.inc for disable ColAndreas Module                                                *
 * DISABLE_3D_TRYG_YSF          //Use before 3DTryg.inc for disable YSF Module                                                       *
 * DISABLE_3D_TRYG_STREAMER     //Use before 3DTryg.inc for disable Streamer Module                                                  *
 * DISABLE_3D_TRYG_FCNPC        //Use before 3DTryg.inc for disable FCNPC Module                                                     *
 * DISABLE_3D_TRYG_VEHSTREAMER  //Use before 3DTryg.inc for disable VehicleStreamer Module                                           *
 * DISABLE_3D_TRYG_GPS          //Use before 3DTryg.inc for disable GPS Module                                                       *
 * ENABLE_3D_TRYG_YSI_SUPPORT   //Use before 3DTryg.inc for enable YSI Support (use only when 3DTryg say error for this)             *
 * ENABLE_3D_TRYG_STREAM3D      //Use before 3DTryg.inc for enable Stream3D Module                                                   *
 * ENABLE_3D_TRYG_ANIMS         //Use before 3DTryg.inc for enable Anims Module                                                      *
 *                                                                                                                                   *
 * //Complementary Functions:
 * Float:sqrtN(Float:value,Float:exponent);
 * abs(value);
 * Float:fabs(Float:value);
 * power(value,Float:exponent);
 * IsEven(value);
 * Tryg3D::RandomFloat(Float:min,Float:max,accuracy=4);
 * 
 * //Internal Functions:
 * single_clock(max,id); //For Random::PointOnClock parameter rz
 * even_clock(max,id); //For Random::PointOnClock parameter rz
 * uneven_clock(max,id); //For Random::PointOnClock parameter rz
 * NLTZ(value); //NotLessThanZero
 * NMTZ(value); //NotMoreThanZero
 * NLTZF(Float:value); //NotLessThanZeroFloat
 * NMTZF(Float:value); //NotMoreThanZeroFloat
 * NLTV(value,min); //NotLessThanValue
 * NMTV(value,max); //NotMoreThanValue
 * NLTVF(Float:value,Float:min); //NotLessThanValueFloat
 * NMTVF(Float:value,Float:max); //NotMoreThanValueFloat
 * Tryg3D::CompressRotation(Float:rotation);
 * Tryg3D::DeCompressRotation(Float:rotation);
 * Tryg3D::IsRotationTest(Float:rotation,Float:r_min,Float:r_max);
 * Tryg3D::GivePlayerDamage(targetid,Float:amount,playerid,weaponid,bodypart);
 * Tryg3D::GetWeaponDamage(weaponid);
 * Tryg3D::SwapInt(variable1,variable2);
 * Tryg3D::IsPlayerSpawned(playerid);
 * Tryg3D::GetActiveTime();
 * 
 * //General Functions:
 * CountPlayers(bool:isplayer=true,bool:isnpc=true);
 * CountActors();
 * CountVisibleActors(playerid);
 * CountVisibleVehicles(playerid);
 * CountVisiblePlayers(playerid,bool:isplayer=true,bool:isnpc=true);
 * RecoilFloat(Float:value,Float:recoil);
 * RecoilVector(&Float:vx,&Float:vy,&Float:vz,Float:sx,Float:sy,Float:sz);
 * Float:ShiftDegreeToRadian(Float:deg);
 * Float:ShiftDegreeToRadianEx(Float:deg);
 * Float:ShiftDegreeToGrades(Float:deg);
 * Float:ShiftRadianToDegree(Float:rad);
 * Float:ShiftRadianToDegreeEx(Float:rad);
 * Float:ShiftRadianToGrades(Float:rad);
 * Float:ShiftGradesToDegree(Float:grad);
 * Float:ShiftGradesToRadian(Float:grad);
 * GetRandomHit(Float:x,Float:y,Float:z,range,&Float:tx,&Float:ty,&Float:tz);
 * Float:GetDistanceBetweenPoints1D(Float:x1,Float:x2);
 * Float:GetDistanceBetweenPoints2D(Float:x1,Float:y1,Float:x2,Float:y2);
 * Float:GetDistanceBetweenPoints3D(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2);
 * GetPointInFront2D(Float:x,Float:y,Float:rz,Float:radius,&Float:tx,&Float:ty);
 * GetPointInFront3D(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * GetPointInFront3DEx(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * Float:GetPointInFrontOfPlayer(playerid,&Float:tx,&Float:ty,Float:radius);
 * Float:GetPointInFrontOfCamera2D(playerid,&Float:tx,&Float:ty,Float:radius);
 * GetPointInFrontOfCamera3D(playerid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
 * GetRotationFor2Point2D(Float:x,Float:y,Float:tx,Float:ty,&Float:rz);
 * GetRotationFor2Point3D(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,&Float:rx,&Float:rz);
 * GetMoveTime(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,Float:speed,&rtime=0);
 * GetSpeedForMoveTime(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,&Float:speed,rtime);
 * GetVehicleRotation(vehicleid,&Float:rx,&Float:ry,&Float:rz);
 * Float:GetPointInFrontOfVehicle2D(vehicleid,&Float:tx,&Float:ty,Float:radius);
 * GetPointInFrontOfVehicle3D(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
 * GetPlayerCameraRotation(playerid,&Float:rx,&Float:rz);
 * SetPlayerCameraRotation(playerid,Float:rx,Float:rz);
 * Float:GetPlayerCameraZAngle(playerid,&Float:rz=0.0);
 * SetPlayerCameraZAngle(playerid,Float:rz);
 * GetPointFor2Point2D(Float:x1,Float:y1,Float:x2,Float:y2,Float:percent_size,&Float:tx,&Float:ty);
 * GetPointFor2Point3D(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2,Float:percent_size,&Float:tx,&Float:ty,&Float:tz);
 * GetPointFor2Point2DEx(Float:x1,Float:y1,Float:x2,Float:y2,Float:distance,&Float:tx,&Float:ty);
 * GetPointFor2Point3DEx(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2,Float:distance,&Float:tx,&Float:ty,&Float:tz);
 * ShiftVectorToRotation(Float:vx,Float:vy,Float:vz,&Float:rx,&Float:rz);
 * ShiftRotationToVector(Float:rx,Float:rz,&Float:vx,&Float:vy,&Float:vz);
 * GetPointToPointVector(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,&Float:vx,&Float:vy,&Float:vz);
 * IsPointBetween2Points2D(Float:px,Float:py,Float:xA,Float:yA,Float:xB,Float:yB);
 * IsPointBetween2Points3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB);
 * IsPointNearly2Points2D(Float:px,Float:py,Float:xA,Float:yA,Float:xB,Float:yB,Float:maxdist);
 * IsPointNearly2Points3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:maxdist);
 * Area::PointInCircle(Float:px,Float:py,Float:x,Float:y,Float:radius);
 * Area::PointInCylinder3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius);
 * Area::PointInCylinder2D(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:minz,Float:maxz,Float:radius);
 * Area::PointInSphere(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:z,Float:radius);
 * Area::PointInRectangle(Float:x,Float:y,Float:minx,Float:miny,Float:maxx,Float:maxy);
 * Area::PointInCube(Float:x,Float:y,Float:z,Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz);
 * Area::PointInPolygon(Float:x,Float:y,Float:points[],maxpoints=sizeof(points));
 * Area::PointInCircularSector(Float:px,Float:py,Float:x,Float:y,Float:rz,Float:radius,Float:view_angle);
 * Area::PointInSphericalSector(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz);
 * Area::PointInCone3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:pointA_radius,Float:pointB_radius);
 * Area::PointInCube3D(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z);
 * Area::PointInEllipse(Float:px,Float:py,Float:cx,Float:cy,Float:size_x,Float:size_y);
 * Area::PointInEllipticalCylinder(Float:px,Float:py,Float:pz,Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y);
 * Area::PointInSphericalSectorEx(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,bool:testLOS=true,bool:veh_col=false);
 * Random::PointInCircle(Float:x,Float:y,Float:radius,&Float:tx,&Float:ty);
 * Random::PointInCylinder2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointInCylinder3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointInSphere(Float:x,Float:y,Float:z,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointInRectangle(Float:minx,Float:miny,Float:maxx,Float:maxy,&Float:tx,&Float:ty);
 * Random::PointInCube(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointInPolygon(Float:points[],&Float:tx,&Float:ty,maxpoints=sizeof(points));
 * Random::PointInCircularSector(Float:x,Float:y,Float:rz,Float:radius,Float:view_angle,&Float:tx,&Float:ty);
 * Random::PointInSphericalSector(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointInCone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:pointA_radius,Float:pointB_radius,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointInCube3D(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointInEllipse(Float:cx,Float:cy,Float:size_x,Float:size_y,&Float:tx,&Float:ty);
 * Random::PointInEllipticalCyl2D(Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointOnCircle(Float:x,Float:y,Float:radius,&Float:tx,&Float:ty);
 * Random::PointOnCylinder2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointOnCylinder3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointOnSphere(Float:x,Float:y,Float:z,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointOnRectangle(Float:minx,Float:miny,Float:maxx,Float:maxy,&Float:tx,&Float:ty);
 * Random::PointOnCube(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointOnCircularSector(Float:x,Float:y,Float:rz,Float:radius,Float:view_angle,&Float:tx,&Float:ty);
 * Random::PointOnSphericalSector(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointOnCone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:pointA_radius,Float:pointB_radius,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointOnCube3D(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointOnEllipse(Float:cx,Float:cy,Float:size_x,Float:size_y,&Float:tx,&Float:ty);
 * Random::PointOnEllipticalCyl2D(Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y,&Float:tx,&Float:ty,&Float:tz);
 * Random::PointOnClock(Float:x,Float:y,Float:radius,&Float:tx,&Float:ty,&Float:trz,Float:rz=INVALID_ROTATION);
 * IsProbable(chance);
 * Float:CalculatePercent(Float:value,Float:maxvalue);
 * Float:GetPlayerTargetAngle(playerid,Float:x,Float:y,&Float:rz=0.0);
 * Float:SetPlayerTargetAngle(playerid,Float:x,Float:y,&Float:rz=0.0);
 * Float:GetPlayerTargetPlayerAngle(playerid,targetid,&Float:rz=0.0);
 * Float:SetPlayerTargetPlayerAngle(playerid,targetid,&Float:rz=0.0);
 * Float:GetVehicleSpeed(vehicleid);
 * SetVehicleSpeed(vehicleid,Float:speed);
 * Float:GetPlayerSpeed(playerid);
 * CreateDynamicExplosion(Float:x,Float:y,Float:z,type,Float:radius,worldid=-1,interiorid=-1,playerid=-1,Float:distance=200.0);
 * CreateDynamicExplosionDMG(Float:x,Float:y,Float:z,type,Float:radius,worldid=-1,interiorid=-1,playerid=-1,Float:distance=200.0,Float:damage=82.5,Float:vehicle_damage=82.5,byplayerid=INVALID_PLAYER_ID);
 * SendFakeDamageInRadius(weaponid,bodypart,Float:damage,Float:vehicle_damage,Float:x,Float:y,Float:z,Float:radius,worldid=-1,interiorid=-1,playerid=-1,byplayerid=INVALID_PLAYER_ID);
 * GetVehicleFlags(vehicleid);
 * GetVehicleDefaultFlagsByModel(modelid);
 * GetVehicleFlagsByModel(modelid);
 * SetVehicleFlagsByModel(modelid,value);
 * ToggleVehicleModelFlag(modelid,flag,bool:toggle);
 * IsVehicleFlag(value,flag);
 * GetWeaponShotPos(playerid,hittype,&Float:fx,&Float:fy,&Float:fz);
 * SetPlayerLookAtPlayer(playerid,targetid,cut=CAMERA_CUT);
 * GetPlayerCameraLookAt(playerid,&Float:x,&Float:y,&Float:z);
 * IsPlayerLookAtSky(playerid);
 * GetQuatUpVector(Float:qw,Float:qx,Float:qy,Float:qz,&Float:vx,&Float:vy,&Float:vz);
 * Float:GetLineSize2D(Float:points[][],maxpoints=sizeof(points));
 * Float:GetLineSize3D(Float:points[][],maxpoints=sizeof(points));
 * IsVehicleInRangeOfPoint(vehicleid,Float:range,Float:x,Float:y,Float:z);
 * IsActorInRangeOfPoint(actorid,Float:range,Float:x,Float:y,Float:z);
 * IsObjectInRangeOfPoint(objectid,Float:range,Float:x,Float:y,Float:z);
 * ShiftLineRotation(Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,Float:rx,Float:ry,Float:rz,&Float:nX,&Float:nY,&Float:nZ);
 * ShiftLineRotationVector(Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,Float:rx,Float:ry,Float:rz,&Float:nX,&Float:nY,&Float:nZ);
 * Float:GetEllipseRadius(Float:x,Float:y,Float:angle);
 * GetArcPoints3D(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,Float:ry,Float:height,Float:points[][],max_points=sizeof(points));
 * GetArcPointsFloor3D(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,Float:spread,Float:points[][],max_points=sizeof(points));
 * GetArcPointsCellar3D(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,Float:spread,Float:points[][],max_points=sizeof(points));
 * GetArcPointsLarboard3D(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,Float:spread,Float:points[][],max_points=sizeof(points));
 * GetArcPointsStarboard3D(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,Float:spread,Float:points[][],max_points=sizeof(points));
 * Float:GetDistanceFromPointToLine(Float:px,Float:py,Float:pz,Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,&Float:iX=0.0,&Float:iY=0.0,&Float:iZ=0.0);
 * ShiftOffsetToPosition(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:offset_x,Float:offset_y,Float:offset_z,&Float:tx,&Float:ty,&Float:tz);
 * ShiftPositionToOffset(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,&Float:offset_x,&Float:offset_y,&Float:offset_z,Float:tx,Float:ty,Float:tz);
 * Tryg3D::EulerToQuat(Float:rx,Float:ry,Float:rz,&Float:qw,&Float:qx,&Float:qy,&Float:qz);
 * Tryg3D::QuatToEuler(&Float:rx,&Float:ry,&Float:rz,Float:qw,Float:qx,Float:qy,Float:qz);
 * ShiftVectorRotation(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,&Float:tx,&Float:ty,&Float:tz);
 * GetCube3DPoint(OrientationCube3D:orientation,Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z,&Float:tx,&Float:ty,&Float:tz);
 * IsPlayerFakeSpectating(playerid,bool:force_disable=true);
 * GenerateGangZone(Float:x,Float:y,Float:radius,&Float:minx,&Float:miny,&Float:maxx,&Float:maxy);
 * Float:GetCameraTargetDistance(Float:CamX,Float:CamY,Float:CamZ,Float:ObjX,Float:ObjY,Float:ObjZ,Float:FrX,Float:FrY,Float:FrZ);
 * IsPlayerAimingAt(playerid,Float:x,Float:y,Float:z,Float:radius);
 * IPL_CreateObject(modelid,Float:x,Float:y,Float:z,Float:qx,Float:qy,Float:qz,Float:qw,Float:drawdistance=0.0);
 * 
 * //Universal Functions:
 * Item::GetInvalidID(Item3D_Type:item_type);
 * Item::GetPos(elementid,Item3D_Type:element_type,&Float:x,&Float:y,&Float:z);
 * Item::GetVirtualWorld(TRYG3D_ELEMENT_TAG:elementid,Item3D_Type:element_type);
 * Item::GetRotationQuat(elementid,Item3D_Type:element_type,&Float:qw,&Float:qx,&Float:qy,&Float:qz);
 * Item::GetUpVector(elementid,Item3D_Type:element_type,&Float:vx,&Float:vy,&Float:vz);
 * Item::GetUpPos(elementid,Item3D_Type:element_type,Float:radius,&Float:x,&Float:y,&Float:z,bool:reverse=false);
 * Item::GetDistance(elementid,Item3D_Type:element_type,targetid,Item3D_Type:target_type);
 * Item::GetDistanceFromPoint(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:z);
 * Item::OnPlayerScreen(playerid,targetid,Item3D_Type:target_type=item_player,element_orientation:orientation=o_front,Float:rx=INVALID_ROTATION,Float:rz=INVALID_ROTATION,Float:vrx=VERTICAL_CAMERA_RADIUS,Float:vrz=HORIZONTAL_CAMERA_RADIUS,bool:testLOS=true,bool:testVW=true,bool:veh_col=false);
 * Item::OnFakeScreen(Float:x,Float:y,Float:z,targetid,Item3D_Type:target_type,Float:rx,Float:rz,Float:vrx=VERTICAL_CAMERA_RADIUS,Float:vrz=HORIZONTAL_CAMERA_RADIUS,bool:testLOS=true,bool:veh_col=false);
 * Item::InCircle(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:radius);
 * Item::InCylinder3D(elementid,Item3D_Type:element_type,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius);
 * Item::InCylinder2D(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:minz,Float:maxz,Float:radius);
 * Item::InSphere(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:z,Float:radius);
 * Item::InRectangle(elementid,Item3D_Type:element_type,Float:minx,Float:miny,Float:maxx,Float:maxy);
 * Item::InCube(elementid,Item3D_Type:element_type,Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz);
 * Item::InPolygon(elementid,Item3D_Type:element_type,Float:points[],maxpoints=sizeof(points));
 * Item::InCircularSector(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:rz,Float:radius,Float:view_angle);
 * Item::InSphericalSector(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz);
 * Item::InCone(elementid,Item3D_Type:element_type,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:pointA_radius,Float:pointB_radius);
 * Item::InCube3D(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z);
 * Item::GetToPointVector(elementid,Item3D_Type:element_type,Float:tx,Float:ty,Float:tz,&Float:vx,&Float:vy,&Float:vz);
 * Item::GetRotatedVector(elementid,Item3D_Type:element_type,Float:tx,Float:ty,Float:tz,&Float:vx,&Float:vy,&Float:vz,bool:return_vector=true,Float:rx=0.0,Float:ry=0.0,Float:rz=0.0);
 * Item::GetOrientationPos(elementid,Item3D_Type:element_type,element_orientation:orientation,Float:distance,&Float:tx,&Float:ty,&Float:tz);
 * Item::InEllipse(elementid,Item3D_Type:element_type,Float:cx,Float:cy,Float:size_x,Float:size_y);
 * Item::InEllipticalCylinder2D(elementid,Item3D_Type:element_type,Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y);
 * 
 * //Universal Functions (ColAndreas):
 * Item::ToItemIsWall(elementid,Item3D_Type:element_type,targetid,Item3D_Type:target_type);
 * Item::ToPointIsWall(Float:x,Float:y,Float:z,targetid,Item3D_Type:target_type);
 * Item::GetCollisionFlags(elementid,Item3D_Type:element_type);
 * Item::IsPlayerInRange(playerid,Float:range,targetid,Item3D_Type:target_type=item_player,bool:testLOS=true,bool:veh_col=false);
 * Item::InRangeOfPoint(Float:x,Float:y,Float:z,Float:range,targetid,Item3D_Type:target_type=item_player,bool:testLOS=true,bool:veh_col=false);
 * Item::InRangeOfItem(elementid,Item3D_Type:element_type,Float:range,targetid,Item3D_Type:target_type=item_player,bool:testLOS=true,bool:veh_col=false);
 * Item::GetOrientationPosCol(elementid,Item3D_Type:element_type,element_orientation:orientation,Float:distance,&Float:tx,&Float:ty,&Float:tz);
 * Item::IsPointInWaterOrient(TRYG3D_ELEMENT_TAG:elementid,Item3D_Type:element_type,Float:radius,element_orientation:orientation=o_front);
 * 
 * //Universal Functions (Stream3D):
 * Item::InStream(elementid,Item3D_Type:element_type,Stream:StreamData[Stream3D]);
 * Item::GetInStream(Stream:StreamData[Stream3D],Item3D_Type:element_type,element_list[],max_element=sizeof(element_list));
 *
 * //Universal Functions (Streamer):
 * Item::InDynamicArea(TRYG3D_ELEMENT_TAG:elementid,Item3D_Type:element_type,STREAMER_TAG_AREA:areaid);
 * Item::GetInDynamicArea(STREAMER_TAG_AREA:areaid,Item3D_Type:element_type,element_list[],max_element=sizeof(element_list));
 * 
 * //ScreenToWorld Functions:
 * ScreenToWorld(playerid,Float:screenX,Float:screenY,&Float:vX,&Float:vY,&Float:vZ);
 * WorldToScreen(playerid,Float:x,Float:y,Float:z,&Float:screenX,&Float:screenY);
 * ScreenToWorldCol(playerid,Float:distance,Float:screenX,Float:screenY,&Float:vX,&Float:vY,&Float:vZ);
 * Tryg3D::NormCrossProduct(&Float:x,&Float:y,&Float:z,Float:v1x,Float:v1y,Float:v1z,Float:v2x,Float:v2y,Float:v2z);
 * 
 * //Nero_3D Rotations Functions:
 * Tryg3D::GetRotationMatrixEuler(Float:matrix[][],Float:rx,Float:ry,Float:rz,T3D:eulermode:mode=T3D:euler_default);
 * Tryg3D::MatrixRotate(Float:matrix[][],Float:oX,Float:oY,Float:oZ,&Float:x,&Float:y,&Float:z);
 * Tryg3D::QuatRotate(Float:qw,Float:qx,Float:qy,Float:qz,Float:oX,Float:oY,Float:oZ,&Float:tx,&Float:ty,&Float:tz);
 * Tryg3D::GetQuatFromEuler(Float:rx,Float:ry,Float:rz,&Float:qw,&Float:qx,&Float:qy,&Float:qz,T3D:eulermode:mode=T3D:euler_default);
 * Tryg3D::EulerRotate(Float:rX,Float:rY,Float:rZ,Float:oX,Float:oY,Float:oZ,&Float:tx,&Float:ty,&Float:tz,T3D:eulermode:mode=T3D:euler_default);
 * 
 * //VehiclePartPosition Functions:
 * GetVehiclePartPos(vehicleid,partid,&Float:tx,&Float:ty,&Float:tz,Float:offset_x=0.0,Float:offset_y=0.0,Float:offset_z=0.0);
 * GetDynamicVehiclePartPos(vehicleid,partid,&Float:tx,&Float:ty,&Float:tz,Float:offset_x=0.0,Float:offset_y=0.0,Float:offset_z=0.0);
 * 
 * //VehicleCollision Functions:
 * IsVehicleCollisionEnabled();
 * Tryg3D::InitVehicleCollision(); //OnGameModeInit / OnFilterScriptInit
 * Tryg3D::ExitVehicleCollision();
 * Tryg3D::SyncVehicleCollision(vehicleid); //EVF -> OnVehicleCreated
 * IsToggledVehicleCollision(vehicleid);
 * ToggleVehicleCollision(vehicleid,bool:toggle);
 * MovePointColWithVehicle(Float:StartX,Float:StartY,Float:StartZ,Float:EndX,Float:EndY,Float:EndZ,&Float:x,&Float:y,&Float:z);
 * MovePointColWithVehicleCut(Float:StartX,Float:StartY,Float:StartZ,Float:EndX,Float:EndY,Float:EndZ,&Float:x,&Float:y,&Float:z,Float:cut_size=0.0);
 * Item::ToPointIsVeh(Float:x,Float:y,Float:z,TRYG3D_ELEMENT_TAG:targetid,Item3D_Type:target_type);
 * Item::ToItemIsVeh(TRYG3D_ELEMENT_TAG:elementid,Item3D_Type:element_type,TRYG3D_ELEMENT_TAG:targetid,Item3D_Type:target_type);
 * 
 * //Extended Functions:
 * Tryg3D::GetModuleName(Tryg3D::Module:moduleid);
 * Tryg3D::GetModules(&modules_count=0);
 * Tryg3D::IsModuleLoaded(Tryg3D::Module:moduleid);
 * Tryg3D::GetErrorCount();
 * Tryg3D::ResetErrorCount();
 * Tryg3D::SetStreamDistance(Float:streamdistance); //default 300.0
 * Tryg3D::GetStreamDistance();
 * Tryg3D::GetActiveCount();
 * Tryg3D::GetVersion(value);
 * 
 * //Animation Functions:
 * Animation::IsPlayerSkydiving(playerid);
 * Animation::IsPlayerUsingParachute(playerid);
 * Animation::IsPlayerAiming(playerid);
 * Animation::IsPlayerStay(playerid);
 * Animation::IsPlayerRunning(playerid);
 * Animation::IsPlayerSwim(playerid);
 * Animation::IsPlayerJump(playerid);
 * Animation::IsPlayerParaFall(playerid);
 * Animation::IsPlayerParaGlide(playerid);
 * Animation::IsPlayerFall(playerid);
 * 
 * //ATM Module Functions:
 * randomex(min,max);
 * Tryg3D::KeyPressed(key);
 * Tryg3D::KeyReleased(key);
 * Tryg3D::KeyHolding(key);
 * Tryg3D::GetSAMIncludeVersion(value,name[],maxdest=sizeof(name));
 * Tryg3D::SecToTimeDay(second);      //Use: %d:%02d:%02d:%02d
 * Tryg3D::MSToTimeDay(millisecond);  //Use: %d:%02d:%02d:%02d
 * Tryg3D::SecToTime(second);         //Use: %02d:%02d:%02d
 * Tryg3D::MSToTime(millisecond);     //Use: %02d:%02d:%02d
 * Tryg3D::SecToTimeMini(second);     //Use: %02d:%02d
 * Tryg3D::MSToTimeMini(millisecond); //Use: %02d:%02d
 * 
 * //Streamer Functions:
 * IsDynamicObjectInRangeOfPoint(objectid,Float:range,Float:x,Float:y,Float:z);
 * SetPlayerAbsolutePosition(playerid,Float:x,Float:y,Float:z,Float:angle,worldid=-1,interiorid=-1,compensatedtime=-1,freezeplayer=1);
 * SetPlayerAbsolutePositionVeh(playerid,Float:x,Float:y,Float:z,Float:angle,worldid=-1,interiorid=-1,compensatedtime=-1,freezeplayer=1);
 * IsDynamicActorInRangeOfPoint(actorid,Float:range,Float:x,Float:y,Float:z);
 * IsVehicleFullyInDynamicArea(vehicleid,areaid);
 * Random::PointInDynamicArea(STREAMER_TAG_AREA:areaid,&Float:tx,&Float:ty,&Float:tz);
 * IPL_CreateDynamicObject(modelid,Float:x,Float:y,Float:z,Float:qx,Float:qy,Float:qz,Float:qw,worldid=-1,interiorid=-1,playerid=-1,Float:streamdistance=STREAMER_OBJECT_SD,Float:drawdistance=STREAMER_OBJECT_DD,STREAMER_TAG_AREA:areaid=STREAMER_TAG_AREA:-1,priority=0);
 * 
 * //MapAndreas Functions:
 * Float:MapAndreasFindZ(Float:x,Float:y,&Float:z=0.0);
 * GetGroundRotation(Float:x,Float:y,Float:size,&Float:rx,&Float:ry);
 * GetPointInFrontOnGround(Float:x,Float:y,Float:z,Float:rx,Float:rz,&Float:tx,&Float:ty,&Float:tz,Float:max_distance);
 * IsPointInWater(Float:x,Float:y,Float:z=0.0);
 * 
 * //MapAndreas Extended Functions:
 * Tryg3D::IsMapAndreasInit();
 * Tryg3D::SafeMapAndreasInit(mode=MAP_ANDREAS_MODE_FULL,name[]="",len=sizeof(name));
 * 
 * //ColAndreas Functions:
 * MovePointCol(Float:StartX,Float:StartY,Float:StartZ,Float:EndX,Float:EndY,Float:EndZ,&Float:x,&Float:y,&Float:z);
 * MovePointColCutLine(Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,&Float:x,&Float:y,&Float:z,Float:cut_size=0.0);
 * MovePointColCutLineEx(Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,&Float:x,&Float:y,&Float:z,Float:cut_size=0.0);
 * GetPointInFront3DCol(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * GetPointInFront3DColEx(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:radius,&Float:tx,&Float:ty,&Float:tz);
 * Float:GetPointInFrontOfPlayerCol(playerid,&Float:tx,&Float:ty,Float:radius);
 * Float:GetPointInFrontOfCamera2DCol(playerid,&Float:tx,&Float:ty,Float:radius);
 * GetPointInFrontOfCamera3DCol(playerid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
 * Float:GetPointInFrontOfVehicle2DCol(vehicleid,&Float:tx,&Float:ty,Float:radius);
 * GetPointInFrontOfVehicle3DCol(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
 * GetGroundRotation(Float:x,Float:y,Float:size,&Float:rx,&Float:ry);
 * GetPointInFrontOnGround(Float:x,Float:y,Float:z,Float:rx,Float:rz,&Float:tx,&Float:ty,&Float:tz,Float:max_distance);
 * GetPointCollisionFlags(Float:x,Float:y,Float:z,interiorid=0);
 * IsCollisionFlag(value,flag);
 * Float:UndergroundFindZ(Float:x,Float:y,&Float:z=0.0);
 * Float:InteriorFindZ(Float:px,Float:py,Float:pz=1000.0,Float:size=2.0,&Float:z=0.0);
 * IsPointInWater(Float:x,Float:y,Float:z=0.0);
 * IsPointInUnderwater(Float:x,Float:y,Float:z);
 * IsPointInUnderground(Float:x,Float:y,Float:z);
 * IsPointInAir(Float:x,Float:y,Float:z,bool:interior=false,Float:max_distance=2.2);
 * IsPointInGround(Float:x,Float:y,Float:z,bool:interior=false,Float:max_distance=2.2);
 * IsBetweenPlayersIsWall(playerid,targetid);
 * IsBetweenPlayerToPointIsWall(playerid,Float:x,Float:y,Float:z);
 * GetPointInWallForPoint(Float:x,Float:y,Float:z,Float:radius,&Float:tx,&Float:ty,&Float:tz,Float:sector=90.0);
 * GetWallRotation(Float:sx,Float:sy,Float:sz,Float:ex,Float:ey,Float:ez,&Float:rx,&Float:rz,&Float:px=0.0,&Float:py=0.0,&Float:pz=0.0,Float:size=1.0,Float:cut_size=0.0);
 * Float:MapAndreasFindZ(Float:x,Float:y,&Float:z=0.0);
 * ColAndreas::FindGroundZ(Float:x,Float:y,Float:z,&Float:gZ);
 * 
 * //ColAndreas Extended Functions:
 * Tryg3D::IsColAndreasInit();
 * Tryg3D::SafeColAndreasInit();
 * 
 * //ColAndreas Callbacks:
 * OnColAndreasRemoveBuilding();
 * OnPlayerDroppingGrenade(playerid,weaponid,Float:x,Float:y,Float:z);
 * 
 * //YSF Functions:
 * Float:GetPlayerHydraReactorRX(playerid);
 * IsPlayerHydraReactorBoost(playerid);
 * GetPlayerRotation(playerid,&Float:rx,&Float:ry,&Float:rz);
 * CountTextDraw();
 * CountPlayerTextDraw(playerid);
 * CountVisibleTextDraw(playerid);
 * CountVisiblePlayerTextDraw(playerid);
 * CountGangZone();
 * CountVisibleGangZone(playerid);
 * CountPlayerGangZone(playerid);
 * CountVisiblePlayerGangZone(playerid);
 * IsVehicleOnSpawn(vehicleid,Float:check_radius=1.0);
 * IsPlayerOnSpawn(playerid,Float:check_radius=1.0);
 * Random::PointInGangZone(zoneid,&Float:tx,&Float:ty);
 * Random::PointInPlayerGangZone(playerid,zoneid,&Float:tx,&Float:ty);
 * 
 * //FCNPC Functions:
 * FCNPC::GetPointInFront(npcid,&Float:tx,&Float:ty,Float:radius);
 * FCNPC::InRangeOfPoint(npcid,Float:range,Float:x,Float:y,Float:z);
 * FCNPC::GetTargetAngle(npcid,Float:x,Float:y,&Float:rz=0.0);
 * FCNPC::SetTargetAngle(npcid,Float:x,Float:y,&Float:rz=0.0);
 * FCNPC::SetVehicleRotation(npcid,Float:rx,Float:ry,Float:rz);
 * FCNPC::SetVehicleTargetRotation(npcid,Float:tx,Float:ty,Float:tz,Float:ry=0.0);
 * FCNPC::GoToAir(npcid,Float:x,Float:y,Float:z,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,Float:min_distance=0.0,stopdelay=250);
 * 
 * //FCNPC Functions (ColAndreas):
 * FCNPC::GetPointInFrontCol(npcid,&Float:tx,&Float:ty,Float:radius);
 * FCNPC::GoToCol(npcid,Float:x,Float:y,Float:z,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,Float:cut_size=0.0,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);
 * FCNPC::GoToPlayerCol(npcid,playerid,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,Float:cut_size=0.0,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);
 * FCNPC::GoToPlayerOnGroundCol(npcid,playerid,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,Float:cut_size=1.0,Float:climbing=2.0,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);
 * FCNPC::GoToPlayerOnGroundColVeh(npcid,playerid,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,Float:cut_size=1.0,Float:climbing=2.0,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);
 * FCNPC::GoToAirCol(npcid,Float:x,Float:y,Float:z,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,Float:cut_size=0.0,Float:min_distance=0.0,stopdelay=250);
 * FCNPC::RandomMoveInDynamicArea(npcid,STREAMER_TAG_AREA:areaid,Float:climbing=2.0,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);
 * FCNPC::RandomMoveInStream(npcid,Stream:StreamData[Stream3D],Float:climbing=2.0,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);
 * FCNPC::SetAbsolutePosition(npcid,Float:x,Float:y,Float:z,Float:angle,worldid=-1,interiorid=-1,compensatedtime=-1,freezeplayer=1);
 * FCNPC::SetFloorPos(npcid);
 * 
 * //Stream3D Functions:
 * StreamCreate(variable);
 * StreamType:GetStreamType(Stream:StreamData[Stream3D]);
 * Stream:ConvertAreaToStream(areaid);
 * Stream:StreamCircle(Float:x,Float:y,Float:radius);
 * Stream:StreamCylinder3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius);
 * Stream:StreamCylinder2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius);
 * Stream:StreamSphere(Float:x,Float:y,Float:z,Float:radius);
 * Stream:StreamRectangle(Float:minx,Float:miny,Float:maxx,Float:maxy);
 * Stream:StreamCube(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz);
 * Stream:StreamCircularSector(Float:x,Float:y,Float:rz,Float:radius,Float:view_angle);
 * Stream:StreamSphericalSector(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz);
 * Stream:StreamCone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:pointA_radius,Float:pointB_radius);
 * Stream:StreamCube3D(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z);
 * Stream:StreamEllipse(Float:cx,Float:cy,Float:size_x,Float:size_y);
 * Stream:StreamEllipticalCylinder2D(Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y);
 * IsValidStream(Stream:StreamData[Stream3D]);
 * Area::PointInStream(Float:x,Float:y,Float:z,Stream:StreamData[Stream3D]);
 * Random::PointInStream(Stream:StreamData[Stream3D],&Float:x,&Float:y,&Float:z);
 * Random::PointOnStream(Stream:StreamData[Stream3D],&Float:x,&Float:y,&Float:z);
 * IsVehicleFullyInStream(vehicleid,Stream:StreamData[Stream3D]);
 * 
 * //VehicleStreamer Functions:
 * GetDynamicVehicleFlags(vehicleid);
 * Float:GetDynamicVehicleSpeed(vehicleid);
 * Float:GetPointInFrontOfDynVeh2D(vehicleid,&Float:tx,&Float:ty,Float:radius);
 * GetPointInFrontOfDynVeh3D(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
 * IsDynVehInRangeOfPoint(vehicleid,Float:range,Float:x,Float:y,Float:z);
 * IsDynVehFullyInDynamicArea(vehicleid,areaid);
 * Float:GetPointInFrontOfDynVeh2DCol(vehicleid,&Float:tx,&Float:ty,Float:radius);
 * GetPointInFrontOfDynVeh3DCol(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
 * IsDynamicVehicleOnSpawn(vehicleid,Float:check_radius=1.0);
 * IsDynamicVehicleFullyInStream(vehicleid,Stream:StreamData[Stream3D]);
 * GetDynamicVehicleRotation(vehicleid,&Float:rx,&Float:ry,&Float:rz);
 * 
 * //Functions extra names:
 * Tryg3D::MapAndreasFindZ        -> ColAndreas::FindZ_For2DCoord / MapAndreasFindZ
 *
 * //Deprecated Functions:
 * GetDistanceBetweenPoints       -> GetDistanceBetweenPoints3D
 * GetPlayersDistance             -> Item::GetDistance
 * GetVehiclesDistance            -> Item::GetDistance
 * GetObjectsDistance             -> Item::GetDistance
 * GetActorDistanceFromPoint      -> Item::GetDistanceFromPoint
 * GetObjectDistanceFromPoint     -> Item::GetDistanceFromPoint
 * GetDistanceBetweenPlayers      -> Item::GetDistance
 * GetDistanceBetweenVehicles     -> Item::GetDistance
 * GetDistanceBetweenObjects      -> Item::GetDistance
 * GetPlayerActorDistance         -> Item::GetDistance
 * GetPlayerVehicleDistance       -> Item::GetDistance
 * GetPlayerObjectDistance        -> Item::GetDistance
 * IsPlayerInCircle               -> Item::In...
 * IsPlayerInCylinder3D           -> Item::In...
 * IsPlayerInCylinder2D           -> Item::In...
 * IsPlayerInSphere               -> Item::In...
 * IsPlayerInRectangle            -> Item::In...
 * IsPlayerInCube                 -> Item::In...
 * IsPlayerInPolygon              -> Item::In...
 * IsPlayerInCircularSector       -> Item::In...
 * IsPlayerInSphericalSector      -> Item::In...
 * IsPlayerInCone                 -> Item::In...
 * IsPlayerInCube3D               -> Item::In...
 * IsPlayerInEllipse              -> Item::In...
 * IsPlayerInEllipticalCylinder2D -> Item::InEllipticalCylinder2D
 * GetPlayerCollisionFlags        -> Item::GetCollisionFlags
 * GetVehicleCollisionFlags       -> Item::GetCollisionFlags
 * IsPointInWaterFrontOfPlayer    -> Item::IsPointInWaterOrient
 *                                                                                                                                   *
 * //Symbols:                                                                                                                        *
 * FLOAT_PI                    - pi constant value                                                                                   *
 * FLOAT_EULER                 - Euler number                                                                                        *
 * FLOAT_NAN                   - Float NaN                                                                                           *
 * FLOAT_DEFECT                - Float defect (Arc Test)                                                                             *
 * FLOAT_INFINITY              - Float Infinity                                                                                      *
 * VBTP                        - Value Bigger Than Possible                                                                          *
 * VLTP                        - Value Lower Than Possible                                                                           *
 *                                                                                                                                   *
 * //Definitions:                                                                                                                    *
 * VERTICAL_CAMERA_RADIUS      - (modifiable)                                                                                        *
 * HORIZONTAL_CAMERA_RADIUS    - (modifiable)                                                                                        *
 * INVALID_ROTATION            - (modifiable)                                                                                        *
 * MAX_POLYGON_POINTS          - (modifiable)                                                                                        *
 * VEHICLE_SPEED_MULTIPLIER    - (modifiable)                                                                                        *
 * PLAYER_SPEED_MULTIPLIER     - (modifiable)                                                                                        *
 * INVALID_MOVE_TIME           - (modifiable)                                                                                        *
 * INVALID_MOVE_SPEED          - (modifiable)                                                                                        *
 * INVALID_VIRTUAL_WORLD                                                                                                             *
 *                                                                                                                                   *
 * //Position Flags:                                                                                                                 *
 * POSITION_FLAG_WORLD                                                                                                               *
 * POSITION_FLAG_INTERIOR                                                                                                            *
 * POSITION_FLAG_AIR                                                                                                                 *
 * POSITION_FLAG_GROUND                                                                                                              *
 * POSITION_FLAG_WATER                                                                                                               *
 * POSITION_FLAG_UNDERWATER                                                                                                          *
 * POSITION_FLAG_UNDERGROUND                                                                                                         *
 *                                                                                                                                   *
 * //Vehicle Flags:                                                                                                                  *
 * VF_STREET        VF_AIRBORNE      VF_NATATORIAL    VF_MILITARY      VF_TRAIN         VF_RC            VF_CARRIAGE                 *
 * VF_AIRPLANE      VF_HELICOPTER    VF_BIKES         VF_TRAILER       VF_TOWABLE       VF_POLICE                                    *
 *                                                                                                                                   *
 * //Vehicle Parts:                                                                                                                  *
 * VEHICLE_PART_RFTIRE         - Right Front tire                                                                                    *
 * VEHICLE_PART_LFTIRE         - Left Front tire                                                                                     *
 * VEHICLE_PART_RRTIRE         - Right Rear tire                                                                                     *
 * VEHICLE_PART_LRTIRE         - Left Rear tire                                                                                      *
 * VEHICLE_PART_HOOD           - In Front                                                                                            *
 * VEHICLE_PART_TRUNK          - Behind                                                                                              *
 * VEHICLE_PART_ROOF           - Roof                                                                                                *
 * VEHICLE_PART_CHASSIS        - Chassis                                                                                             *
 * VEHICLE_PART_PETROLCAP      - Petrolcap                                                                                           *
 *                                                                                                                                   *
 * enum 'element_orientation'                                                                                                        *
 * # o_left                    - Orientation Left                                                                                    *
 * # o_right                   - Orientation Right                                                                                   *
 * # o_up                      - Orientation UP                                                                                      *
 * # o_down                    - Orientation Down                                                                                    *
 * # o_front                   - Orientation Front                                                                                   *
 * # o_back                    - Orientation Back                                                                                    *
 *                                                                                                                                   *
 * enum 'Item3D_Type'                                                                                                                *
 * # item_player                                                                                                                     *
 * # item_npc                                                                                                                        *
 * # item_actor                                                                                                                      *
 * # item_object                                                                                                                     *
 * # item_vehicle                                                                                                                    *
 * # item_dynamic_object                                                                                                             *
 * # item_dynamic_pickup                                                                                                             *
 * # item_dynamic_cp                                                                                                                 *
 * # item_dynamic_racecp                                                                                                             *
 * # item_dynamic_mapicon                                                                                                            *
 * # item_dynamic_3dtext                                                                                                             *
 * # item_dynamic_actor                                                                                                              *
 * # item_dynamic_vehicle                                                                                                            *
 * # item_fcnpc                                                                                                                      *
 *                                                                                                                                   *
 * enum 'Vectors3D'                                                                                                                  *
 * # Float: T3D:X             - Position X                                                                                           *
 * # Float: T3D:Y             - Position Y                                                                                           *
 * # Float: T3D:Z             - Position Z                                                                                           *
 * # Float: T3D:A             - Angle                                                                                                *
 *                                                                                                                                   *
 * enum 'Float3D'                                                                                                                    *
 * # Float: T3D:X             - Position X                                                                                           *
 * # Float: T3D:Y             - Position Y                                                                                           *
 * # Float: T3D:Z             - Position Z                                                                                           *
 * # Float: T3D:rX            - Rotation X                                                                                           *
 * # Float: T3D:rY            - Rotation Y                                                                                           *
 * # Float: T3D:rZ            - Rotation Z                                                                                           *
 * # Float: T3D:tX            - Target Position X                                                                                    *
 * # Float: T3D:tY            - Target Position Y                                                                                    *
 * # Float: T3D:tZ            - Target Position Z                                                                                    *
 * #        T3D:VW            - Virtual World ID                                                                                     *
 * #        T3D:INT           - Interior ID                                                                                          *
 * # Float: T3D:SPEED         - Speed                                                                                                *
 *                                                                                                                                   *
 * enum 'LongFloat3D'                                                                                                                *
 * # Float: T3D:X             - Position X                                                                                           *
 * # Float: T3D:Y             - Position Y                                                                                           *
 * # Float: T3D:Z             - Position Z                                                                                           *
 * # Float: T3D:rX            - Rotation X                                                                                           *
 * # Float: T3D:rY            - Rotation Y                                                                                           *
 * # Float: T3D:rZ            - Rotation Z                                                                                           *
 * # Float: T3D:tX            - Target Position X                                                                                    *
 * # Float: T3D:tY            - Target Position Y                                                                                    *
 * # Float: T3D:tZ            - Target Position Z                                                                                    *
 * # Float: T3D:trX           - Target Rotation X                                                                                    *
 * # Float: T3D:trY           - Target Rotation Y                                                                                    *
 * # Float: T3D:trZ           - Target Rotation Z                                                                                    *
 * # Float: T3D:VecX          - Vector Position X                                                                                    *
 * # Float: T3D:VecY          - Vector Position Y                                                                                    *
 * # Float: T3D:VecZ          - Vector Position Z                                                                                    *
 * #        T3D:VW            - Virtual World ID                                                                                     *
 * #        T3D:INT           - Interior ID                                                                                          *
 * # Float: T3D:SPEED         - Speed                                                                                                *
 *                                                                                                                                   *
 * enum 'StreamType'                                                                                                                 *
 * # s_invalid                                                                                                                       *
 * # s_circle                                                                                                                        *
 * # s_cylinder2d                                                                                                                    *
 * # s_cylinder3d                                                                                                                    *
 * # s_sphere                                                                                                                        *
 * # s_rectangle                                                                                                                     *
 * # s_cube2d                                                                                                                        *
 * # s_cube3d                                                                                                                        *
 * # s_circularsector                                                                                                                *
 * # s_sphericalsector                                                                                                               *
 * # s_cone                                                                                                                          *
 * # s_ellipse                                                                                                                       *
 * # s_ellipticalcyl2d                                                                                                               *
 *                                                                                                                                   *
 * enum 'OrientationCube3D'                                                                                                          *
 * # o_left_back_down                                                                                                                *
 * # o_right_back_down                                                                                                               *
 * # o_right_front_down                                                                                                              *
 * # o_left_front_down                                                                                                               *
 * # o_left_back_up                                                                                                                  *
 * # o_right_back_up                                                                                                                 *
 * # o_right_front_up                                                                                                                *
 * # o_left_front_up                                                                                                                 *
 *                                                                                                                                   *
 * enum 'Tryg3D::Module'                                                                                                             *
 * # TRYG3D_MODULEID_MAPANDREAS                                                                                                      *
 * # TRYG3D_MODULEID_COLANDREAS                                                                                                      *
 * # TRYG3D_MODULEID_YSF                                                                                                             *
 * # TRYG3D_MODULEID_STREAMER                                                                                                        *
 * # TRYG3D_MODULEID_FOXFOREACH                                                                                                      *
 * # TRYG3D_MODULEID_YSIFOREACH                                                                                                      *
 * # TRYG3D_MODULEID_FCNPC                                                                                                           *
 * # TRYG3D_MODULEID_STREAM3D                                                                                                        *
 * # TRYG3D_MODULEID_ACTOR                                                                                                           *
 * # TRYG3D_MODULEID_ATM                                                                                                             *
 * # TRYG3D_MODULEID_ANIMS                                                                                                           *
 * # TRYG3D_MODULEID_VEHSTREAMER                                                                                                     *
 * # TRYG3D_MODULEID_VEHICLECOL                                                                                                      *
 *                                                                                                                                   *
 *************************************************************************************************************************************/ 
Download:
3DTryg.inc

More functions available with plugins:
Use ColAndreas Functions (NOT REQUIRED)
Use MapAndreas Functions (NOT REQUIRED)
Use YSF Functions (NOT REQUIRED)
Use Streamer Functions (NOT REQUIRED)
Use FCNPC Functions (NOT REQUIRED)
Use VehicleStreamer Functions (NOT REQUIRED)

Supported Includes:
FoxForeach (NOT REQUIRED)
Foreach (NOT REQUIRED)

Compatibility includes:
rotation.inc by Nero_3D
i_quat.inc by IllidanS4

Supported elements:

1. Character Elements:

- Player's

- NPC's

- Actor's

- FCNPC's


2. Static Elements:

- Object's

- Vehicle's

- GangZone's


3. Dynamic Elements:

- DynamicObject's

- DynamicPickup's

- DynamicCP's

- DynamicRaceCP's

- DynamicMapIcon's

- Dynamic3DText's

- DynamicActor's

- DynamicVehicles's


4. Areas 2D / 3D:

a) Geometric Figures:

- Circle

- Rectangle

- Polygon

- CircularSector

- Ellipse


b) Chunk:

- Cylinder2D

- Sphere

- Cube

- EllipticalCylinder2D


c) Rotated Chunk:

- Cylinder3D

- SphericalSector

- Cube3D

- Cone3D

3DTryg Tree:



Non-Registered Users:
Bug Report
Reply
#2

I like the fact that you are trying actually to help out the whole community, well done and keep up with this beneficial work
Reply
#3

Thanks really needed the 3D version of it for quite a long time
Reply
#4

This is not an include, it's a snippet that belongs in the "Useful Snippets" thread.


Plus, I made the 3D version already (it's in the useful snippets)! You have the parameters named wrong too, it's not RX and RZ. It's latitude and longitude.
Reply
#5

not, the parameters are valid RX and RZ !
Reply
#6

Quote:
Originally Posted by AbyssMorgan
View Post
not, the parameters are valid RX and RZ !
No. Sure RZ is a valid latitude, but neither RX or RY are longitude. They can both be adjusted to be longitude, but then the correct term would be in fact longitude.
Reply
#7

these are rotations, wake up
Reply
#8

Quote:
Originally Posted by AbyssMorgan
View Post
these are rotations, wake up
Latitude and longitude are rotations. Do some research child.

https://upload.wikimedia.org/wikiped..._Earth.svg.png
Reply
#9

Map of GTA is flat
Do not lecture.
Reply
#10

In geography it's latitude and longitude but in mathematical geometry they are rotations. AbyssMoragan, here GTA map structure does not come into action in any way, Crayder just showed you an example with respect to the Earth.
Reply
#11

It's not anything to do with the terrain. It's all a point in space and angles from that point.
Quote:

Map of GTA is flat
Do not lecture.

You saying that just proved how much you know, not much at all!
Reply
#12

Quote:
Originally Posted by Crayder
Посмотреть сообщение
It's not anything to do with the terrain. It's all a point in space and angles from that point.You saying that just proved how much you know, not much at all!
I know that I have to give rotations RX and RZ, and not some length
Reply
#13

I added two new function:
PHP код:
GetRotationFor2Point2D(Float:xFloat:yFloat:txFloat:ty, &Float:rz); //made by Zoutdaxv (modified version)
GetRotationFor2Point3D(Float:xFloat:yFloat:zFloat:txFloat:tyFloat:tz, &Float:rx, &Float:rz); //new code version support 3D made by Abyss Morgan 
Reply
#14

Quote:
Originally Posted by AbyssMorgan
Посмотреть сообщение
I know that I have to give rotations RX and RZ, and not some length
Latitude and longitude are not lengths. They are rotations. We've been over this already.
Reply
#15

Quote:
Originally Posted by Crayder
Посмотреть сообщение
Latitude and longitude are not lengths. They are rotations. We've been over this already.
not important, it gives the parameters that will understand every person, not just you
Reply
#16

Quote:
Originally Posted by AbyssMorgan
Посмотреть сообщение
not important, it gives the parameters that will understand every person, not just you
You are the only person here that doesn't know what latitude and longitude is.

Also:
pawn Код:
stock CompRotationFloat(Float:rotation,&Float:cr){
    cr = rotation;
    while(cr < 0.0) cr += 360.0;
    while(cr >= 360.0) cr -= 360.0;
}
Use a while loop. One single subtraction or addition could return adverse numbers. Using a while loop will make sure the number is more than 0 and less than 360 no matter what the input is.
Reply
#17

added new function:
PHP код:
ShiftDegreeToRadian(Float:deg,&Float:rad);
ShiftDegreeToGrades(Float:deg,&Float:grad);
ShiftRadianToDegree(Float:rad,&Float:deg);
ShiftRadianToGrades(Float:rad,&Float:grad);
ShiftGradesToDegree(Float:grad,&Float:deg);
ShiftGradesToRadian(Float:grad,&Float:rad);
ConvertMTARaceRotation(Float:rotation1,Float:rotation2,Float:rotation3,&Float:rx,&Float:ry,&Float:rz);
ConvertToMTARaceRotation(Float:rx,Float:ry,Float:rz,&Float:rotation1,&Float:rotation2,&Float:rotation3); 
Download Full Include from GitHub
Reply
#18

Updated 3DTryg.inc to v2.5 now

Fixed GetVehicleRotation thanks for IllidanS4
PHP код:
GetVehicleRotation(vehicleid,&Float:rx,&Float:ry,&Float:rz); 
Added new function:
PHP код:
Float:GetPointInFrontOfVehicle2D(vehicleid,&Float:tx,&Float:ty,Float:radius);
GetPointInFrontOfVehicle3D(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
Float:GetPointInFrontOfPlayer(playerid,&Float:tx,&Float:ty,Float:radius); //GetXYInFrontOfPlayer
 
Float:GetPointInFrontOfCamera2D(playerid,&Float:tx,&Float:ty,Float:radius);
GetPointInFrontOfCamera3D(playerid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
Float:GetPlayerTargetAngle(playerid,Float:x,Float:y,&Float:rz=0.0);
Float:SetPlayerTargetAngle(playerid,Float:x,Float:y,&Float:rz=0.0);
GetPlayerCameraRotation(playerid,&Float:rx,&Float:rz);
Float:GetPlayerCameraZAngle(playerid,&Float:rz=0.0);
GetPointInFrontOnGround(Float:x,Float:y,Float:z,Float:rx,Float:rz,&Float:tx,&Float:ty,&Float:tz,Float:max_distance);
bool:IsPointInCylinder(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:maxdist);
bool:IsProbable(chance); 
Completed functions:
PHP код:
GetGroundRotation(Float:x,Float:y,Float:size,&Float:rx,&Float:ry); 
Optimized functions:
PHP код:
NLTZ(value);
NMTZ(value);
Float:NLTZF(Float:value);
Float:NMTZF(Float:value);
Float:ShiftDegreeToRadian(Float:deg);
Float:ShiftDegreeToRadianEx(Float:deg);
Float:ShiftDegreeToGrades(Float:deg);
Float:ShiftRadianToDegree(Float:rad);
Float:ShiftRadianToDegreeEx(Float:rad);
Float:ShiftRadianToGrades(Float:rad);
Float:ShiftGradesToDegree(Float:grad);
Float:ShiftGradesToRadian(Float:grad);
ShiftRotationToVector(Float:rx,Float:rz,&Float:vx,&Float:vy,&Float:vz);
GetRotationFor2Point2D(Float:x,Float:y,Float:tx,Float:ty,&Float:rz);
Float:GetDistanceBetweenPoints1D(Float:x1,Float:x2);
Float:GetDistanceBetweenPoints2D(Float:x1,Float:y1,Float:x2,Float:y2);
Float:GetDistanceBetweenPoints3D(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2);
Float:sqrtN(Float:value,Float:exponent); 
All functions:
PHP код:
Float:sqrtN(Float:value,Float:exponent);
abs(value);
power(value,Float:exponent);
Float:ctg(Float:value,anglemode:mode=radian);
Float:secans(Float:value,anglemode:mode=radian);
Float:cosecans(Float:value,anglemode:mode=radian);
single_clock(max,id);
even_clock(max,id);
uneven_clock(max,id);
IsEven(value);
GetRandomHit(Float:x,Float:y,Float:z,range,&Float:tx,&Float:ty,&Float:tz);
Float:GetDistanceBetweenPoints1D(Float:x1,Float:x2);
Float:GetDistanceBetweenPoints2D(Float:x1,Float:y1,Float:x2,Float:y2);
Float:GetDistanceBetweenPoints3D(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2);
NLTZ(value);
NMTZ(value);
Float:NLTZF(Float:value);
Float:NMTZF(Float:value);
CompRotation(rotation,&cr=0);
Float:CompRotationFloat(Float:rotation,&Float:cr=0.0);
GetPointInFront2D(Float:x,Float:y,Float:rz,Float:radius,&Float:tx,&Float:ty);
Float:GetPointInFrontOfPlayer(playerid,&Float:tx,&Float:ty,Float:radius);
Float:GetPointInFrontOfCamera2D(playerid,&Float:tx,&Float:ty,Float:radius);
GetPointInFrontOfCamera3D(playerid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
GetPointInFront3D(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,&Float:tx,&Float:ty,&Float:tz);
GetRotationFor2Point2D(Float:x,Float:y,Float:tx,Float:ty,&Float:rz);
GetRotationFor2Point3D(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,&Float:rx,&Float:rz);
GetRandomClockPos(Float:x,Float:y,Float:z,Float:radius,&Float:tx,&Float:ty,&Float:tz,&Float:trz,Float:rz = -1000.0);
GetRandomPointInCube(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz,&Float:x,&Float:y,&Float:z);
Float:ShiftDegreeToRadian(Float:deg);
Float:ShiftDegreeToRadianEx(Float:deg);
Float:ShiftDegreeToGrades(Float:deg);
Float:ShiftRadianToDegree(Float:rad);
Float:ShiftRadianToDegreeEx(Float:rad);
Float:ShiftRadianToGrades(Float:rad);
Float:ShiftGradesToDegree(Float:grad);
Float:ShiftGradesToRadian(Float:grad);
ConvertMTARaceRotation(Float:rotation1,Float:rotation2,Float:rotation3,&Float:rx,&Float:ry,&Float:rz);
ConvertToMTARaceRotation(Float:rx,Float:ry,Float:rz,&Float:rotation1,&Float:rotation2,&Float:rotation3);
GetMoveTime(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,Float:speed,&rtime);
Float:GetSpeedForMoveTime(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,&Float:speed,rtime);
GetVehicleRotation(vehicleid,&Float:rx,&Float:ry,&Float:rz);
Float:GetPointInFrontOfVehicle2D(vehicleid,&Float:tx,&Float:ty,Float:radius);
GetPointInFrontOfVehicle3D(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);
GetPlayerCameraRotation(playerid,&Float:rx,&Float:rz);
Float:GetPlayerCameraZAngle(playerid,&Float:rz=0.0);
GetPointFor2Point2D(Float:x1,Float:y1,Float:x2,Float:y2,Float:percent_size,&Float:tx,&Float:ty);
GetPointFor2Point3D(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2,Float:percent_size,&Float:tx,&Float:ty,&Float:tz);
ShiftVectorToRotation(Float:vx,Float:vy,Float:vz,&Float:rx,&Float:rz);
ShiftRotationToVector(Float:rx,Float:rz,&Float:vx,&Float:vy,&Float:vz);
bool:IsPointBetween2Points2D(Float:px,Float:py,Float:xA,Float:yA,Float:xB,Float:yB);
bool:IsPointBetween2Points3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB);
bool:IsPointNearly2Points2D(Float:px,Float:py,Float:xA,Float:yA,Float:xB,Float:yB,Float:maxdist);
bool:IsPointNearly2Points3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:maxdist);
bool:IsPointInCylinder(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:maxdist);
bool:IsProbable(chance);
GetGroundRotation(Float:x,Float:y,Float:size,&Float:rx,&Float:ry);
GetPointInFrontOnGround(Float:x,Float:y,Float:z,Float:rx,Float:rz,&Float:tx,&Float:ty,&Float:tz,Float:max_distance);
Float:GetPlayerTargetAngle(playerid,Float:x,Float:y,&Float:rz=0.0);
Float:SetPlayerTargetAngle(playerid,Float:x,Float:y,&Float:rz=0.0);
Deprecated Functions:
GetXYInFrontOfPlayer -> GetPointInFrontOfPlayer
GetPointInFront
-> GetPointInFront3D
GetPointInFrontOfCamera
-> GetPointInFrontOfCamera3D
GetDistanceBetweenPoints 
-> GetDistanceBetweenPoints3D
Old prototype
:
GetAngle -> GetPlayerTargetAngle SetPlayerTargetAngle GetRotationFor2Point2D 
Reply
#19

@AbyssMorgan: You really should be using "Float:0"... That compiles as "float(0)". It's best to just use "0.0", which compiles as "0.0".
Reply
#20

Quote:
Originally Posted by Crayder
Посмотреть сообщение
@AbyssMorgan: You really should be using "Float:0"... That compiles as "float(0)". It's best to just use "0.0", which compiles as "0.0".
okay, this will change
Reply


Forum Jump:


Users browsing this thread: