open.mp forum   ›   SA-MP   ›   Releases   ›   Libraries   ›   [Library] 3DTryg

  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
[Library] 3DTryg
AbyssMorgan
Burgershot Member
Joined: Apr 2021
Posts: 63

Reputation: 8

Location: Poland
#1
2021-04-18, 07:24 AM (This post was last modified: 2021-09-19, 04:10 PM by AbyssMorgan. Edit Reason: Update v5.3.0 )
Include contain professional functions for manipulating (coordinates / rotations / vectors / arc / areas / offset) supported (2D / 3D)



Videos:

- Knife Shoot

- EngineV6

- EngineX

- Missile Launch

- Vehicle Missile Launch (ColAndreas Version)

- GetGroundRotation

- GetPlayerCollisionFlags (ColAndreas)

- Marica Mortar V1

- Heavy Marica Mortar

- Acid Renia (FCNPC)

- Beta Interceptor (FCNPC)

- GoToPlayerOnGroundCol (FCNPC)

- IsElementOnPlayerScreen (ColAndreas)

- Arc Points

- Missile Launcher Aim Player

- GetRandomPointOnSphericalSector

- Vehicle Missile Congreve Rocket

- Magic Wand

- Vehicle Parachute

- Portal Gun #1

- Portal Gun #2

- Marica Mortar V2

- Stingers (Cops and Robbers)

- NPC Driver Eye

- PET SAR v1.0

- Vehicle Speed Control

- Prototype Grenade Detection



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



Download:

3DTryg.inc



More functions available with plugins:

ColAndreas (Recommended 1GB RAM for server by using this plugin)

YSF

Streamer

FCNPC

VehicleStreamer



Compatibility includes:

rotation.inc by Nero_3D

i_quat.inc by IllidanS4

YSI Libraries (with #define ENABLE_3D_TRYG_YSI_SUPPORT if you got error)



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

- Cone2D



b) Chunk:

- Cylinder2D

- Sphere

- Cube

- EllipticalCylinder2D



c) Rotated Chunk:

- Cylinder3D

- SphericalSector

- Cube3D

- Cone3D
  Website
  Reply
Pinch
Burgershot Member
Joined: Apr 2019
Posts: 392

Reputation: 22

Location: Belgrade, Serbia
#2
2021-04-18, 02:48 PM
One of the most useful libraries out there.
Using Pawn.CMD?

If you're doing so, this is the very first sign that you absolutely shouldn't utilize your all powerful P-Code knowledge in any of the scripting discussion topics.
  Website
  Reply
AbyssMorgan
Burgershot Member
Joined: Apr 2021
Posts: 63

Reputation: 8

Location: Poland
#3
2021-05-01, 01:24 PM
Update v5.0.0:



- Fixed functions:

Code:
Random::PointInCylinder3D

Tryg3D::RandomFloat(Float:min,Float:max,accuracy=4);

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

Item::OnPlayerScreen(playerid,TRYG3D_ELEMENT_TAG: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); //fixed orientations



- New random alghoritm has been tested by Area:: test and with Draw3D:: functions



- Some deprecated functions alias removed



- Added Draw3D functions (available only after #define ENABLE_3D_TRYG_DRAW3D before include 3DTryg)

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



- Added functions:

Code:
Random::PointInCone2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b,&Float:tx,&Float:ty,&Float:tz);

Area::PointInCone2D(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b);

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



- Added new orientations:

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



- Updated functions for new orientations:

