Library 3DTryg - Printable Version

Code:
3DTryg.inc



 Copyright ? 2021 Abyss Morgan. All rights reserved.



 Contributors: Crayder, IllidanS4, Nero_3D, RyDeR, Zoutdaxv, hesambia, Neil Lamoureux, Ivan_Ino, Ralfie, Unrea1, Katarina Calzaghe, $continue$



 Mr.Reus







 Website: https://adm.ct8.pl







 Plugins: ColAndreas, YSF, Streamer, FCNPC, VehicleStreamer



 Internal Modules: Actor, VehicleCollision, PlayerCollision, ActorCollision, Draw3D, CatchItems, GrenadeDetection







 File Version: 5.3.0



 ColAndreas Version: 1.5.0



 YSF Version: R19 (kurta999)



 Streamer Version: 2.9.5



 VehicleStreamer Version: 2.9.4



 FCNPC Version: 2.0.0







 Foreach Types:



 1. FoxForeach



 2. StandaloneForeach



 3. YSI Foreach



 4. GetPlayerPoolSize







 Compiler Options:



 DISABLE_3D_TRYG_INIT            //Use before 3DTryg.inc for disable ColAndreas Auto Init



 DISABLE_3D_TRYG_ACTOR           //Use before 3DTryg.inc for disable Actors Module



 DISABLE_3D_TRYG_FOREACH_FOX     //Use before 3DTryg.inc for disable FoxForeach Module



 DISABLE_3D_TRYG_FOREACH_STAND   //Use before 3DTryg.inc for disable StandaloneForeach Module



 DISABLE_3D_TRYG_FOREACH_YSI     //Use before 3DTryg.inc for disable YSI Foreach 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



 ENABLE_3D_TRYG_YSI_SUPPORT      //Use before 3DTryg.inc for enable YSI Support (use only when 3DTryg say error for this)



 ENABLE_3D_TRYG_DRAW3D           //Use before 3DTryg.inc for enable Draw3D Module



 ENABLE_3D_TRYG_CATCH_ITEMS      //Use before 3DTryg.inc for enable CatchItems Module



 ENABLE_3D_TRYG_GRENADEDETECTION //Use before 3DTryg.inc for enable GrenadeDetection Module



 ENABLE_3D_TRYG_VEHICLECOL       //Use before 3DTryg.inc for enable VehicleCollision Module



 ENABLE_3D_TRYG_PLAYERCOL        //Use before 3DTryg.inc for enable PlayerCollision Module



 ENABLE_3D_TRYG_ACTORCOL         //Use before 3DTryg.inc for enable ActorCollision Module



 



 Complementary Functions:



 Float:sqrtN(Float:value,Float:exponent);



 abs(value);



 Float:fabs(Float:value);



 power(value,Float:exponent);



 IsEven(value);



 Float: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);



 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);



 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);



 IsProbable(chance);



 IsProbableEx(chance,poolsize); //by default IsProbable using 100



 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);



 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);



 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[][2],maxpoints=sizeof(points));



 Float:GetLineSize3D(Float:points[][3],maxpoints=sizeof(points));



 IsVehicleInRangeOfPoint(vehicleid,Float:range,Float:x,Float:y,Float:z);



 IsActorInRangeOfPoint(actorid,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[][3],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);



 Float:GetDistanceFromPointToLineEx(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);



 GetNearest2DPointOnPolygon(const Float:polygon_points[],Float:x,Float:y,&Float:tx,&Float:ty,maxpoints = sizeof(polygon_points));



 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);



 bool:IsPolygonClosed(const Float:points[],maxpoints = sizeof(points));



 bool:IsValidPolygon(const Float:points[],maxpoints = sizeof(points));



 Tryg3D::GetOrientation(Float:angle);



 Tryg3D::GetOrientationName(orientation_name[],Float:angle,bool:as_compass=false,maxdest = sizeof(orientation_name));



 



 Cast3D functions:



 Cast3D::Explosion(Float:x,Float:y,Float:z,type,Float:radius,worldid=-1,interiorid=-1,playerid=-1,Float:distance=200.0);



 Cast3D::ExplosionDMG(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,ignore_vehicle = INVALID_VEHICLE_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);



 Cast3D::ExplosionRangeDMG(Float:x,Float:y,Float:z,type,Float:radius,worldid = -1,interiorid = -1,playerid = -1,Float:distance = 200.0,Float:min_damage=10.0,Float:max_damage=82.5,Float:min_vehicle_damage=50.0,Float:max_vehicle_damage=250.0,byplayerid=INVALID_PLAYER_ID,ignore_vehicle = INVALID_VEHICLE_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);



 Cast3D::Damage(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);



 Cast3D::Gravity(Float:x,Float:y,Float:z,Float:radius,Float:power = 1.0,worldid = -1,interiorid = -1,playerid = -1,byplayerid = INVALID_PLAYER_ID);



 



 Area check functions:



 Area::PointInCircle(Float:px,Float:py,Float:x,Float:y,Float:radius);



 Area::PointInCylinder2D(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:minz,Float:maxz,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::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::PointInCone2D(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b);



 Area::PointInCone3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius_a,Float:radius_b);



 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,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_OBJECT);



 



 Area get random point functions (IN)



 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), max_iterations = 10000);



 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::PointInCone2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b,&Float:tx,&Float:ty,&Float:tz)



 Random::PointInCone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius_a,Float:radius_b,&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);



 



 Area get random point functions (ON)



 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:radius_a,Float:radius_b,&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);



 



 Universal Functions:



 Item::GetInvalidID(Item3D_Type:item_type);



 Item::GetPos(elementid,Item3D_Type:element_type,&Float:x,&Float:y,&Float:z);



 Item::GetVirtualWorld(elementid,Item3D_Type:element_type);



 Item::GetInterior(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::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::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:testVW=true,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_OBJECT);



 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,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_OBJECT);



 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::InCone2D(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b);



 Item::InCone3D(elementid,Item3D_Type:element_type,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius_a,Float:radius_b);



 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::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);



 Item::InRangeOfPoint(Float:x,Float:y,Float:z,Float:range,targetid,Item3D_Type:target_type=item_player,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);



 Item::IsPlayerInRange(playerid,Float:range,targetid,Item3D_Type:target_type=item_player,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);



 Item::InRangeOfItem(elementid,Item3D_Type:element_type,Float:range,targetid,Item3D_Type:target_type=item_player,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);



 



 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::GetOrientationPosCol(elementid,Item3D_Type:element_type,element_orientation:orientation,Float:distance,&Float:tx,&Float:ty,&Float:tz);



 Item::IsPointInWaterOrient(elementid,Item3D_Type:element_type,Float:radius,element_orientation:orientation=o_front);



 Item::CollisionToPoint(Float:x,Float:y,Float:z,targetid,Item3D_Type:target_type,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_ALL);



 Item::CollisionToItem(elementid,Item3D_Type:element_type,targetid,Item3D_Type:target_type,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_ALL);



 







 Universal Functions (Streamer):



 Item::InDynamicArea(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));



 



 Draw3D Module functions:



 Draw3D::Circle3D(Float:x,Float:y,Float:z,Float:radius,Float:points[][3],max_sector = 36,Float:rx = 90.0,Float:ry = 0.0,max_points = sizeof(points));



 Draw3D::Cylinder3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,Float:points[][3],max_sector = 36,max_circles = 5,max_points = sizeof(points));



 Draw3D::Sphere(Float:x,Float:y,Float:z,Float:radius,Float:points[][3],max_sector = 36,max_circles = 5,max_points = sizeof(points));



 Draw3D::Cone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,Float:points[][3],max_sector = 36,max_circles = 5,max_points = sizeof(points));



 Draw3D::Rectangle2D(Float:minx,Float:miny,Float:maxx,Float:maxy,Float:points[][2],points_per_wall = 36,max_points = sizeof(points));



 Draw3D::Cube2D(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz,Float:points[][3],points_per_wall = 36,max_points = sizeof(points));



 Draw3D::Polygon2D(const Float:polygon_points[],Float:points[][2],points_per_line = 36,max_polygon_points = sizeof(polygon_points),max_points = sizeof(points));



 



 Catch Module functions:



 CatchItems::Circle(Float:x,Float:y,Float:radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::Cylinder2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::Cylinder3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::Sphere(Float:x,Float:y,Float:z,Float:radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::Rectangle(Float:minx,Float:miny,Float:maxx,Float:maxy,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::StreamCube(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::Polygon(const Float:points[],Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list),maxpoints = sizeof(points));



 CatchItems::CircularSector(Float:x,Float:y,Float:rz,Float:radius,Float:view_angle,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::SphericalSector(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::Cone2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::Cone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:pointA_radius,Float:pointB_radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::Cube3D(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::Ellipse(Float:cx,Float:cy,Float:size_x,Float:size_y,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::EllipticalCylinder2D(Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::SphericalSectorEx(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,Item3D_Type:element_type,element_list[],ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_OBJECT,worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::PointInStream(Float:x,Float:y,Float:z,const Stream:AreaData[Stream3D]);



 CatchItems::InStream(TRYG3D_ELEMENT_TAG:elementid,Item3D_Type:element_type,const Stream:AreaData[Stream3D],worldid = -1,interiorid = -1);



 CatchItems::GetInStream(const Stream:AreaData[Stream3D],Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));



 CatchItems::GetStreamType(Stream:data);



 CatchItems::IsValidStream(Stream:data);



 



 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);



 Tryg3D::GetRotationMatrixEulerEx(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);



 Tryg3D::EulerRotateEx(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);



 



 PlayerCollision Functions:



 IsPlayerCollisionEnabled();



 Tryg3D::InitPlayerCollision(); //OnGameModeInit / OnFilterScriptInit



 Tryg3D::ExitPlayerCollision();



 Tryg3D::SyncPlayerCollision(playerid); //auto called after player spawn



 IsToggledPlayerCollision(playerid);



 TogglePlayerCollision(playerid,bool:toggle);



 



 ActorCollision Functions:



 IsActorCollisionEnabled();



 Tryg3D::InitActorCollision(); //OnGameModeInit / OnFilterScriptInit



 Tryg3D::ExitActorCollision();



 Tryg3D::SyncActorCollision(actorid); //After create/change actor position



 IsToggledActorCollision(actorid);



 ToggleActorCollision(actorid,bool:toggle);



 



 Extended Functions:



 randomex(min,max);



 Tryg3D::GetErrorCount();



 Tryg3D::ResetErrorCount();



 Tryg3D::SetStreamDistance(Float:streamdistance); //default 300.0



 Tryg3D::GetStreamDistance();



 Tryg3D::GetActiveCount();



 Tryg3D::GetVersion(value);



 Tryg3D::KeyPressed(key);



 Tryg3D::KeyReleased(key);



 Tryg3D::KeyHolding(key);



 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



 



 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);



 



 Streamer Functions:



 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);



 



 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);



 GetPointCollisionFlags(Float:x,Float:y,Float:z,interiorid=0);



 IsCollisionFlag(value,flag);



 UndergroundFindZ(Float:x,Float:y,&Float:z);



 InteriorFindZ(Float:px,Float:py,Float:pz,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);



 SetPlayerCameraDirectionLookAt(playerid,Float:x,Float:y,Float:z,Float:distance = 5.0,Float:rx=20.0,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);



 ColAndreas::FindGroundZ(Float:x,Float:y,Float:z,&Float:gZ);



 Tryg3D::CollisionCheck(Float:StartX,Float:StartY,Float:StartZ,Float:EndX,Float:EndY,Float:EndZ,&Float:x,&Float:y,&Float:z,&Item3D_Type:item_type=Item3D_Type:0,&element_id=0,Float:cut_size=0.0,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_ALL);







 ColAndreas Extended Functions:



 Tryg3D::IsColAndreasInit();



 Tryg3D::SafeColAndreasInit();



 



 ColAndreas Callbacks:



 OnColAndreasRemoveBuilding();



 



 Grenade Detection Callbacks (ColAndreas):



 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::SetAbsolutePosition(npcid,Float:x,Float:y,Float:z,Float:angle,worldid=-1,interiorid=-1,compensatedtime=-1,freezeplayer=1);



 FCNPC::SetFloorPos(npcid);



 



 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);



 GetDynamicVehicleRotation(vehicleid,&Float:rx,&Float:ry,&Float:rz);







 Deprecated Functions:



 GetDistanceBetweenPoints       -> GetDistanceBetweenPoints3D



 GetPlayersDistance             -> Item::GetDistance



 GetVehiclesDistance            -> Item::GetDistance



 GetObjectsDistance             -> Item::GetDistance



 GetActorDistanceFromPoint      -> Item::GetDistanceFromPoint



 GetDistanceBetweenPlayers      -> Item::GetDistance



 GetDistanceBetweenVehicles     -> Item::GetDistance



 GetDistanceBetweenObjects      -> Item::GetDistance



 GetPlayerActorDistance         -> Item::GetDistance



 GetPlayerVehicleDistance       -> Item::GetDistance



 GetPlayerObjectDistance        -> Item::GetDistance



 IsPlayerInCircle               -> Item::In...



 IsPlayerInSphere               -> Item::In...



 IsPlayerInRectangle            -> Item::In...



 IsPlayerInCube                 -> Item::In...



 IsPlayerInPolygon              -> Item::In...



 GetPlayerCollisionFlags        -> Item::GetCollisionFlags



 GetVehicleCollisionFlags       -> Item::GetCollisionFlags



 IsPointInWaterFrontOfPlayer    -> Item::IsPointInWaterOrient



 MovePointColWithVehicle        -> Tryg3D::CollisionCheck



 MovePointColWithVehicleCut     -> Tryg3D::CollisionCheck



 Item::ToPointIsVeh             -> Item::CollisionToPoint



 Item::ToItemIsVeh              -> Item::CollisionToItem







 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          - (modifiable)



 CHARACTER_GROUND_Z_DIFF        - (modifiable)



 TRYG3D_MAX_AREA_CHECK          - Define area check limit when using Vehicle/Player/Actor collision system (modifiable)



 TRYG3D_RANDOM_MAX_ANGLE



 WEAPON_DYNAMIC_EXPLOSION_DMG   - deatch reason by using Cast3D::ExplosionDMG



 WEAPON_DYNAMIC_EXPLOSION_RANGE - deatch reason by using Cast3D::ExplosionRangeDMG



 



 Position Flags:



 POSITION_FLAG_WORLD



 POSITION_FLAG_INTERIOR



 POSITION_FLAG_AIR



 POSITION_FLAG_GROUND



 POSITION_FLAG_WATER



 POSITION_FLAG_UNDERWATER



 POSITION_FLAG_UNDERGROUND



 



 Tryg3D::CollisionCheck Flags:



 TRYG3D_COLLISION_FLAG_NONE



 TRYG3D_COLLISION_FLAG_OBJECT



 TRYG3D_COLLISION_FLAG_VEHICLE



 TRYG3D_COLLISION_FLAG_PLAYER



 TRYG3D_COLLISION_FLAG_ACTOR



 TRYG3D_COLLISION_FLAG_ALL







 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



 # o_front_left              - Orientation Front left (diagonal)



 # o_front_right             - Orientation Front right (diagonal)



 # o_back_left               - Orientation Back left (diagonal)



 # o_back_right              - Orientation Back right (diagonal)







 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 'StreamType'



 # s_invalid



 # s_circle



 # s_cylinder2d



 # s_cylinder3d



 # s_sphere



 # s_rectangle



 # s_cube2d



 # s_cube3d



 # s_polygon



 # s_circularsector



 # s_sphericalsector



 # s_cone2d



 # s_cone3d



 # s_ellipse



 # s_ellipticalcyl2d



 # a_sphericalsectorex







 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 '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 'T3D:eulermode'



 # T3D:euler_xzx - Proper / Classic Euler angles



 # T3D:euler_xyx - Proper / Classic Euler angles



 # T3D:euler_yxy - Proper / Classic Euler angles



 # T3D:euler_yzy - Proper / Classic Euler angles



 # T3D:euler_zyz - Proper / Classic Euler angles



 # T3D:euler_zxz - Proper / Classic Euler angles



 # T3D:euler_xzy - Tait-Bryan angles



 # T3D:euler_xyz - Tait-Bryan angles



 # T3D:euler_yxz - Tait-Bryan angles



 # T3D:euler_yzx - Tait-Bryan angles



 # T3D:euler_zyx - pitch roll yaw



 # T3D:euler_zxy - sa-mp