Code:
Item::OnPlayerScreen(playerid,TRYG3D_ELEMENT_TAG: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::GetOrientationPos(TRYG3D_ELEMENT_TAG:elementid,Item3D_Type:element_type,element_orientation:orientation,Float:distance,&Float:tx,&Float:ty,&Float:tz);

Item::GetOrientationPosCol(elementid,Item3D_Type:element_type,element_orientation:orientation,Float:distance,&Float:tx,&Float:ty,&Float:tz);



- Renamed function:

Code:
Item::InCone -> Item::InCone3D



- Added macro:

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



- Added definitions:

Code:
CHARACTER_GROUND_Z_DIFF

TRYG3D_RANDOM_MAX_ANGLE



- Example Draw3D::Polygon2D

Code:
new Float:zones_points_0[] = {

10.0,36.0,20.0,67.0,81.0,29.0,73.0,-45.0,10.0,36.0

}; //SAMP Zone Editor



new Float:points[1000][2], point_count = Draw3D::Polygon2D(zones_points_0,points,16);

for(new i = 0; i < point_count; i){

CreateDynamicObject(19197,points[i][0],points[i][1],5.0,0.0,0.0,0.0);

}



Screenshots:

https://imgur.com/a/ZBzVmpi
  Website
  Reply
AbyssMorgan
Burgershot Member
Joined: Apr 2021
Posts: 63

Reputation: 8

Location: Poland
#4
2021-05-05, 07:52 PM
Update v5.1.0:



- Renamed bad YSIFOREACH detection to standalone foreach detection



- Added YSI Foreach detection (applying for every script using 3DTryg)



- Added universal function:

Code:
Item::GetInterior(TRYG3D_ELEMENT_TAG:elementid,Item3D_Type:element_type);



- Added CatchItems functions (available only after #define ENABLE_3D_TRYG_CATCH_ITEMS before include 3DTryg):

Code:
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,bool:testLOS,bool:veh_col,Item3D_Type:element_type,element_list[],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);





- Example CatchItems using:

Code:
new Float:zones_points_0[] = {

10.0,36.0,20.0,67.0,81.0,29.0,73.0,-45.0,10.0,36.0

};



new element_list[250], item_count;



item_count = CatchItems::Polygon(zones_points_0,item_player,element_list,-1,-1,sizeof(element_list),sizeof(zones_points_0));

for(new i = 0; i < item_count; i){

SendClientMessage(element_list[i],0xFFFFFFFF,"Deatch has found you");

SetPlayerHealth(element_list[i],0.0);

}



item_count = CatchItems::Polygon(zones_points_0,item_dynamic_object,element_list,-1,-1,sizeof(element_list),sizeof(zones_points_0));

for(new i = 0; i < item_count; i){

DestroyDynamicObject(STREAMER_TAG_OBJECT:element_list[i]);

}



- Updated loading logs example:

Code:
[ADM] Info: Load 3DTryg v5.1.0 for SA:MP 0.3 DL by Abyss Morgan

[ADM] Info: Load 3DTryg Modules: ColAndreas v1.4.0, Streamer v2.9.4, Actor, VehicleCollision, Draw3D, CatchItems
  Website
  Reply
Radical
Burgershot Member
Joined: Dec 2020
Posts: 176

Reputation: 17
#5
2021-05-25, 11:18 PM (This post was last modified: 2021-05-25, 11:19 PM by Radical.)
Item::IsPointInWaterOrient function is not woking for me.
If water in 3 m of player front it's not detecting.
I use colandreas and it loaded 100%,?I don't know what's wrong.

Code:
if(!PlayerFishing[playerid]) {
? ? if(!Item::IsPointInWaterOrient(playerid,item_player,3.0,o_front)) return 0;
? ? PlayerFishing[playerid] = 1;
? ? GameTextForPlayer(playerid, "~w~Fishing...", 5000, 4);
}
  Reply
AbyssMorgan
Burgershot Member
Joined: Apr 2021
Posts: 63

Reputation: 8

Location: Poland
#6
2021-05-26, 03:28 PM
(2021-05-25, 11:18 PM)Radical Wrote: Item::IsPointInWaterOrient function is not woking for me.

If water in 3 m of player front it's not detecting.

I use colandreas and it loaded 100%,?I don't know what's wrong.



Code:
if(!PlayerFishing[playerid]) {

? ? if(!Item::IsPointInWaterOrient(playerid,item_player,3.0,o_front)) return 0;

? ? PlayerFishing[playerid] = 1;

? ? GameTextForPlayer(playerid, "~w~Fishing...", 5000, 4);

}



Funcion work, howerer 3.0 radius is to small for fishing as you can see on video:

https://www.youtube.com/watch?v=Y-CdLwk8eOw
  Website
  Reply
Radical
Burgershot Member
Joined: Dec 2020
Posts: 176

Reputation: 17
#7
2021-05-30, 09:28 PM
(2021-05-26, 03:28 PM)AbyssMorgan Wrote:
(2021-05-25, 11:18 PM)Radical Wrote: Item::IsPointInWaterOrient function is not woking for me.

If water in 3 m of player front it's not detecting.

I use colandreas and it loaded 100%,?I don't know what's wrong.



Code:
if(!PlayerFishing[playerid]) {

? ? if(!Item::IsPointInWaterOrient(playerid,item_player,3.0,o_front)) return 0;

? ? PlayerFishing[playerid] = 1;

? ? GameTextForPlayer(playerid, "~w~Fishing...", 5000, 4);

}



Funcion work, howerer 3.0 radius is to small for fishing as you can see on video:

https://www.youtube.com/watch?v=Y-CdLwk8eOw



This problem is solved, but I can fish even when I am in the water. Why?
  Reply
AbyssMorgan
Burgershot Member
Joined: Apr 2021
Posts: 63

Reputation: 8

Location: Poland
#8
2021-06-03, 06:14 AM (This post was last modified: 2021-06-03, 06:15 AM by AbyssMorgan.)
(2021-05-30, 09:28 PM)Radical Wrote:
(2021-05-26, 03:28 PM)AbyssMorgan Wrote:
(2021-05-25, 11:18 PM)Radical Wrote: Item::IsPointInWaterOrient function is not woking for me.

If water in 3 m of player front it's not detecting.

I use colandreas and it loaded 100%,?I don't know what's wrong.



Code:
if(!PlayerFishing[playerid]) {

? ? if(!Item::IsPointInWaterOrient(playerid,item_player,3.0,o_front)) return 0;

? ? PlayerFishing[playerid] = 1;

? ? GameTextForPlayer(playerid, "~w~Fishing...", 5000, 4);

}



Funcion work, howerer 3.0 radius is to small for fishing as you can see on video:

https://www.youtube.com/watch?v=Y-CdLwk8eOw



This problem is solved, but I can fish even when I am in the water. Why?



Code:
if(!PlayerFishing[playerid]){

    if(!Item::IsPointInWaterOrient(playerid,item_player,3.0,o_front)) return 0;

    if(!IsCollisionFlag(Item::GetCollisionFlags(playerid,itme_player),POSITION_FLAG_GROUND)) return 0;

    PlayerFishing[playerid] = 1;

    GameTextForPlayer(playerid, "~w~Fishing...", 5000, 4);

}
  Website
  Reply
AbyssMorgan
Burgershot Member
Joined: Apr 2021
Posts: 63

Reputation: 8

Location: Poland
#9
2021-09-17, 08:22 PM
Update v5.2.0:



- Removed functions (due to has no expected effect):

Code:
SetPlayerLookAtPlayer(playerid,targetid,cut=CAMERA_CUT);

SetPlayerCameraRotation(playerid,Float:rx,Float:rz);

SetPlayerCameraZAngle(playerid,Float:rz);



- Renamed functions:

Code:
Tryg3D::GetRotationMatrixEuler -> Tryg3D::GetRotationMatrixEulerEx

Tryg3D::EulerRotate -> Tryg3D::EulerRotateEx

GetVehicleDefaultFlagsByModel -> GenerateVehicleDefaultFlags



- Added functions:

Code:
GetVehicleDefaultFlagsByModel(modelid); //optimized

Tryg3D::GetRotationMatrixEuler(Float:matrix[][],Float:rx,Float:ry,Float:rz); //simple version of Tryg3D::GetRotationMatrixEulerEx

Tryg3D::EulerRotate(Float:rX,Float:rY,Float:rZ,Float:oX,Float:oY,Float:oZ,&Float:tx,&Float:ty,&Float:tz); //simple version of Tryg3D::EulerRotateEx



- Added options:

Code:
ENABLE_3D_TRYG_GRENADEDETECTION //Use before 3DTryg.inc for enable Grenade detection feature (Callback: OnPlayerDroppingGrenade)



- Optimizations



- Update for Streamer v2.9.5



Update v5.2.1:



- Add returning objectid from ColAndreas::RayCastLine inside functions:

Code:
ColAndreas::FindGroundZ

MovePointCol

MovePointColCutLine

MovePointColCutLineEx

GetPointInFront3DCol

GetPointInFront3DColEx

Item::GetOrientationPosCol - return -1 if fail
  Website
  Reply
AbyssMorgan
Burgershot Member
Joined: Apr 2021
Posts: 63

Reputation: 8

Location: Poland
#10
2021-09-19, 04:10 PM (This post was last modified: 2021-09-19, 06:48 PM by AbyssMorgan.)
Update v5.3.0:



- Added definitions:

Code:
WEAPON_DYNAMIC_EXPLOSION_DMG - Cast3D::ExplosionDMG

WEAPON_DYNAMIC_EXPLOSION_RANGE - Cast3D::ExplosionRangeDMG

TRYG3D_MAX_AREA_CHECK - define area check limit when using Vehicle/Player/Actor collision



TRYG3D_COLLISION_FLAG_NONE

TRYG3D_COLLISION_FLAG_OBJECT

TRYG3D_COLLISION_FLAG_VEHICLE

TRYG3D_COLLISION_FLAG_PLAYER

TRYG3D_COLLISION_FLAG_ACTOR

TRYG3D_COLLISION_FLAG_ALL



- Added compiler options

Code:
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



- Renamed functions:

Code:
CreateDynamicExplosion -> Cast3D::Explosion

CreateDynamicExplosionDMG -> Cast3D::ExplosionDMG

SendFakeDamageInRadius -> Cast3D::Damage

SendGravityInRadius -> Cast3D::Gravity



- Added functions:

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

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



//Created by $continue$, Nero_3D (It can work outside the cylinder, use GetDistanceFromPointToLine if you need check only in cylinder)

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



//Created by $continue$

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



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



Tryg3D::GetOrientation(Float:angle);

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



- Added ColAndreas functions:

Code:
//example: collision_flags = TRYG3D_COLLISION_FLAG_OBJECT  TRYG3D_COLLISION_FLAG_VEHICLE

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



Item::CollisionToPoint(Float:x,Float:y,Float:z,TRYG3D_ELEMENT_TAG: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(TRYG3D_ELEMENT_TAG:elementid,Item3D_Type:element_type,TRYG3D_ELEMENT_TAG: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);



- Updated functions:

Code:
Random::PointInPolygon(const Float:points[],&Float:tx,&Float:ty,maxpoints = sizeof(points), max_iterations = 10000); //return -1 if polygon is invalid or iteration limit exceeded



// added collision params

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



//syntax changed, now return collision objectid

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



//syntax changed, now return collision objectid

InteriorFindZ(Float:px,Float:py,Float:pz,Float:size=2.0,&Float:z=0.0);



//return number of points

GetArcPoints3D(...);



//removed testLOS and veh_col arguments, added new collision engine support (default dont check collisions), function may be used without ColAndreas

Item::InRangeOfPoint(Float:x,Float:y,Float:z,Float:range,TRYG3D_ELEMENT_TAG: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);

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

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

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



- Added PlayerCollision Functions:

Code:
IsPlayerCollisionEnabled();

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

Tryg3D::ExitPlayerCollision();

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

IsToggledPlayerCollision(playerid);

TogglePlayerCollision(playerid,bool:toggle);



- Added ActorCollision Functions:

Code:
IsActorCollisionEnabled();

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

Tryg3D::ExitActorCollision();

Tryg3D::SyncActorCollision(actorid); //Must be call after create/change actor position

IsToggledActorCollision(actorid);

ToggleActorCollision(actorid,bool:toggle);



- Added polygon validations



- Added auto closing polygons in functions



- Removed compiler options:

Code:
DISABLE_3D_TRYG_VEHICLECOL



- Fixed collision sync after init



- Fixed functions:

Code:
Draw3D::Cube2D - bad distance betwen vertical points



- Marked functions as deprecated:

Code:
MovePointColWithVehicle? ? ? ? -> Tryg3D::CollisionCheck

MovePointColWithVehicleCut? ? -> Tryg3D::CollisionCheck

Item::ToPointIsVeh? ? ? ? ? ? -> Item::CollisionToPoint

Item::ToItemIsVeh? ? ? ? ? ? ? -> Item::CollisionToItem



- Removed deprecated macros:

Code:
GetArcPointsFloor2D

GetArcPointsCellar2D

GetArcPointsLarboard2D

GetArcPointsStarboard2D

GetArcPointsFloor3D

GetArcPointsCellar3D

GetArcPointsStarboard3D

GetArcPointsLarboard3D

IsPlayerInCircularSector

IsPlayerInCube3D

IsPlayerInEllipse

IsPlayerInEllipticalCylinder2D

IsPlayerInSphericalSector

IsPlayerInCylinder3D

IsPlayerInCylinder2D

IsObjectInRangeOfPoint

GetObjectDistanceFromPoint

IsDynamicObjectInRangeOfPoint

IsDynamicActorInRangeOfPoint



- Updated library compatibility (need redownload if you use):

Code:
EVF.inc

ExtendedGrenade.inc

Mines.inc

Missile.inc

Missions.inc

VehicleMissileCol.inc
  Website
  Reply
AbyssMorgan
Burgershot Member
Joined: Apr 2021
Posts: 63

Reputation: 8

Location: Poland
#11
2021-10-31, 10:41 AM
Update v5.3.1:



- Added callbacks:

Code:
OnPlayerGrenadeExplode(playerid,weaponid,Float:x,Float:y,Float:z); //called after OnPlayerDroppingGrenade for weaponid 16



- Added explosion protection for Cast3D::Explosion functions when explode radius is smaller than original explosion radius



- Optimizations
  Website
  Reply
Salik_Davince
Burgershot Member
Joined: Apr 2019
Posts: 4

Reputation: 0
#12
2022-04-24, 08:05 AM
Hi, I know that the project is practically not supported, but I would like to ask how to implement the rotation of an object and position relative to another object, i.e. group objects, I know that 3DTryg includes the following functions, but I am not strong in trigonometry: (yandex translator) -





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



* ShiftVectorToRotation(Float:vx,Float:vy,Float:vz,&Float:rx,&Float:rz);

* ShiftRotationToVector(Float:rx,Float:rz,&Float:vx,&Float:vy,&Float:vz);



* ShiftVectorRotation(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,&Float:tx,&Float:ty,&Float:tz);



* Item::GetRotationQuat(elementid,Item3D_Type:element_type,&Float:qw,&Float:qx,&Float:qy,&Float:qz);



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





----



And the second question in conclusion is how to set the angle of the player towards the object and set the angle (rotation) of the object towards the player, thank you for your help.!
  Reply


Forum Jump: