AlliedModders Wiki - User contributions [en]

AlliedModders Planning

2011-03-16T03:03:13Z

Seta00: /* Phase 7 */

__FORCETOC__

This is sort of a major push for AlliedModders to be a bit more streamlined. We're encountering growth problems, especially as our personnel has dwindled quite low recently. This document discusses some changes I'm proposing. Anyone is free to discuss this on the forums or add comments into this document.

Everything related to source code management in this document refers to Metamod:Source and SourceMod. AMX Mod X is considered "mature" and is no longer maintained except for critical or high priority bugs. If and when we do a move past Subversion, it is unlikely AMX Mod X will follow.

=The Problems=
==Short Term==
*We're finding it hard to manage multiple projects in a unified way.
*There are site disparities, Metamod:Source and SourceMod and AMX Mod X each have entirely different backends.
*Similarly, each site has a different version of the mirror system script.
*Subversion doesn't cut it -- Mercurial might handle things better. Subversion basically has no branching or tagging support, and it has no real branch merging capabilities. This is a real problem for SourceMod which has pretty active development.
*The packaging system is disorganized and fundamentally broken. It's inconsistent, inaccurate, and takes up 1.7GB of wasted space and growing.

==Long Term==
*AlliedModders has plans past SourceMod. We need to be able to grow our project base without adding exponential amounts of work.
*We still don't have a main site
*MediaWiki still has authentication problems since its handling of usernames is broken
*Flyspray is buggy, definitely non-production, and doesn't get maintained frequently
*It's impossible to maintain the AMXX/SM/MM:S sites right now

=Mercurial=
Subversion doesn't let us branch nicely or create user-specific branches without forever mucking up the central repository. It's difficult to do merges.

An excellent tutorial for how Mercurial works is [http://www.selenic.com/mercurial/wiki/index.cgi/UnderstandingMercurial here].

=Phases=

==Phase 0 - Done ==
'''DONE:''' We've eliminated build numbers and are back on the x.y.z system.

*<strike>Apply new versioning scheme, whatever it may be.</strike>

==Phase 1 - Done==
'''DONE!'''

<strike>Move from Sente to Iroh so we can get away from ThePlanet and clean up/optimize some infrastructure. This is documented at [[Iroh_Migration|Iroh Migration]].</strike>

==Phase 2==
Expected date: Mid-July

*<strike>Redo automation so the "packaging" versus "sending upstream" processes are fundamentally separate.</strike>
*<strike>Redo "sending upstream" process so it simply sends over FTP.</strike>
*<strike>Use an SSH tunnel to notify of new packages, so we don't have to do something idiotic like mirrors.pl for the mirror system, or using post-commit scripts on the Packages repository.</strike>
*Redo the package system so only 30 days worth of builds are available.
*<strike>Write a script to help users diff between packages? (Update: No one asked for it.)</strike>
*<strike>Remove the Packages repository entirely (transitioning AMX Mod X to this will be trivial).</strike>
*<strike>Update symbol server to include binaries and maybe even sourcecode? Removes the need for fetchdll's.</strike>

==Phase 3 - Done==
'''DONE!'''

*<strike>{{bz|3257}}: Transition SourceMod to vs2k8.</strike>
*<strike>{{bz|3258}}: Transition Metamod:Source to vs2k8.</strike>

==Phase 4 - Done==
'''DONE!'''

*<strike>Move the pdbstore to be centralized client-side. This can be accomplished by making a more advanced symstore wrapper that will remove anything older than 30 days, and then (in a similar SSH tunnel method as above), rsync all changes upstream to the webserver. The exact mechanism is still up in the air, but rsync would probably suffice (as long as we can stomach cygwin).</strike>
*<strike>Remove the Symbols repository.</strike>
*<strike>Rewrite fetchdlls to support the new layout.</strike>

==Phase 5 - Done==
'''DONE!'''

*<strike>Add hg.alliedmods.net pointing to our "repository roots," which will be per-project. For example, hg.alliedmods.net/sourcemod.</strike>
*<strike>From there, import trunk as "sourcemod."</strike>
*<strike>Branch every major release off as separate repositories, from the appropriate revisions.</strike>
*<strike>Tag minor releases.</strike>
*<strike>Update all links we can find on the site and in the docs.</strike>

==Phase 6 - Done==
'''DONE!'''

*<strike>Import mmsource into Mercurial.</strike>
*<strike>Import hl2sdk/hl2sdk-ob into Mercurial.</strike>
*<strike>Update all links we can find on the site and in the docs.</strike>

==Phase 7==
'''DONE!'''

*<strike>{{bz|3259}}: We need to update vBulletin to the 3.7 branch. This is potentially a huge task.</strike>

==Phase 8==
Expected date: Q1 2009

We really, really still need a CMS to make this packaging, mirroring, etc business much more streamlined. But this phase is so far in the future I expect other phases to creep in before it. This is more a mind dump than anything, but here goes --

*<strike>Moving from flyspray to bugzilla. After using bugzilla, I'm convinced that its massive feature set far outweights the few permissions issues we ran into. flyspray is severely lacking, and even though bugzilla isn't the nicest looking tool, it's templated and professionally done. It has little things that really count, like..</strike>
**<strike>The input system isn't broken and convoluted like Flyspray's embedded dokuwiki (which seems to be less a product than a bunch of bugs someone coded)</strike>
**<strike>A much, MUCH better attachment system that allows for attachment reviews
**More focused on triaging and patch management than flyspray, which is simply a list of tasks with some basic statistics</strike>
*Moving from MediaWiki, which (I view) as a very, very outdated piece of software. From version 1.5 to 1.10 I have noticed no real usability or feature set changes, and the installation/upgrade process is always very buggy for us. Its administration and permissions model is laughably limited. A possible target for this is DekiWiki which Mozilla is supposedly converting to. It's open source and it's actually a CMS, which (perhaps) could kill two birds with one stone.

Talk:FakeMeta Functions Detailed Descriptions

2010-09-07T16:48:20Z

Seta00: Created page with 'The original content is here: http://forums.alliedmods.net/showthread.php?t=93229 I've just converted the page to Wiki format. ~~~~'

The original content is here: http://forums.alliedmods.net/showthread.php?t=93229

I've just converted the page to Wiki format.

[[User:Seta00|Seta00]] 16:48, 7 September 2010 (UTC)

FakeMeta Functions Detailed Descriptions

2010-09-07T16:44:27Z

Seta00: Added EngFunc_AlertMessage

== Point Functions ==
=== EngFunc_PointContents ===
This function checks an origin and gives us information of its whearabouts.

The constants that this function returns are these:
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7 // Removed at csg time
#define CONTENTS_CLIP -8 // Changed to contents_solid
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
#define CONTENTS_LADDER -16
#define CONTENT_FLYFIELD -17
#define CONTENT_GRAVITY_FLYFIELD -18
#define CONTENT_FOG -19

==== Usage ====
<pawn>static Float:origin[3]
static result
result = engfunc(EngFunc_PointContents, origin)
// if for example result is CONTENTS_SKY
// then the origin that we see is in the sky we can for example use this to see where a player is aming if he is aiming at sky this will be the result! </pawn>

=== EngFunc_GetBonePosition ===
[[Image:PlayerSkeleton.jpg|frame|This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.]]
This function allows to get the bone positions of an entity. This is best used on getting specific player origin points.

These are the bones that a player has:

Bone 1 Name: "Bip01"
Bone 2 Name: "Bip01 Pelvis"
Bone 3 Name: "Bip01 Spine"
Bone 4 Name: "Bip01 Spine1"
Bone 5 Name: "Bip01 Spine2"
Bone 6 Name: "Bip01 Spine3"
Bone 7 Name: "Bip01 Neck"
Bone 8 Name: "Bip01 Head"
Bone 9 Name: "Bone01"
Bone 10 Name: "Bip01 L Clavicle"
Bone 11 Name: "Bip01 L UpperArm"
Bone 12 Name: "Bip01 L Forearm"
Bone 13 Name: "Bip01 L Hand"
Bone 14 Name: "Bip01 L Finger0"
Bone 15 Name: "Bip01 L Finger01"
Bone 16 Name: "Bip01 L Finger1"
Bone 17 Name: "Bip01 L Finger11"
Bone 18 Name: "-- L knuckle"
Bone 19 Name: "-- L Forearm twist"
Bone 20 Name: "-- L wrist"
Bone 21 Name: "-- L Elbow"
Bone 22 Name: "-- L bicep twist"
Bone 23 Name: "-- L shoulder outside"
Bone 24 Name: "-- L Shoulder inside"
Bone 25 Name: "Bip01 R Clavicle"
Bone 26 Name: "Bip01 R UpperArm"
Bone 27 Name: "Bip01 R Forearm"
Bone 28 Name: "Bip01 R Hand"
Bone 29 Name: "Bip01 R Finger0"
Bone 30 Name: "Bip01 R Finger01"
Bone 31 Name: "Bip01 R Finger1"
Bone 32 Name: "Bip01 R Finger11"
Bone 33 Name: "-- R knuckle"
Bone 34 Name: "-- R wrist"
Bone 35 Name: "-- R forearm twist"
Bone 36 Name: "-- R Elbow"
Bone 37 Name: "-- R bicep twist"
Bone 38 Name: "-- R Shoulder inside"
Bone 39 Name: "-- R shoulder outside"
Bone 40 Name: "-- Neck smooth"
Bone 41 Name: "-- R Butt"
Bone 42 Name: "-- L butt"
Bone 43 Name: "Bip01 L Thigh"
Bone 44 Name: "Bip01 L Calf"
Bone 45 Name: "Bip01 L Foot"
Bone 46 Name: "Bip01 L Toe0"
Bone 47 Name: "-- L ankle"
Bone 48 Name: "-- L Knee"
Bone 49 Name: "Bip01 R Thigh"
Bone 50 Name: "Bip01 R Calf"
Bone 51 Name: "Bip01 R Foot"
Bone 52 Name: "Bip01 R Toe0"
Bone 53 Name: "-- R Ankle"
Bone 54 Name: "-- R Knee"
Bone 55 Name: "Bomb"

==== Usage ====
<pawn>// ENTITY is the player entity id
// BONE_NUMBER you have to choose from the list above
// bone_origin[3] is the vector where we save the bone origin
// bone_angles[3] the vector that holds the angles of the bone.
engfunc(EngFunc_GetBonePosition, ENTITY, BONE_NUMBER, Float:bone_origin[3], Float:bone_angles[3])</pawn>

==== Useful Stocks ====
These stocks are made for CS/CZ, you need to port them to other mods.
===== get_bone_hitgroup =====
This gets the hitgroup of the bone:
<pawn>#define BONE_HIT_HEAD 8
#define BONE_HIT_CHEST 6
#define BONE_HIT_STOMACH 4
#define BONE_HIT_LEFTARM 24
#define BONE_HIT_RIGHTARM 39
#define BONE_HIT_LEFTLEG 48
#define BONE_HIT_RIGHTLEG 54
#define HEAD_NECK 40
#define BONE_L_BUTT 41
#define BONE_R_BUTT 42

stock get_bone_hitgroup(number)
{
switch (number)
{
case HEAD_NECK:
{
return HIT_HEAD
}
case BONE_L_BUTT:
{
return HIT_LEFTLEG
}
case BONE_R_BUTT:
{
return HIT_RIGHTLEG
}
}

if (1 <= number <= BONE_HIT_STOMACH)
return HIT_STOMACH

if (BONE_HIT_STOMACH < number <= BONE_HIT_CHEST)
return HIT_CHEST

if (BONE_HIT_CHEST < number <= BONE_HIT_HEAD)
return HIT_HEAD

if (BONE_HIT_HEAD < number <= BONE_HIT_LEFTARM)
return HIT_LEFTARM

if (BONE_HIT_LEFTARM < number <= BONE_HIT_RIGHTARM)
return HIT_RIGHTARM

if (BONE_HIT_RIGHTARM < number <= BONE_HIT_LEFTLEG)
return HIT_LEFTLEG

if (BONE_HIT_LEFTLEG < number <= BONE_HIT_RIGHTLEG)
return HIT_RIGHTLEG

return HIT_GENERIC
}</pawn>

===== find_closest_bone_to_gunshot =====
This gets the closest bone to the gunshot (Use this in FM_TraceLine and Ham_TraceAttack):
<pawn>#define DISTANCE_CLEAR_HIT 2.0

stock find_closest_bone_to_gunshot(victim, Float:endtrace[3])
{
new Float:angles[3], Float:origin[3], Float:dist = 9999999.99, Float:curorigin[3], bone_nr
for (new i=1;i<=54;i++)
{
// Get the bone position
engfunc(EngFunc_GetBonePosition, victim, i, curorigin, angles)
// Calculate the distance vector
xs_vec_sub(curorigin, endtrace, angles)

// If this is smaller than the last small distance remember the value!
if (xs_vec_len(angles) <= dist)
{
origin = curorigin
dist = xs_vec_len(angles)
bone_nr = i
}

// If distance is smaller than CLEARHIT! Break (We accept the last value!)
if (dist <= DISTANCE_CLEAR_HIT)
{
break
}
}

// Return the bone
return bone_nr
}</pawn>

== Messaging Functions ==
=== EngFunc_MessageBegin ===
This function is used to generate client messages.

==== Usage ====
Syntax:
<pawn>engfunc(EngFunc_MessageBegin, dest, msg_type, origin[3] = {0, 0, 0}, player = 0)</pawn>
Example:
<pawn>static Float:origin[3] // Origin should be a Float
pev(id, pev_origin, origin) // Get user origin
engfunc(EngFunc_MessageBegin,MSG_BROADCAST,SVC_TEMPENTITY,origin,0) // Create message</pawn>
With MSG_ONE_UNRELIABLE:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>
With MSG_ALL:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>

dest can be:

#define MSG_BROADCAST 0 // Unreliable to all, There is not id
#define MSG_ONE 1 // Reliable to one (msg_entity)
#define MSG_ALL 2 // Reliable to all, There is not origin
#define MSG_INIT 3 // Write to the init string
#define MSG_PVS 4 // Ents in PVS of org
#define MSG_PAS 5 // Ents in PAS of org
#define MSG_PVS_R 6 // Reliable to PVS
#define MSG_PAS_R 7 // Reliable to PAS
#define MSG_ONE_UNRELIABLE 8 // Send to one client, but don't put in reliable stream,
// put in unreliable datagram (could be dropped), there is not origin
#define MSG_SPEC 9 // Sends to all spectator proxies

'''Before calling another EngFunc_MessageBegin you must call message_end().'''

== Entity Search Functions ==
=== EngFunc_FindEntityInSphere ===
Find entities within a radius. '''The function returns the next entity id after the start entity.'''

[[Image:FindEntityInSphere.png|thumb|3D diagram to show how the function works.]]
If we use
<pawn>engfunc(EngFunc_FindEntityInSphere, -1, origin, radius)</pawn>
In the situation described on the picture the function call above will return 1,
<pawn>engfunc(EngFunc_FindEntityInSphere, 20, origin, radius)</pawn>
will return 30 and
<pawn>engfunc(EngFunc_FindEntityInSphere, 100, origin, radius)</pawn>
will return 0, meaning that it didn't find an entity with an id grater than 100.

==== Usage ====
<pawn>engfunc(EngFunc_FindEntityInSphere, ent_to_start, origin, radius)</pawn>

=== EngFunc_EntitiesInPVS ===

This function checks entities that are in the [[PVS]] of an entity.
'''It can't be used on worldspawn.'''

The function returns the first entity on the [[PVS]] and then you can traverse through the results using pev_chain/EV_ENT_chain.
A NULL value of pev_chain/EV_ENT_chain indicates the end of the chain.

==== Usage ====
<pawn>public whatisonPVS(id)
{
static next, chain
static class[32]

next = engfunc(EngFunc_EntitiesInPVS, id)
while(next)
{
pev(next, pev_classname, class, charsmax(class))
chain = pev(next, pev_chain)

server_print("Found entity in player (%i) PVS: ent(%i) class(%s)", id, next, class)

if(!chain)
break

next = chain
}
}</pawn>

=== EngFunc_FindEntityByString ===
Returns the first entity found that matches the search criteria.

You can use any of string type attributes of entities:

classname Type of entity
globalname This is the name of the global variable that can be used to control the state of the entity
model The model of the entity
target Entity that this entity is handling
targetname The name given to this entity that another entity searches for to handle it
netname Player or NPC name
message Seems to be used mainly to store sound (string). It happens to store others things, depending the need of the entity
noise Noise variables do different things for different ents
noise1 This is the move sound for doors
noise2 This is the stop sound for doors
noise3 This is for blocking game_player_equip and player_weaponstrip

==== Usage ====
<pawn>iEnt = engfunc(EngFunc_FindEntityByString, iStartEnt, sAttribute, sValue)</pawn>
Parameters:
* iStartEnt: Start searching on this entity (ex: 0 = worldspawn)
* sAttribute: Name of attribute over which we need to search (ex: classname)
* sValue: Text string that we are searching for (ex: func_breakable)

The function returns the first entity matching the criteria.

=== EngFunc_FindClientInPVS ===
Returns the next "player" entity in someone's [[PVS]] using a global loop.

==== Usage ====
<pawn>iEnt2 = engfunc(EngFunc_FindClientInPVS, iEnt)</pawn>
Parameters:
* iEnt Source entity. Seek someone within iEnt's [[PVS]]

Unlike [[#EngFunc_EntitiesInPVS|EntitiesInPVS]], it does not return a series of chained entities. Instead, it works like a global loop of entities.
No matter which source entity you use, this function maintains the last index used and returns the next entity in source entity [[PVS]].

This function must be called several times to find every entity in [[PVS]] and can also return the source entity but it can't be called twice inside the same function because it will return the same entity.

==== Notes ====
It's not clear the main purpose of this function because you can get similar results with [[#EngFunc_EntitiesInPVS|EntitiesInPVS]].

[[#EngFunc_CheckVisibility|CheckVisibility]] and [[#EngFunc_EntitiesInPVS|EntitiesInPVS]] are better functions to use.

== Trace Functions ==
=== EngFunc_TraceLine ===
This function traces between 2 origins and gives us information about it.

These are the constants we can use as flags:

#define DONT_IGNORE_MONSTERS 0
#define IGNORE_MONSTERS 1
#define IGNORE_MISSILE 2
#define IGNORE_GLASS 0x100

'''These constants can be used together.'''

Ex: IGNORE_MISSILE | IGNORE_MONSTERS | IGNORE_GLASS - This makes the traceline ignore missiles, monsters (players) and glass.

==== Usage ====

Example of doing a traceline between two origins, and ignoring glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr)</pawn>

Now considering glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr)</pawn>

<gallery>
File:Traceline1.jpg|Traceline result if glass is ignored. The entity is ignored because of its solid flag
File:Traceline2.jpg|Traceline result if glass is not ignored.
File:Traceline3.jpg|Traceline result if glass is ignored but there's an entity with blocking solid flags in the way
File:Traceline4.jpg|Traceline result if glass is ignored, and the entity in the way has non-blocking flags
</gallery>

==== Other Traceline functions ====
This creates a trace handle. It's important to do this because we don't want our plugins to mess with eachothers info.
<pawn>new ptr = create_tr2()</pawn>

And this frees the trace handle:
<pawn>free_tr2(ptr)</pawn>

Getter and setter:
<pawn>[g|s]et_tr2(trace_handle, CONSTANT, argument_if_setting)</pawn>
Where CONSTANT can be one of the following enumerations:
<pawn>enum TraceResult
{
TR_AllSolid, // int
TR_StartSolid, // int
TR_InOpen, // int
TR_InWater, // int
TR_flFraction, // float
TR_vecEndPos, // float array[3]
TR_flPlaneDist, // float
TR_vecPlaneNormal, // float array[3]
TR_pHit, // int (edict_t*)
TR_iHitgroup, // int
};</pawn>

'''Getting the array and Float values require the third parameter to be passed.'''

Example:
<pawn>
new startsolid = get_tr2(trace, TR_StartSolid)
// TR_StartSolid is a boolean that says whether you were "inside" something
// (usually the world) when the trace started (point A)
// TR_AllSolid tells you if you ever got out of the "inside" or not.

new inopen = get_tr2(trace, TR_InOpen)
// TR_InOpen means that the start point is in Open
// That means in the world and not in an ent or something

new hit = get_tr2(trace, TR_pHit)
// What was hit by the traceline. It will either be a player index,
// entity index, 0 (part of map), or -1 (didn't hit anything;
// doesn't happen with player tracelines).

new hitgroup = get_tr2(trace, TR_iHitgroup)
// If the traceline hit another player, returns will be HIT_HEAD,
// HIT_CHEST, HIT_LEFTLEG... etc. If the traceline hit part of the
// map, this returns HIT_GENERIC.

new Float:fraction
get_tr2(trace, TR_flFraction, fraction)
// Returns a number between 0.0 and 1.0, indicating how far the
// traceline traveled start to end before it hit something. Depending
// on what conditions were passed to this traceline forward function,
// it could either be a wall or another entity.

new Float:end_origin[3]
get_tr2(trace, TR_vecEndPos, end_origin)
// The official end of the traceline. Not necesarily the same as the
// second argument passed to this traceline forward function.

new Float:normal[3]
get_tr2(trace, TR_vecPlaneNormal, normal)
// Returns a 1 unit long vector normal to the spot that it hit. Note
// that "normal" has a special connotation here. It doesn't mean "regular."
</pawn>

==== Useful Stocks ====
===== is_wall_between_points =====
This returns true if there's a wall between ''start'' and ''end''.
<pawn>stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
// Create the trace handle! It is best to create it!
new ptr = create_tr2()

// The main traceline function!
// This function ignores GLASS, MISSILE and MONSTERS!
// Here is an example of how you should combine all the flags!
engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS | IGNORE_MONSTERS | IGNORE_MISSILE, ignore_ent, ptr)

// We are interested in the fraction parameter
new fraction
get_tr2(ptr, TR_flFraction, fraction)

// Free the trace handle (don't forget to do this!)
free_tr2(ptr)

// If = 1.0 then it didn't hit anything!
return (fraction != 1.0)
}</pawn>

==== Extra Info ====
[[http://developer.valvesoftware.com/wiki/TraceLines Description of tracelines on the Valve Developer Community]]

[[http://forums.alliedmods.net/showthread.php?t=66076 Traceline tutorial by Nomexous]]

[[Category:Scripting (AMX Mod X)]]

=== EngFunc_TraceTexture, DLLFunc_PM_FindTextureType ===
The TraceTexture function detects the texture of an entity from a direction

The FindTextureType function allows to get the type of the material of the texture.

==== Usage ====
<pawn>engfunc(EngFunc_TraceTexture, ent, Float:start[3], Float:end[3], texture_name, len)</pawn>
* ent is the entity that we want to get the texture
* start is the point from where the trace starts
* end is the point where the trace ends
* texture_name - here we save the texture name
* len - the texture_name string length

<pawn>dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>
* texture_name is the name of the texture that we have gotten with TraceTexture

The function returns the material of the texture, which can be one of the following:

* C : concrete
* D : dirt
* G : grate
* M : metal
* N : snow
* P : computer
* S : slosh
* T : tile
* V : ventilation
* W : wood
* Y : glass

'''Example:'''

<pawn>new texture_name[64], texture_type
engfunc(EngFunc_TraceTexture, 0, start, end, texture_name, charsmax(texture_name))
texture_type = dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>

==== Notes ====
'''Improper use of these functions may crash the server!'''

To avoid crashing the server use the TraceTexture:
* on any entities (even worldspawn) except players
* when there is at least one player connected
* with a big distance between the two points (> 2000.0)

=== EngFunc_TraceModel ===
This function traces between 2 origins a model and gives us properties about it.
It acts just like a TraceLine but it ignores all the entities except the one we want to hit!

==== Usage ====
<pawn>engfunc(EngFunc_TraceModel, const Float:start[3], const Float:end[3], hull, ent_to_hit, ptr)</pawn>
* start - start origin
* end - end origin
* hull - the hull that is moved check above to see them
* ent_to_hit - the entity that you want to hit (this is a must!)
* ptr - the trace handle pointer, acts the same as the one in trace line!

The constants that we can use in hull:

#define HULL_POINT 0 // This means that we are moving a point from the start to the end
#define HULL_HUMAN 1 // That means that we move a cube of a player from start to end
#define HULL_LARGE 2 // That means that we move a bigger cube that one of the player from start to end
// (used in HL for big monsters!)
#define HULL_HEAD 3 // This means that we move from start to end the hull of a ducked player

==== Extra Info ====
[[http://forums.alliedmods.net/showthread.php?p=850698 TraceModel example]]

[[#EngFunc_TraceLine|TraceLine explanation]]

=== EngFunc_TraceToss ===
Trace the point where some entity movement will finish.
If for some reason the entity movement must be blocked for other entity (or worldspawn), TraceToss will detect that situation taking in account the original entity bounding boxes.

==== Usage ====
<pawn>engfunc(EngFunc_TraceToss, ent, skipent, tr)</pawn>
* ent = The entity which movement we want to trace
* skipent = The entity to skip in trace
* tr = trace handle to store the result

[[Image:Tracetoss.jpg|thumb|EngFunc_TraceToss example]]
==== Example ====

In the image you can see a player jumping and 2 points.

''Start Point'' is the origin of the player when TraceToss was called.

''End Point'' is the point returned in TR result.

So the player is making a parabola from START to END.
The green line is only for testing purposes and show from where to where the trace is.
This was tested with gravity = 400.

== Model/Decal/Texture Functions ==
=== EngFunc_SetModel ===
Properly sets a new model on an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetModel, iEnt, sModel)</pawn>
* iEnt = Entity index
* sModel = Model file name to set on entity (ex: "models/player/vip/vip.mdl")

==== Engine Alternative ====
<pawn>entity_set_model(entity, model[])</pawn>
[[http://www.amxmodx.org/funcwiki.php?go=func&id=354 FuncWiki page for entity_set_model]]

=== EngFunc_ModelIndex ===
Returns an unique index of the model name provided.
It's actually the same number that precache_model() returns.

A model index is used for example in some TE_* messages. ( TE_LIGHTNING, TE_GLOWSPRITE, etc.. See message_const.inc file ).

The model index of an entity is stored in pev_modelindex.

==== Usage ====
<pawn>ModelIndex = engfunc(EngFunc_ModelIndex, "models/MyModel.mdl")</pawn>
ModelIndex will have the model index for "models/MyModel.mdl" after the function call.

=== EngFunc_ModelFrames ===
Returns the frames count of a model.

==== Usage ====
<pawn>ModelFrames = engfunc(EngFunc_ModelFrames, ModelIndex)</pawn>
* ModelIndex = The model index. Value you can get from precache_model() or [[#EngFunc_ModelIndex|EngFunc_ModelIndex]].

=== EngFunc_DecalIndex ===
Returns an unique index of the decal name provided.

A decal index is used for example in some TE_* messages. ( TE_PLAYERDECAL, TE_DECAL, etc.. See message_const.inc file ).

All the available decals are stored in the decals.wad file. ( Located at your mod root directory )

As side-note a plugin [[http://forums.alliedmods.net/showthread.php?p=247677 "Decals/Models Lister"]] is available to see a list of decals/models index/name. ( Only CS and HL )

==== Usage ====
<pawn>DecalIndex = engfunc(EngFunc_DecalIndex, "{bigshot1")</pawn>
DecalIndex will have the decal index for "{bigshot1" after the function call.

=== EngFunc_AnimationAutomove ===
Plays the selected animation on entity

==== Usage ====
<pawn>entity_set_float(iEnt, EV_FL_framerate, fFrameRate);
entity_set_int(iEnt, EV_INT_sequence, iSequence);
engfunc(EngFunc_AnimationAutomove, iEnt, fTime);</pawn>

* fFrameRate = Frame rate of desired animation.
* iSequence = Sequence to play.
* iEnt = Source entity.
* fTime = '''It seems to not affect the animation. Maybe for internal use.'''

First you have to select the sequence and the desired frame rate. Then you can start the animation.
It will run in an endless loop.

It seems to work only on non-player entities.

== Entity/Global Functions ==
=== EngFunc_NumberOfEntities ===
Returns the number of entities in the world.

==== Usage ====
<pawn>ents = engfunc(EngFunc_NumberOfEntities)</pawn>

==== Engine alternative ====
<pawn>ents = entity_count()</pawn>
[[http://www.amxmodx.org/funcwiki.php?go=func&id=356 FuncWiki page for entity_count]]

=== EngFunc_SetSize ===
Sets the bounds of an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetSize, iEnt, Float:fMins[3], Float:fMaxs[3])</pawn>
* iEnt = Entity index
* fMins[3] = Mins boundings values (x,y,z)
* fMaxs[3] = Maxs boundings values (x,y,z)

==== Engine alternative ====
<pawn>entity_set_size(index, Float:mins[3], Float:maxs[3])</pawn>
[[http://www.amxmodx.org/funcwiki.php?go=func&id=328 FuncWiki page for entity_set_size]]

=== EngFunc_SetOrigin ===
Properly sets a new origin on an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetOrigin, iEnt, Float:Origin[3])</pawn>
* iEnt = Entity index
* Origin[3] = New origin for the entity (x,y,z)

==== Engine alternative ====
<pawn>entity_set_origin(index, Float:NewOrigin[3])</pawn>
[[http://www.amxmodx.org/funcwiki.php?go=func&id=353 FuncWiki page for entity_set_origin]]

=== EngFunc_MoveToOrigin ===
Moves an entity a defined distance toward a coordinate.

If the distance between Entity and Destination is less than the required distance, the entity will pass over that point.

==== Usage ====
<pawn>engfunc(EngFunc_MoveToOrigin, iEnt, Float:Destination[3], Float:Distance, iMoveType)</pawn>

* iEnt = Entity index
* Destination[3] = A Coordinate toward which the entity moves
* Distance = The distance to move the entity
* iMoveType = This is the MOVE_* option used for monsters and players to change the behaviour of the movement

Move type possible values:

#define MOVE_NORMAL 0 // normal move in the direction monster is facing
#define MOVE_STRAFE 1 // moves in direction specified, no matter which way monster is facing
#define MOVE_STUCK_DIST 32 // if a monster can't step this far, it is stuck.
#define MOVE_START_TURN_DIST 64 // when this far away from moveGoal, start turning to face next goal

==== Caveats ====

* iEnt must be on ground
* If there's an object closer than Distance that iEnt could collide then the movement is not done
* If there's a ramp, it works like an object and the movement is not done

== Visibility Functions ==
=== EngFunc_CheckVisibility ===
This function is used to check if an entity is in your [[PVS]].

'''It can be used on all entities except worldspawn.'''

==== Usage ====
This function has a parameter that must be obtained in a special way, the ''pset'' parameter.
'''Note:''' The parameter is player only, that means that if you get pset for example for a player that has the id ''1''. When you use this function on an entity it will check whether that entity is in [[PVS]] of the Player id ''1''.

<pawn>new g_cl_pset[33]

public plugin_init(id)
{
register_forward(FM_AddToFullPack, "pfw_atfp", 1)
}

public pfw_atfp(es, e, ent, host, flags, player, set)
{
g_cl_pset[host] = set

return FMRES_IGNORED
}

stock is_ent_in_player_pvs(id, entity)
{
return engfunc(EngFunc_CheckVisibility, entity, g_cl_pset[id])
}

stock get_pvs_players(id, players[32], num, flags[], team[])
{
if (!is_user_connected(id))
return 0

get_players(players, num, flags, team)

for (new i=0;i<num;i++)
{
if (!is_ent_in_player_pvs(id, players[i]))
{
num--;

for (new j=i;j<num;j++)
{
players[j] = players[j+1]
}

i--
}
}

return 1
}</pawn>

== Other Functions ==
=== EngFunc_PrecacheModel ===
Precaches a model or sprite file.

This should be used only when you would need to postpone the precache process in plugin_init() or plugin_cfg(), otherwise you should use precache_model() native directly in plugin_precache() forward.

It can be useful for example when you want to manage models with cvars and to avoid registering them in plugin_precache() then getting some trouble, you could manage out of this forward.

==== Usage ====
<pawn>engfunc(EngFunc_PrecacheModel, "models/MyModel.mdl")</pawn>
<pawn>engfunc(EngFunc_PrecacheModel, "sprites/MySprite.spr")</pawn>
It returns the precached model/sprite index if successful, otherwise 0.

=== EngFunc_PrecacheSound ===
Precaches a sound, only *.wav file. ( for mp3, see EngFunc_PrecacheGeneric )

This should be used only when you would need to postpone the precache process in plugin_init() or plugin_cfg(), otherwise you should use precache_sound() native directly in plugin_precache() forward.

It can be useful for example when you want to manage sounds with cvars and to avoid registering them in plugin_precache() then getting some trouble, you could manage out of this forward.

==== Usage ====
<pawn>engfunc(EngFunc_PrecacheSound, "sound/MySound.wav")</pawn>
It returns the precached sound index if successful, otherwise 0.

=== EngFunc_AlertMessage ===
Prints an alert message.

==== Usage ====
<pawn>engfunc(EngFunc_AlertMessage, AlertType, const Message)</pawn>
AlertType can be:

at_notice - shows a message box with the message
at_console - same as at_notice, but forces a ConPrintf, not a message box, prints output to server console, but only if 'developer' is 1.
at_aiconsole - same as at_console, but only shown if 'developer' is 2.
at_warning -
at_error -
at_logged - prints output to server logs and console.

FakeMeta Functions Detailed Descriptions

2010-09-07T16:42:52Z

Seta00: Added EngFunc_PrecacheSound

FakeMeta Functions Detailed Descriptions

2010-09-07T16:41:29Z

Seta00: Added EngFunc_PrecacheModel

FakeMeta Functions Detailed Descriptions

2010-09-07T16:39:20Z

Seta00: Added EngFunc_CheckVisibility

FakeMeta Functions Detailed Descriptions

2010-09-07T16:33:52Z

Seta00: Added EngFunc_MoveToOrigin

FakeMeta Functions Detailed Descriptions

2010-09-07T16:31:12Z

Seta00: Added EngFunc_SetOrigin

FakeMeta Functions Detailed Descriptions

2010-09-07T16:29:19Z

Seta00: Added EngFunc_SetSize

FakeMeta Functions Detailed Descriptions

2010-09-07T16:27:05Z

Seta00: Added EngFunc_NumberOfEntities

FakeMeta Functions Detailed Descriptions

2010-09-07T16:25:04Z

Seta00:

FakeMeta Functions Detailed Descriptions

2010-09-07T16:23:11Z

Seta00: /* Engine Alternative */ fixed link

FakeMeta Functions Detailed Descriptions

2010-09-07T16:22:23Z

Seta00: /* Extra Info */ Fixed links

== Point Functions ==
=== EngFunc_PointContents ===
This function checks an origin and gives us information of its whearabouts.

The constants that this function returns are these:
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7 // Removed at csg time
#define CONTENTS_CLIP -8 // Changed to contents_solid
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
#define CONTENTS_LADDER -16
#define CONTENT_FLYFIELD -17
#define CONTENT_GRAVITY_FLYFIELD -18
#define CONTENT_FOG -19

==== Usage ====
<pawn>static Float:origin[3]
static result
result = engfunc(EngFunc_PointContents, origin)
// if for example result is CONTENTS_SKY
// then the origin that we see is in the sky we can for example use this to see where a player is aming if he is aiming at sky this will be the result! </pawn>

=== EngFunc_GetBonePosition ===
[[Image:PlayerSkeleton.jpg|frame|This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.]]
This function allows to get the bone positions of an entity. This is best used on getting specific player origin points.

These are the bones that a player has:

Bone 1 Name: "Bip01"
Bone 2 Name: "Bip01 Pelvis"
Bone 3 Name: "Bip01 Spine"
Bone 4 Name: "Bip01 Spine1"
Bone 5 Name: "Bip01 Spine2"
Bone 6 Name: "Bip01 Spine3"
Bone 7 Name: "Bip01 Neck"
Bone 8 Name: "Bip01 Head"
Bone 9 Name: "Bone01"
Bone 10 Name: "Bip01 L Clavicle"
Bone 11 Name: "Bip01 L UpperArm"
Bone 12 Name: "Bip01 L Forearm"
Bone 13 Name: "Bip01 L Hand"
Bone 14 Name: "Bip01 L Finger0"
Bone 15 Name: "Bip01 L Finger01"
Bone 16 Name: "Bip01 L Finger1"
Bone 17 Name: "Bip01 L Finger11"
Bone 18 Name: "-- L knuckle"
Bone 19 Name: "-- L Forearm twist"
Bone 20 Name: "-- L wrist"
Bone 21 Name: "-- L Elbow"
Bone 22 Name: "-- L bicep twist"
Bone 23 Name: "-- L shoulder outside"
Bone 24 Name: "-- L Shoulder inside"
Bone 25 Name: "Bip01 R Clavicle"
Bone 26 Name: "Bip01 R UpperArm"
Bone 27 Name: "Bip01 R Forearm"
Bone 28 Name: "Bip01 R Hand"
Bone 29 Name: "Bip01 R Finger0"
Bone 30 Name: "Bip01 R Finger01"
Bone 31 Name: "Bip01 R Finger1"
Bone 32 Name: "Bip01 R Finger11"
Bone 33 Name: "-- R knuckle"
Bone 34 Name: "-- R wrist"
Bone 35 Name: "-- R forearm twist"
Bone 36 Name: "-- R Elbow"
Bone 37 Name: "-- R bicep twist"
Bone 38 Name: "-- R Shoulder inside"
Bone 39 Name: "-- R shoulder outside"
Bone 40 Name: "-- Neck smooth"
Bone 41 Name: "-- R Butt"
Bone 42 Name: "-- L butt"
Bone 43 Name: "Bip01 L Thigh"
Bone 44 Name: "Bip01 L Calf"
Bone 45 Name: "Bip01 L Foot"
Bone 46 Name: "Bip01 L Toe0"
Bone 47 Name: "-- L ankle"
Bone 48 Name: "-- L Knee"
Bone 49 Name: "Bip01 R Thigh"
Bone 50 Name: "Bip01 R Calf"
Bone 51 Name: "Bip01 R Foot"
Bone 52 Name: "Bip01 R Toe0"
Bone 53 Name: "-- R Ankle"
Bone 54 Name: "-- R Knee"
Bone 55 Name: "Bomb"

==== Usage ====
<pawn>// ENTITY is the player entity id
// BONE_NUMBER you have to choose from the list above
// bone_origin[3] is the vector where we save the bone origin
// bone_angles[3] the vector that holds the angles of the bone.
engfunc(EngFunc_GetBonePosition, ENTITY, BONE_NUMBER, Float:bone_origin[3], Float:bone_angles[3])</pawn>

==== Useful Stocks ====
These stocks are made for CS/CZ, you need to port them to other mods.
===== get_bone_hitgroup =====
This gets the hitgroup of the bone:
<pawn>#define BONE_HIT_HEAD 8
#define BONE_HIT_CHEST 6
#define BONE_HIT_STOMACH 4
#define BONE_HIT_LEFTARM 24
#define BONE_HIT_RIGHTARM 39
#define BONE_HIT_LEFTLEG 48
#define BONE_HIT_RIGHTLEG 54
#define HEAD_NECK 40
#define BONE_L_BUTT 41
#define BONE_R_BUTT 42

stock get_bone_hitgroup(number)
{
switch (number)
{
case HEAD_NECK:
{
return HIT_HEAD
}
case BONE_L_BUTT:
{
return HIT_LEFTLEG
}
case BONE_R_BUTT:
{
return HIT_RIGHTLEG
}
}

if (1 <= number <= BONE_HIT_STOMACH)
return HIT_STOMACH

if (BONE_HIT_STOMACH < number <= BONE_HIT_CHEST)
return HIT_CHEST

if (BONE_HIT_CHEST < number <= BONE_HIT_HEAD)
return HIT_HEAD

if (BONE_HIT_HEAD < number <= BONE_HIT_LEFTARM)
return HIT_LEFTARM

if (BONE_HIT_LEFTARM < number <= BONE_HIT_RIGHTARM)
return HIT_RIGHTARM

if (BONE_HIT_RIGHTARM < number <= BONE_HIT_LEFTLEG)
return HIT_LEFTLEG

if (BONE_HIT_LEFTLEG < number <= BONE_HIT_RIGHTLEG)
return HIT_RIGHTLEG

return HIT_GENERIC
}</pawn>

===== find_closest_bone_to_gunshot =====
This gets the closest bone to the gunshot (Use this in FM_TraceLine and Ham_TraceAttack):
<pawn>#define DISTANCE_CLEAR_HIT 2.0

stock find_closest_bone_to_gunshot(victim, Float:endtrace[3])
{
new Float:angles[3], Float:origin[3], Float:dist = 9999999.99, Float:curorigin[3], bone_nr
for (new i=1;i<=54;i++)
{
// Get the bone position
engfunc(EngFunc_GetBonePosition, victim, i, curorigin, angles)
// Calculate the distance vector
xs_vec_sub(curorigin, endtrace, angles)

// If this is smaller than the last small distance remember the value!
if (xs_vec_len(angles) <= dist)
{
origin = curorigin
dist = xs_vec_len(angles)
bone_nr = i
}

// If distance is smaller than CLEARHIT! Break (We accept the last value!)
if (dist <= DISTANCE_CLEAR_HIT)
{
break
}
}

// Return the bone
return bone_nr
}</pawn>

== Messaging Functions ==
=== EngFunc_MessageBegin ===
This function is used to generate client messages.

==== Usage ====
Syntax:
<pawn>engfunc(EngFunc_MessageBegin, dest, msg_type, origin[3] = {0, 0, 0}, player = 0)</pawn>
Example:
<pawn>static Float:origin[3] // Origin should be a Float
pev(id, pev_origin, origin) // Get user origin
engfunc(EngFunc_MessageBegin,MSG_BROADCAST,SVC_TEMPENTITY,origin,0) // Create message</pawn>
With MSG_ONE_UNRELIABLE:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>
With MSG_ALL:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>

dest can be:

#define MSG_BROADCAST 0 // Unreliable to all, There is not id
#define MSG_ONE 1 // Reliable to one (msg_entity)
#define MSG_ALL 2 // Reliable to all, There is not origin
#define MSG_INIT 3 // Write to the init string
#define MSG_PVS 4 // Ents in PVS of org
#define MSG_PAS 5 // Ents in PAS of org
#define MSG_PVS_R 6 // Reliable to PVS
#define MSG_PAS_R 7 // Reliable to PAS
#define MSG_ONE_UNRELIABLE 8 // Send to one client, but don't put in reliable stream,
// put in unreliable datagram (could be dropped), there is not origin
#define MSG_SPEC 9 // Sends to all spectator proxies

'''Before calling another EngFunc_MessageBegin you must call message_end().'''

== Entity Search Functions ==
=== EngFunc_FindEntityInSphere ===
Find entities within a radius. '''The function returns the next entity id after the start entity.'''

[[Image:FindEntityInSphere.png|thumb|3D diagram to show how the function works.]]
If we use
<pawn>engfunc(EngFunc_FindEntityInSphere, -1, origin, radius)</pawn>
In the situation described on the picture the function call above will return 1,
<pawn>engfunc(EngFunc_FindEntityInSphere, 20, origin, radius)</pawn>
will return 30 and
<pawn>engfunc(EngFunc_FindEntityInSphere, 100, origin, radius)</pawn>
will return 0, meaning that it didn't find an entity with an id grater than 100.

==== Usage ====
<pawn>engfunc(EngFunc_FindEntityInSphere, ent_to_start, origin, radius)</pawn>

=== EngFunc_EntitiesInPVS ===

This function checks entities that are in the [[PVS]] of an entity.
'''It can't be used on worldspawn.'''

The function returns the first entity on the [[PVS]] and then you can traverse through the results using pev_chain/EV_ENT_chain.
A NULL value of pev_chain/EV_ENT_chain indicates the end of the chain.

==== Usage ====
<pawn>public whatisonPVS(id)
{
static next, chain
static class[32]

next = engfunc(EngFunc_EntitiesInPVS, id)
while(next)
{
pev(next, pev_classname, class, charsmax(class))
chain = pev(next, pev_chain)

server_print("Found entity in player (%i) PVS: ent(%i) class(%s)", id, next, class)

if(!chain)
break

next = chain
}
}</pawn>

=== EngFunc_FindEntityByString ===
Returns the first entity found that matches the search criteria.

You can use any of string type attributes of entities:

classname Type of entity
globalname This is the name of the global variable that can be used to control the state of the entity
model The model of the entity
target Entity that this entity is handling
targetname The name given to this entity that another entity searches for to handle it
netname Player or NPC name
message Seems to be used mainly to store sound (string). It happens to store others things, depending the need of the entity
noise Noise variables do different things for different ents
noise1 This is the move sound for doors
noise2 This is the stop sound for doors
noise3 This is for blocking game_player_equip and player_weaponstrip

==== Usage ====
<pawn>iEnt = engfunc(EngFunc_FindEntityByString, iStartEnt, sAttribute, sValue)</pawn>
Parameters:
* iStartEnt: Start searching on this entity (ex: 0 = worldspawn)
* sAttribute: Name of attribute over which we need to search (ex: classname)
* sValue: Text string that we are searching for (ex: func_breakable)

The function returns the first entity matching the criteria.

=== EngFunc_FindClientInPVS ===
Returns the next "player" entity in someone's [[PVS]] using a global loop.

==== Usage ====
<pawn>iEnt2 = engfunc(EngFunc_FindClientInPVS, iEnt)</pawn>
Parameters:
* iEnt Source entity. Seek someone within iEnt's [[PVS]]

Unlike [[#EngFunc_EntitiesInPVS|EntitiesInPVS]], it does not return a series of chained entities. Instead, it works like a global loop of entities.
No matter which source entity you use, this function maintains the last index used and returns the next entity in source entity [[PVS]].

This function must be called several times to find every entity in [[PVS]] and can also return the source entity but it can't be called twice inside the same function because it will return the same entity.

==== Notes ====
It's not clear the main purpose of this function because you can get similar results with [[#EngFunc_EntitiesInPVS|EntitiesInPVS]].

[[#EngFunc_CheckVisibility|CheckVisibility]] and [[#EngFunc_EntitiesInPVS|EntitiesInPVS]] are better functions to use.

== Trace Functions ==
=== EngFunc_TraceLine ===
This function traces between 2 origins and gives us information about it.

These are the constants we can use as flags:

#define DONT_IGNORE_MONSTERS 0
#define IGNORE_MONSTERS 1
#define IGNORE_MISSILE 2
#define IGNORE_GLASS 0x100

'''These constants can be used together.'''

Ex: IGNORE_MISSILE | IGNORE_MONSTERS | IGNORE_GLASS - This makes the traceline ignore missiles, monsters (players) and glass.

==== Usage ====

Example of doing a traceline between two origins, and ignoring glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr)</pawn>

Now considering glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr)</pawn>

<gallery>
File:Traceline1.jpg|Traceline result if glass is ignored. The entity is ignored because of its solid flag
File:Traceline2.jpg|Traceline result if glass is not ignored.
File:Traceline3.jpg|Traceline result if glass is ignored but there's an entity with blocking solid flags in the way
File:Traceline4.jpg|Traceline result if glass is ignored, and the entity in the way has non-blocking flags
</gallery>

==== Other Traceline functions ====
This creates a trace handle. It's important to do this because we don't want our plugins to mess with eachothers info.
<pawn>new ptr = create_tr2()</pawn>

And this frees the trace handle:
<pawn>free_tr2(ptr)</pawn>

Getter and setter:
<pawn>[g|s]et_tr2(trace_handle, CONSTANT, argument_if_setting)</pawn>
Where CONSTANT can be one of the following enumerations:
<pawn>enum TraceResult
{
TR_AllSolid, // int
TR_StartSolid, // int
TR_InOpen, // int
TR_InWater, // int
TR_flFraction, // float
TR_vecEndPos, // float array[3]
TR_flPlaneDist, // float
TR_vecPlaneNormal, // float array[3]
TR_pHit, // int (edict_t*)
TR_iHitgroup, // int
};</pawn>

'''Getting the array and Float values require the third parameter to be passed.'''

Example:
<pawn>
new startsolid = get_tr2(trace, TR_StartSolid)
// TR_StartSolid is a boolean that says whether you were "inside" something
// (usually the world) when the trace started (point A)
// TR_AllSolid tells you if you ever got out of the "inside" or not.

new inopen = get_tr2(trace, TR_InOpen)
// TR_InOpen means that the start point is in Open
// That means in the world and not in an ent or something

new hit = get_tr2(trace, TR_pHit)
// What was hit by the traceline. It will either be a player index,
// entity index, 0 (part of map), or -1 (didn't hit anything;
// doesn't happen with player tracelines).

new hitgroup = get_tr2(trace, TR_iHitgroup)
// If the traceline hit another player, returns will be HIT_HEAD,
// HIT_CHEST, HIT_LEFTLEG... etc. If the traceline hit part of the
// map, this returns HIT_GENERIC.

new Float:fraction
get_tr2(trace, TR_flFraction, fraction)
// Returns a number between 0.0 and 1.0, indicating how far the
// traceline traveled start to end before it hit something. Depending
// on what conditions were passed to this traceline forward function,
// it could either be a wall or another entity.

new Float:end_origin[3]
get_tr2(trace, TR_vecEndPos, end_origin)
// The official end of the traceline. Not necesarily the same as the
// second argument passed to this traceline forward function.

new Float:normal[3]
get_tr2(trace, TR_vecPlaneNormal, normal)
// Returns a 1 unit long vector normal to the spot that it hit. Note
// that "normal" has a special connotation here. It doesn't mean "regular."
</pawn>

==== Useful Stocks ====
===== is_wall_between_points =====
This returns true if there's a wall between ''start'' and ''end''.
<pawn>stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
// Create the trace handle! It is best to create it!
new ptr = create_tr2()

// The main traceline function!
// This function ignores GLASS, MISSILE and MONSTERS!
// Here is an example of how you should combine all the flags!
engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS | IGNORE_MONSTERS | IGNORE_MISSILE, ignore_ent, ptr)

// We are interested in the fraction parameter
new fraction
get_tr2(ptr, TR_flFraction, fraction)

// Free the trace handle (don't forget to do this!)
free_tr2(ptr)

// If = 1.0 then it didn't hit anything!
return (fraction != 1.0)
}</pawn>

==== Extra Info ====
[[http://developer.valvesoftware.com/wiki/TraceLines Description of tracelines on the Valve Developer Community]]

[[http://forums.alliedmods.net/showthread.php?t=66076 Traceline tutorial by Nomexous]]

[[Category:Scripting (AMX Mod X)]]

=== EngFunc_TraceTexture, DLLFunc_PM_FindTextureType ===
The TraceTexture function detects the texture of an entity from a direction

The FindTextureType function allows to get the type of the material of the texture.

==== Usage ====
<pawn>engfunc(EngFunc_TraceTexture, ent, Float:start[3], Float:end[3], texture_name, len)</pawn>
* ent is the entity that we want to get the texture
* start is the point from where the trace starts
* end is the point where the trace ends
* texture_name - here we save the texture name
* len - the texture_name string length

<pawn>dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>
* texture_name is the name of the texture that we have gotten with TraceTexture

The function returns the material of the texture, which can be one of the following:

* C : concrete
* D : dirt
* G : grate
* M : metal
* N : snow
* P : computer
* S : slosh
* T : tile
* V : ventilation
* W : wood
* Y : glass

'''Example:'''

<pawn>new texture_name[64], texture_type
engfunc(EngFunc_TraceTexture, 0, start, end, texture_name, charsmax(texture_name))
texture_type = dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>

==== Notes ====
'''Improper use of these functions may crash the server!'''

To avoid crashing the server use the TraceTexture:
* on any entities (even worldspawn) except players
* when there is at least one player connected
* with a big distance between the two points (> 2000.0)

=== EngFunc_TraceModel ===
This function traces between 2 origins a model and gives us properties about it.
It acts just like a TraceLine but it ignores all the entities except the one we want to hit!

==== Usage ====
<pawn>engfunc(EngFunc_TraceModel, const Float:start[3], const Float:end[3], hull, ent_to_hit, ptr)</pawn>
* start - start origin
* end - end origin
* hull - the hull that is moved check above to see them
* ent_to_hit - the entity that you want to hit (this is a must!)
* ptr - the trace handle pointer, acts the same as the one in trace line!

The constants that we can use in hull:

#define HULL_POINT 0 // This means that we are moving a point from the start to the end
#define HULL_HUMAN 1 // That means that we move a cube of a player from start to end
#define HULL_LARGE 2 // That means that we move a bigger cube that one of the player from start to end
// (used in HL for big monsters!)
#define HULL_HEAD 3 // This means that we move from start to end the hull of a ducked player

==== Extra Info ====
[[http://forums.alliedmods.net/showthread.php?p=850698 TraceModel example]]

[[#EngFunc_TraceLine|TraceLine explanation]]

=== EngFunc_TraceToss ===
Trace the point where some entity movement will finish.
If for some reason the entity movement must be blocked for other entity (or worldspawn), TraceToss will detect that situation taking in account the original entity bounding boxes.

==== Usage ====
<pawn>engfunc(EngFunc_TraceToss, ent, skipent, tr)</pawn>
* ent = The entity which movement we want to trace
* skipent = The entity to skip in trace
* tr = trace handle to store the result

[[Image:Tracetoss.jpg|thumb|EngFunc_TraceToss example]]
==== Example ====

In the image you can see a player jumping and 2 points.

''Start Point'' is the origin of the player when TraceToss was called.

''End Point'' is the point returned in TR result.

So the player is making a parabola from START to END.
The green line is only for testing purposes and show from where to where the trace is.
This was tested with gravity = 400.

== Model/Decal/Texture Functions ==
=== EngFunc_SetModel ===
Properly sets a new model on an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetModel, iEnt, sModel)</pawn>
* iEnt = Entity index
* sModel = Model file name to set on entity (ex: "models/player/vip/vip.mdl")

==== Engine Alternative ====
<pawn>entity_set_model(entity, model[])</pawn>
http://www.amxmodx.org/funcwiki.php?go=func&id=354

=== EngFunc_ModelIndex ===
Returns an unique index of the model name provided.
It's actually the same number that precache_model() returns.

A model index is used for example in some TE_* messages. ( TE_LIGHTNING, TE_GLOWSPRITE, etc.. See message_const.inc file ).

The model index of an entity is stored in pev_modelindex.

==== Usage ====
<pawn>ModelIndex = engfunc(EngFunc_ModelIndex, "models/MyModel.mdl")</pawn>
ModelIndex will have the model index for "models/MyModel.mdl" after the function call.

=== EngFunc_ModelFrames ===
Returns the frames count of a model.

==== Usage ====
<pawn>ModelFrames = engfunc(EngFunc_ModelFrames, ModelIndex)</pawn>
* ModelIndex = The model index. Value you can get from precache_model() or [[#EngFunc_ModelIndex|EngFunc_ModelIndex]].

=== EngFunc_DecalIndex ===
Returns an unique index of the decal name provided.

A decal index is used for example in some TE_* messages. ( TE_PLAYERDECAL, TE_DECAL, etc.. See message_const.inc file ).

All the available decals are stored in the decals.wad file. ( Located at your mod root directory )

As side-note a plugin [[http://forums.alliedmods.net/showthread.php?p=247677 "Decals/Models Lister"]] is available to see a list of decals/models index/name. ( Only CS and HL )

==== Usage ====
<pawn>DecalIndex = engfunc(EngFunc_DecalIndex, "{bigshot1")</pawn>
DecalIndex will have the decal index for "{bigshot1" after the function call.

FakeMeta Functions Detailed Descriptions

2010-09-07T16:21:40Z

Seta00: /* Extra Info */ Fixed links

== Point Functions ==
=== EngFunc_PointContents ===
This function checks an origin and gives us information of its whearabouts.

The constants that this function returns are these:
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7 // Removed at csg time
#define CONTENTS_CLIP -8 // Changed to contents_solid
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
#define CONTENTS_LADDER -16
#define CONTENT_FLYFIELD -17
#define CONTENT_GRAVITY_FLYFIELD -18
#define CONTENT_FOG -19

==== Usage ====
<pawn>static Float:origin[3]
static result
result = engfunc(EngFunc_PointContents, origin)
// if for example result is CONTENTS_SKY
// then the origin that we see is in the sky we can for example use this to see where a player is aming if he is aiming at sky this will be the result! </pawn>

=== EngFunc_GetBonePosition ===
[[Image:PlayerSkeleton.jpg|frame|This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.]]
This function allows to get the bone positions of an entity. This is best used on getting specific player origin points.

These are the bones that a player has:

Bone 1 Name: "Bip01"
Bone 2 Name: "Bip01 Pelvis"
Bone 3 Name: "Bip01 Spine"
Bone 4 Name: "Bip01 Spine1"
Bone 5 Name: "Bip01 Spine2"
Bone 6 Name: "Bip01 Spine3"
Bone 7 Name: "Bip01 Neck"
Bone 8 Name: "Bip01 Head"
Bone 9 Name: "Bone01"
Bone 10 Name: "Bip01 L Clavicle"
Bone 11 Name: "Bip01 L UpperArm"
Bone 12 Name: "Bip01 L Forearm"
Bone 13 Name: "Bip01 L Hand"
Bone 14 Name: "Bip01 L Finger0"
Bone 15 Name: "Bip01 L Finger01"
Bone 16 Name: "Bip01 L Finger1"
Bone 17 Name: "Bip01 L Finger11"
Bone 18 Name: "-- L knuckle"
Bone 19 Name: "-- L Forearm twist"
Bone 20 Name: "-- L wrist"
Bone 21 Name: "-- L Elbow"
Bone 22 Name: "-- L bicep twist"
Bone 23 Name: "-- L shoulder outside"
Bone 24 Name: "-- L Shoulder inside"
Bone 25 Name: "Bip01 R Clavicle"
Bone 26 Name: "Bip01 R UpperArm"
Bone 27 Name: "Bip01 R Forearm"
Bone 28 Name: "Bip01 R Hand"
Bone 29 Name: "Bip01 R Finger0"
Bone 30 Name: "Bip01 R Finger01"
Bone 31 Name: "Bip01 R Finger1"
Bone 32 Name: "Bip01 R Finger11"
Bone 33 Name: "-- R knuckle"
Bone 34 Name: "-- R wrist"
Bone 35 Name: "-- R forearm twist"
Bone 36 Name: "-- R Elbow"
Bone 37 Name: "-- R bicep twist"
Bone 38 Name: "-- R Shoulder inside"
Bone 39 Name: "-- R shoulder outside"
Bone 40 Name: "-- Neck smooth"
Bone 41 Name: "-- R Butt"
Bone 42 Name: "-- L butt"
Bone 43 Name: "Bip01 L Thigh"
Bone 44 Name: "Bip01 L Calf"
Bone 45 Name: "Bip01 L Foot"
Bone 46 Name: "Bip01 L Toe0"
Bone 47 Name: "-- L ankle"
Bone 48 Name: "-- L Knee"
Bone 49 Name: "Bip01 R Thigh"
Bone 50 Name: "Bip01 R Calf"
Bone 51 Name: "Bip01 R Foot"
Bone 52 Name: "Bip01 R Toe0"
Bone 53 Name: "-- R Ankle"
Bone 54 Name: "-- R Knee"
Bone 55 Name: "Bomb"

==== Usage ====
<pawn>// ENTITY is the player entity id
// BONE_NUMBER you have to choose from the list above
// bone_origin[3] is the vector where we save the bone origin
// bone_angles[3] the vector that holds the angles of the bone.
engfunc(EngFunc_GetBonePosition, ENTITY, BONE_NUMBER, Float:bone_origin[3], Float:bone_angles[3])</pawn>

==== Useful Stocks ====
These stocks are made for CS/CZ, you need to port them to other mods.
===== get_bone_hitgroup =====
This gets the hitgroup of the bone:
<pawn>#define BONE_HIT_HEAD 8
#define BONE_HIT_CHEST 6
#define BONE_HIT_STOMACH 4
#define BONE_HIT_LEFTARM 24
#define BONE_HIT_RIGHTARM 39
#define BONE_HIT_LEFTLEG 48
#define BONE_HIT_RIGHTLEG 54
#define HEAD_NECK 40
#define BONE_L_BUTT 41
#define BONE_R_BUTT 42

stock get_bone_hitgroup(number)
{
switch (number)
{
case HEAD_NECK:
{
return HIT_HEAD
}
case BONE_L_BUTT:
{
return HIT_LEFTLEG
}
case BONE_R_BUTT:
{
return HIT_RIGHTLEG
}
}

if (1 <= number <= BONE_HIT_STOMACH)
return HIT_STOMACH

if (BONE_HIT_STOMACH < number <= BONE_HIT_CHEST)
return HIT_CHEST

if (BONE_HIT_CHEST < number <= BONE_HIT_HEAD)
return HIT_HEAD

if (BONE_HIT_HEAD < number <= BONE_HIT_LEFTARM)
return HIT_LEFTARM

if (BONE_HIT_LEFTARM < number <= BONE_HIT_RIGHTARM)
return HIT_RIGHTARM

if (BONE_HIT_RIGHTARM < number <= BONE_HIT_LEFTLEG)
return HIT_LEFTLEG

if (BONE_HIT_LEFTLEG < number <= BONE_HIT_RIGHTLEG)
return HIT_RIGHTLEG

return HIT_GENERIC
}</pawn>

===== find_closest_bone_to_gunshot =====
This gets the closest bone to the gunshot (Use this in FM_TraceLine and Ham_TraceAttack):
<pawn>#define DISTANCE_CLEAR_HIT 2.0

stock find_closest_bone_to_gunshot(victim, Float:endtrace[3])
{
new Float:angles[3], Float:origin[3], Float:dist = 9999999.99, Float:curorigin[3], bone_nr
for (new i=1;i<=54;i++)
{
// Get the bone position
engfunc(EngFunc_GetBonePosition, victim, i, curorigin, angles)
// Calculate the distance vector
xs_vec_sub(curorigin, endtrace, angles)

// If this is smaller than the last small distance remember the value!
if (xs_vec_len(angles) <= dist)
{
origin = curorigin
dist = xs_vec_len(angles)
bone_nr = i
}

// If distance is smaller than CLEARHIT! Break (We accept the last value!)
if (dist <= DISTANCE_CLEAR_HIT)
{
break
}
}

// Return the bone
return bone_nr
}</pawn>

== Messaging Functions ==
=== EngFunc_MessageBegin ===
This function is used to generate client messages.

==== Usage ====
Syntax:
<pawn>engfunc(EngFunc_MessageBegin, dest, msg_type, origin[3] = {0, 0, 0}, player = 0)</pawn>
Example:
<pawn>static Float:origin[3] // Origin should be a Float
pev(id, pev_origin, origin) // Get user origin
engfunc(EngFunc_MessageBegin,MSG_BROADCAST,SVC_TEMPENTITY,origin,0) // Create message</pawn>
With MSG_ONE_UNRELIABLE:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>
With MSG_ALL:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>

dest can be:

#define MSG_BROADCAST 0 // Unreliable to all, There is not id
#define MSG_ONE 1 // Reliable to one (msg_entity)
#define MSG_ALL 2 // Reliable to all, There is not origin
#define MSG_INIT 3 // Write to the init string
#define MSG_PVS 4 // Ents in PVS of org
#define MSG_PAS 5 // Ents in PAS of org
#define MSG_PVS_R 6 // Reliable to PVS
#define MSG_PAS_R 7 // Reliable to PAS
#define MSG_ONE_UNRELIABLE 8 // Send to one client, but don't put in reliable stream,
// put in unreliable datagram (could be dropped), there is not origin
#define MSG_SPEC 9 // Sends to all spectator proxies

'''Before calling another EngFunc_MessageBegin you must call message_end().'''

== Entity Search Functions ==
=== EngFunc_FindEntityInSphere ===
Find entities within a radius. '''The function returns the next entity id after the start entity.'''

[[Image:FindEntityInSphere.png|thumb|3D diagram to show how the function works.]]
If we use
<pawn>engfunc(EngFunc_FindEntityInSphere, -1, origin, radius)</pawn>
In the situation described on the picture the function call above will return 1,
<pawn>engfunc(EngFunc_FindEntityInSphere, 20, origin, radius)</pawn>
will return 30 and
<pawn>engfunc(EngFunc_FindEntityInSphere, 100, origin, radius)</pawn>
will return 0, meaning that it didn't find an entity with an id grater than 100.

==== Usage ====
<pawn>engfunc(EngFunc_FindEntityInSphere, ent_to_start, origin, radius)</pawn>

=== EngFunc_EntitiesInPVS ===

This function checks entities that are in the [[PVS]] of an entity.
'''It can't be used on worldspawn.'''

The function returns the first entity on the [[PVS]] and then you can traverse through the results using pev_chain/EV_ENT_chain.
A NULL value of pev_chain/EV_ENT_chain indicates the end of the chain.

==== Usage ====
<pawn>public whatisonPVS(id)
{
static next, chain
static class[32]

next = engfunc(EngFunc_EntitiesInPVS, id)
while(next)
{
pev(next, pev_classname, class, charsmax(class))
chain = pev(next, pev_chain)

server_print("Found entity in player (%i) PVS: ent(%i) class(%s)", id, next, class)

if(!chain)
break

next = chain
}
}</pawn>

=== EngFunc_FindEntityByString ===
Returns the first entity found that matches the search criteria.

You can use any of string type attributes of entities:

classname Type of entity
globalname This is the name of the global variable that can be used to control the state of the entity
model The model of the entity
target Entity that this entity is handling
targetname The name given to this entity that another entity searches for to handle it
netname Player or NPC name
message Seems to be used mainly to store sound (string). It happens to store others things, depending the need of the entity
noise Noise variables do different things for different ents
noise1 This is the move sound for doors
noise2 This is the stop sound for doors
noise3 This is for blocking game_player_equip and player_weaponstrip

==== Usage ====
<pawn>iEnt = engfunc(EngFunc_FindEntityByString, iStartEnt, sAttribute, sValue)</pawn>
Parameters:
* iStartEnt: Start searching on this entity (ex: 0 = worldspawn)
* sAttribute: Name of attribute over which we need to search (ex: classname)
* sValue: Text string that we are searching for (ex: func_breakable)

The function returns the first entity matching the criteria.

=== EngFunc_FindClientInPVS ===
Returns the next "player" entity in someone's [[PVS]] using a global loop.

==== Usage ====
<pawn>iEnt2 = engfunc(EngFunc_FindClientInPVS, iEnt)</pawn>
Parameters:
* iEnt Source entity. Seek someone within iEnt's [[PVS]]

Unlike [[#EngFunc_EntitiesInPVS|EntitiesInPVS]], it does not return a series of chained entities. Instead, it works like a global loop of entities.
No matter which source entity you use, this function maintains the last index used and returns the next entity in source entity [[PVS]].

This function must be called several times to find every entity in [[PVS]] and can also return the source entity but it can't be called twice inside the same function because it will return the same entity.

==== Notes ====
It's not clear the main purpose of this function because you can get similar results with [[#EngFunc_EntitiesInPVS|EntitiesInPVS]].

[[#EngFunc_CheckVisibility|CheckVisibility]] and [[#EngFunc_EntitiesInPVS|EntitiesInPVS]] are better functions to use.

== Trace Functions ==
=== EngFunc_TraceLine ===
This function traces between 2 origins and gives us information about it.

These are the constants we can use as flags:

#define DONT_IGNORE_MONSTERS 0
#define IGNORE_MONSTERS 1
#define IGNORE_MISSILE 2
#define IGNORE_GLASS 0x100

'''These constants can be used together.'''

Ex: IGNORE_MISSILE | IGNORE_MONSTERS | IGNORE_GLASS - This makes the traceline ignore missiles, monsters (players) and glass.

==== Usage ====

Example of doing a traceline between two origins, and ignoring glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr)</pawn>

Now considering glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr)</pawn>

<gallery>
File:Traceline1.jpg|Traceline result if glass is ignored. The entity is ignored because of its solid flag
File:Traceline2.jpg|Traceline result if glass is not ignored.
File:Traceline3.jpg|Traceline result if glass is ignored but there's an entity with blocking solid flags in the way
File:Traceline4.jpg|Traceline result if glass is ignored, and the entity in the way has non-blocking flags
</gallery>

==== Other Traceline functions ====
This creates a trace handle. It's important to do this because we don't want our plugins to mess with eachothers info.
<pawn>new ptr = create_tr2()</pawn>

And this frees the trace handle:
<pawn>free_tr2(ptr)</pawn>

Getter and setter:
<pawn>[g|s]et_tr2(trace_handle, CONSTANT, argument_if_setting)</pawn>
Where CONSTANT can be one of the following enumerations:
<pawn>enum TraceResult
{
TR_AllSolid, // int
TR_StartSolid, // int
TR_InOpen, // int
TR_InWater, // int
TR_flFraction, // float
TR_vecEndPos, // float array[3]
TR_flPlaneDist, // float
TR_vecPlaneNormal, // float array[3]
TR_pHit, // int (edict_t*)
TR_iHitgroup, // int
};</pawn>

'''Getting the array and Float values require the third parameter to be passed.'''

Example:
<pawn>
new startsolid = get_tr2(trace, TR_StartSolid)
// TR_StartSolid is a boolean that says whether you were "inside" something
// (usually the world) when the trace started (point A)
// TR_AllSolid tells you if you ever got out of the "inside" or not.

new inopen = get_tr2(trace, TR_InOpen)
// TR_InOpen means that the start point is in Open
// That means in the world and not in an ent or something

new hit = get_tr2(trace, TR_pHit)
// What was hit by the traceline. It will either be a player index,
// entity index, 0 (part of map), or -1 (didn't hit anything;
// doesn't happen with player tracelines).

new hitgroup = get_tr2(trace, TR_iHitgroup)
// If the traceline hit another player, returns will be HIT_HEAD,
// HIT_CHEST, HIT_LEFTLEG... etc. If the traceline hit part of the
// map, this returns HIT_GENERIC.

new Float:fraction
get_tr2(trace, TR_flFraction, fraction)
// Returns a number between 0.0 and 1.0, indicating how far the
// traceline traveled start to end before it hit something. Depending
// on what conditions were passed to this traceline forward function,
// it could either be a wall or another entity.

new Float:end_origin[3]
get_tr2(trace, TR_vecEndPos, end_origin)
// The official end of the traceline. Not necesarily the same as the
// second argument passed to this traceline forward function.

new Float:normal[3]
get_tr2(trace, TR_vecPlaneNormal, normal)
// Returns a 1 unit long vector normal to the spot that it hit. Note
// that "normal" has a special connotation here. It doesn't mean "regular."
</pawn>

==== Useful Stocks ====
===== is_wall_between_points =====
This returns true if there's a wall between ''start'' and ''end''.
<pawn>stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
// Create the trace handle! It is best to create it!
new ptr = create_tr2()

// The main traceline function!
// This function ignores GLASS, MISSILE and MONSTERS!
// Here is an example of how you should combine all the flags!
engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS | IGNORE_MONSTERS | IGNORE_MISSILE, ignore_ent, ptr)

// We are interested in the fraction parameter
new fraction
get_tr2(ptr, TR_flFraction, fraction)

// Free the trace handle (don't forget to do this!)
free_tr2(ptr)

// If = 1.0 then it didn't hit anything!
return (fraction != 1.0)
}</pawn>

==== Extra Info ====
[[http://developer.valvesoftware.com/wiki/TraceLines Description of tracelines on the Valve Developer Community]]

[[http://forums.alliedmods.net/showthread.php?t=66076 Traceline tutorial by Nomexous]]

[[Category:Scripting (AMX Mod X)]]

=== EngFunc_TraceTexture, DLLFunc_PM_FindTextureType ===
The TraceTexture function detects the texture of an entity from a direction

The FindTextureType function allows to get the type of the material of the texture.

==== Usage ====
<pawn>engfunc(EngFunc_TraceTexture, ent, Float:start[3], Float:end[3], texture_name, len)</pawn>
* ent is the entity that we want to get the texture
* start is the point from where the trace starts
* end is the point where the trace ends
* texture_name - here we save the texture name
* len - the texture_name string length

<pawn>dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>
* texture_name is the name of the texture that we have gotten with TraceTexture

The function returns the material of the texture, which can be one of the following:

* C : concrete
* D : dirt
* G : grate
* M : metal
* N : snow
* P : computer
* S : slosh
* T : tile
* V : ventilation
* W : wood
* Y : glass

'''Example:'''

<pawn>new texture_name[64], texture_type
engfunc(EngFunc_TraceTexture, 0, start, end, texture_name, charsmax(texture_name))
texture_type = dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>

==== Notes ====
'''Improper use of these functions may crash the server!'''

To avoid crashing the server use the TraceTexture:
* on any entities (even worldspawn) except players
* when there is at least one player connected
* with a big distance between the two points (> 2000.0)

=== EngFunc_TraceModel ===
This function traces between 2 origins a model and gives us properties about it.
It acts just like a TraceLine but it ignores all the entities except the one we want to hit!

==== Usage ====
<pawn>engfunc(EngFunc_TraceModel, const Float:start[3], const Float:end[3], hull, ent_to_hit, ptr)</pawn>
* start - start origin
* end - end origin
* hull - the hull that is moved check above to see them
* ent_to_hit - the entity that you want to hit (this is a must!)
* ptr - the trace handle pointer, acts the same as the one in trace line!

The constants that we can use in hull:

#define HULL_POINT 0 // This means that we are moving a point from the start to the end
#define HULL_HUMAN 1 // That means that we move a cube of a player from start to end
#define HULL_LARGE 2 // That means that we move a bigger cube that one of the player from start to end
// (used in HL for big monsters!)
#define HULL_HEAD 3 // This means that we move from start to end the hull of a ducked player

==== Extra Info ====
TraceModel example: http://forums.alliedmods.net/showthread.php?p=850698

[[#EngFunc_TraceLine]] explanation.

=== EngFunc_TraceToss ===
Trace the point where some entity movement will finish.
If for some reason the entity movement must be blocked for other entity (or worldspawn), TraceToss will detect that situation taking in account the original entity bounding boxes.

==== Usage ====
<pawn>engfunc(EngFunc_TraceToss, ent, skipent, tr)</pawn>
* ent = The entity which movement we want to trace
* skipent = The entity to skip in trace
* tr = trace handle to store the result

[[Image:Tracetoss.jpg|thumb|EngFunc_TraceToss example]]
==== Example ====

In the image you can see a player jumping and 2 points.

''Start Point'' is the origin of the player when TraceToss was called.

''End Point'' is the point returned in TR result.

So the player is making a parabola from START to END.
The green line is only for testing purposes and show from where to where the trace is.
This was tested with gravity = 400.

== Model/Decal/Texture Functions ==
=== EngFunc_SetModel ===
Properly sets a new model on an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetModel, iEnt, sModel)</pawn>
* iEnt = Entity index
* sModel = Model file name to set on entity (ex: "models/player/vip/vip.mdl")

==== Engine Alternative ====
<pawn>entity_set_model(entity, model[])</pawn>
http://www.amxmodx.org/funcwiki.php?go=func&id=354

=== EngFunc_ModelIndex ===
Returns an unique index of the model name provided.
It's actually the same number that precache_model() returns.

A model index is used for example in some TE_* messages. ( TE_LIGHTNING, TE_GLOWSPRITE, etc.. See message_const.inc file ).

The model index of an entity is stored in pev_modelindex.

==== Usage ====
<pawn>ModelIndex = engfunc(EngFunc_ModelIndex, "models/MyModel.mdl")</pawn>
ModelIndex will have the model index for "models/MyModel.mdl" after the function call.

=== EngFunc_ModelFrames ===
Returns the frames count of a model.

==== Usage ====
<pawn>ModelFrames = engfunc(EngFunc_ModelFrames, ModelIndex)</pawn>
* ModelIndex = The model index. Value you can get from precache_model() or [[#EngFunc_ModelIndex|EngFunc_ModelIndex]].

=== EngFunc_DecalIndex ===
Returns an unique index of the decal name provided.

A decal index is used for example in some TE_* messages. ( TE_PLAYERDECAL, TE_DECAL, etc.. See message_const.inc file ).

All the available decals are stored in the decals.wad file. ( Located at your mod root directory )

As side-note a plugin [[http://forums.alliedmods.net/showthread.php?p=247677 "Decals/Models Lister"]] is available to see a list of decals/models index/name. ( Only CS and HL )

==== Usage ====
<pawn>DecalIndex = engfunc(EngFunc_DecalIndex, "{bigshot1")</pawn>
DecalIndex will have the decal index for "{bigshot1" after the function call.

FakeMeta Functions Detailed Descriptions

2010-09-07T16:20:07Z

Seta00: Fixed links in EntitiesInPVS

== Point Functions ==
=== EngFunc_PointContents ===
This function checks an origin and gives us information of its whearabouts.

The constants that this function returns are these:
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7 // Removed at csg time
#define CONTENTS_CLIP -8 // Changed to contents_solid
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
#define CONTENTS_LADDER -16
#define CONTENT_FLYFIELD -17
#define CONTENT_GRAVITY_FLYFIELD -18
#define CONTENT_FOG -19

==== Usage ====
<pawn>static Float:origin[3]
static result
result = engfunc(EngFunc_PointContents, origin)
// if for example result is CONTENTS_SKY
// then the origin that we see is in the sky we can for example use this to see where a player is aming if he is aiming at sky this will be the result! </pawn>

=== EngFunc_GetBonePosition ===
[[Image:PlayerSkeleton.jpg|frame|This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.]]
This function allows to get the bone positions of an entity. This is best used on getting specific player origin points.

These are the bones that a player has:

Bone 1 Name: "Bip01"
Bone 2 Name: "Bip01 Pelvis"
Bone 3 Name: "Bip01 Spine"
Bone 4 Name: "Bip01 Spine1"
Bone 5 Name: "Bip01 Spine2"
Bone 6 Name: "Bip01 Spine3"
Bone 7 Name: "Bip01 Neck"
Bone 8 Name: "Bip01 Head"
Bone 9 Name: "Bone01"
Bone 10 Name: "Bip01 L Clavicle"
Bone 11 Name: "Bip01 L UpperArm"
Bone 12 Name: "Bip01 L Forearm"
Bone 13 Name: "Bip01 L Hand"
Bone 14 Name: "Bip01 L Finger0"
Bone 15 Name: "Bip01 L Finger01"
Bone 16 Name: "Bip01 L Finger1"
Bone 17 Name: "Bip01 L Finger11"
Bone 18 Name: "-- L knuckle"
Bone 19 Name: "-- L Forearm twist"
Bone 20 Name: "-- L wrist"
Bone 21 Name: "-- L Elbow"
Bone 22 Name: "-- L bicep twist"
Bone 23 Name: "-- L shoulder outside"
Bone 24 Name: "-- L Shoulder inside"
Bone 25 Name: "Bip01 R Clavicle"
Bone 26 Name: "Bip01 R UpperArm"
Bone 27 Name: "Bip01 R Forearm"
Bone 28 Name: "Bip01 R Hand"
Bone 29 Name: "Bip01 R Finger0"
Bone 30 Name: "Bip01 R Finger01"
Bone 31 Name: "Bip01 R Finger1"
Bone 32 Name: "Bip01 R Finger11"
Bone 33 Name: "-- R knuckle"
Bone 34 Name: "-- R wrist"
Bone 35 Name: "-- R forearm twist"
Bone 36 Name: "-- R Elbow"
Bone 37 Name: "-- R bicep twist"
Bone 38 Name: "-- R Shoulder inside"
Bone 39 Name: "-- R shoulder outside"
Bone 40 Name: "-- Neck smooth"
Bone 41 Name: "-- R Butt"
Bone 42 Name: "-- L butt"
Bone 43 Name: "Bip01 L Thigh"
Bone 44 Name: "Bip01 L Calf"
Bone 45 Name: "Bip01 L Foot"
Bone 46 Name: "Bip01 L Toe0"
Bone 47 Name: "-- L ankle"
Bone 48 Name: "-- L Knee"
Bone 49 Name: "Bip01 R Thigh"
Bone 50 Name: "Bip01 R Calf"
Bone 51 Name: "Bip01 R Foot"
Bone 52 Name: "Bip01 R Toe0"
Bone 53 Name: "-- R Ankle"
Bone 54 Name: "-- R Knee"
Bone 55 Name: "Bomb"

==== Usage ====
<pawn>// ENTITY is the player entity id
// BONE_NUMBER you have to choose from the list above
// bone_origin[3] is the vector where we save the bone origin
// bone_angles[3] the vector that holds the angles of the bone.
engfunc(EngFunc_GetBonePosition, ENTITY, BONE_NUMBER, Float:bone_origin[3], Float:bone_angles[3])</pawn>

==== Useful Stocks ====
These stocks are made for CS/CZ, you need to port them to other mods.
===== get_bone_hitgroup =====
This gets the hitgroup of the bone:
<pawn>#define BONE_HIT_HEAD 8
#define BONE_HIT_CHEST 6
#define BONE_HIT_STOMACH 4
#define BONE_HIT_LEFTARM 24
#define BONE_HIT_RIGHTARM 39
#define BONE_HIT_LEFTLEG 48
#define BONE_HIT_RIGHTLEG 54
#define HEAD_NECK 40
#define BONE_L_BUTT 41
#define BONE_R_BUTT 42

stock get_bone_hitgroup(number)
{
switch (number)
{
case HEAD_NECK:
{
return HIT_HEAD
}
case BONE_L_BUTT:
{
return HIT_LEFTLEG
}
case BONE_R_BUTT:
{
return HIT_RIGHTLEG
}
}

if (1 <= number <= BONE_HIT_STOMACH)
return HIT_STOMACH

if (BONE_HIT_STOMACH < number <= BONE_HIT_CHEST)
return HIT_CHEST

if (BONE_HIT_CHEST < number <= BONE_HIT_HEAD)
return HIT_HEAD

if (BONE_HIT_HEAD < number <= BONE_HIT_LEFTARM)
return HIT_LEFTARM

if (BONE_HIT_LEFTARM < number <= BONE_HIT_RIGHTARM)
return HIT_RIGHTARM

if (BONE_HIT_RIGHTARM < number <= BONE_HIT_LEFTLEG)
return HIT_LEFTLEG

if (BONE_HIT_LEFTLEG < number <= BONE_HIT_RIGHTLEG)
return HIT_RIGHTLEG

return HIT_GENERIC
}</pawn>

===== find_closest_bone_to_gunshot =====
This gets the closest bone to the gunshot (Use this in FM_TraceLine and Ham_TraceAttack):
<pawn>#define DISTANCE_CLEAR_HIT 2.0

stock find_closest_bone_to_gunshot(victim, Float:endtrace[3])
{
new Float:angles[3], Float:origin[3], Float:dist = 9999999.99, Float:curorigin[3], bone_nr
for (new i=1;i<=54;i++)
{
// Get the bone position
engfunc(EngFunc_GetBonePosition, victim, i, curorigin, angles)
// Calculate the distance vector
xs_vec_sub(curorigin, endtrace, angles)

// If this is smaller than the last small distance remember the value!
if (xs_vec_len(angles) <= dist)
{
origin = curorigin
dist = xs_vec_len(angles)
bone_nr = i
}

// If distance is smaller than CLEARHIT! Break (We accept the last value!)
if (dist <= DISTANCE_CLEAR_HIT)
{
break
}
}

// Return the bone
return bone_nr
}</pawn>

== Messaging Functions ==
=== EngFunc_MessageBegin ===
This function is used to generate client messages.

==== Usage ====
Syntax:
<pawn>engfunc(EngFunc_MessageBegin, dest, msg_type, origin[3] = {0, 0, 0}, player = 0)</pawn>
Example:
<pawn>static Float:origin[3] // Origin should be a Float
pev(id, pev_origin, origin) // Get user origin
engfunc(EngFunc_MessageBegin,MSG_BROADCAST,SVC_TEMPENTITY,origin,0) // Create message</pawn>
With MSG_ONE_UNRELIABLE:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>
With MSG_ALL:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>

dest can be:

#define MSG_BROADCAST 0 // Unreliable to all, There is not id
#define MSG_ONE 1 // Reliable to one (msg_entity)
#define MSG_ALL 2 // Reliable to all, There is not origin
#define MSG_INIT 3 // Write to the init string
#define MSG_PVS 4 // Ents in PVS of org
#define MSG_PAS 5 // Ents in PAS of org
#define MSG_PVS_R 6 // Reliable to PVS
#define MSG_PAS_R 7 // Reliable to PAS
#define MSG_ONE_UNRELIABLE 8 // Send to one client, but don't put in reliable stream,
// put in unreliable datagram (could be dropped), there is not origin
#define MSG_SPEC 9 // Sends to all spectator proxies

'''Before calling another EngFunc_MessageBegin you must call message_end().'''

== Entity Search Functions ==
=== EngFunc_FindEntityInSphere ===
Find entities within a radius. '''The function returns the next entity id after the start entity.'''

[[Image:FindEntityInSphere.png|thumb|3D diagram to show how the function works.]]
If we use
<pawn>engfunc(EngFunc_FindEntityInSphere, -1, origin, radius)</pawn>
In the situation described on the picture the function call above will return 1,
<pawn>engfunc(EngFunc_FindEntityInSphere, 20, origin, radius)</pawn>
will return 30 and
<pawn>engfunc(EngFunc_FindEntityInSphere, 100, origin, radius)</pawn>
will return 0, meaning that it didn't find an entity with an id grater than 100.

==== Usage ====
<pawn>engfunc(EngFunc_FindEntityInSphere, ent_to_start, origin, radius)</pawn>

=== EngFunc_EntitiesInPVS ===

This function checks entities that are in the [[PVS]] of an entity.
'''It can't be used on worldspawn.'''

The function returns the first entity on the [[PVS]] and then you can traverse through the results using pev_chain/EV_ENT_chain.
A NULL value of pev_chain/EV_ENT_chain indicates the end of the chain.

==== Usage ====
<pawn>public whatisonPVS(id)
{
static next, chain
static class[32]

next = engfunc(EngFunc_EntitiesInPVS, id)
while(next)
{
pev(next, pev_classname, class, charsmax(class))
chain = pev(next, pev_chain)

server_print("Found entity in player (%i) PVS: ent(%i) class(%s)", id, next, class)

if(!chain)
break

next = chain
}
}</pawn>

=== EngFunc_FindEntityByString ===
Returns the first entity found that matches the search criteria.

You can use any of string type attributes of entities:

classname Type of entity
globalname This is the name of the global variable that can be used to control the state of the entity
model The model of the entity
target Entity that this entity is handling
targetname The name given to this entity that another entity searches for to handle it
netname Player or NPC name
message Seems to be used mainly to store sound (string). It happens to store others things, depending the need of the entity
noise Noise variables do different things for different ents
noise1 This is the move sound for doors
noise2 This is the stop sound for doors
noise3 This is for blocking game_player_equip and player_weaponstrip

==== Usage ====
<pawn>iEnt = engfunc(EngFunc_FindEntityByString, iStartEnt, sAttribute, sValue)</pawn>
Parameters:
* iStartEnt: Start searching on this entity (ex: 0 = worldspawn)
* sAttribute: Name of attribute over which we need to search (ex: classname)
* sValue: Text string that we are searching for (ex: func_breakable)

The function returns the first entity matching the criteria.

=== EngFunc_FindClientInPVS ===
Returns the next "player" entity in someone's [[PVS]] using a global loop.

==== Usage ====
<pawn>iEnt2 = engfunc(EngFunc_FindClientInPVS, iEnt)</pawn>
Parameters:
* iEnt Source entity. Seek someone within iEnt's [[PVS]]

Unlike [[#EngFunc_EntitiesInPVS|EntitiesInPVS]], it does not return a series of chained entities. Instead, it works like a global loop of entities.
No matter which source entity you use, this function maintains the last index used and returns the next entity in source entity [[PVS]].

This function must be called several times to find every entity in [[PVS]] and can also return the source entity but it can't be called twice inside the same function because it will return the same entity.

==== Notes ====
It's not clear the main purpose of this function because you can get similar results with [[#EngFunc_EntitiesInPVS|EntitiesInPVS]].

[[#EngFunc_CheckVisibility|CheckVisibility]] and [[#EngFunc_EntitiesInPVS|EntitiesInPVS]] are better functions to use.

== Trace Functions ==
=== EngFunc_TraceLine ===
This function traces between 2 origins and gives us information about it.

These are the constants we can use as flags:

#define DONT_IGNORE_MONSTERS 0
#define IGNORE_MONSTERS 1
#define IGNORE_MISSILE 2
#define IGNORE_GLASS 0x100

'''These constants can be used together.'''

Ex: IGNORE_MISSILE | IGNORE_MONSTERS | IGNORE_GLASS - This makes the traceline ignore missiles, monsters (players) and glass.

==== Usage ====

Example of doing a traceline between two origins, and ignoring glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr)</pawn>

Now considering glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr)</pawn>

<gallery>
File:Traceline1.jpg|Traceline result if glass is ignored. The entity is ignored because of its solid flag
File:Traceline2.jpg|Traceline result if glass is not ignored.
File:Traceline3.jpg|Traceline result if glass is ignored but there's an entity with blocking solid flags in the way
File:Traceline4.jpg|Traceline result if glass is ignored, and the entity in the way has non-blocking flags
</gallery>

==== Other Traceline functions ====
This creates a trace handle. It's important to do this because we don't want our plugins to mess with eachothers info.
<pawn>new ptr = create_tr2()</pawn>

And this frees the trace handle:
<pawn>free_tr2(ptr)</pawn>

Getter and setter:
<pawn>[g|s]et_tr2(trace_handle, CONSTANT, argument_if_setting)</pawn>
Where CONSTANT can be one of the following enumerations:
<pawn>enum TraceResult
{
TR_AllSolid, // int
TR_StartSolid, // int
TR_InOpen, // int
TR_InWater, // int
TR_flFraction, // float
TR_vecEndPos, // float array[3]
TR_flPlaneDist, // float
TR_vecPlaneNormal, // float array[3]
TR_pHit, // int (edict_t*)
TR_iHitgroup, // int
};</pawn>

'''Getting the array and Float values require the third parameter to be passed.'''

Example:
<pawn>
new startsolid = get_tr2(trace, TR_StartSolid)
// TR_StartSolid is a boolean that says whether you were "inside" something
// (usually the world) when the trace started (point A)
// TR_AllSolid tells you if you ever got out of the "inside" or not.

new inopen = get_tr2(trace, TR_InOpen)
// TR_InOpen means that the start point is in Open
// That means in the world and not in an ent or something

new hit = get_tr2(trace, TR_pHit)
// What was hit by the traceline. It will either be a player index,
// entity index, 0 (part of map), or -1 (didn't hit anything;
// doesn't happen with player tracelines).

new hitgroup = get_tr2(trace, TR_iHitgroup)
// If the traceline hit another player, returns will be HIT_HEAD,
// HIT_CHEST, HIT_LEFTLEG... etc. If the traceline hit part of the
// map, this returns HIT_GENERIC.

new Float:fraction
get_tr2(trace, TR_flFraction, fraction)
// Returns a number between 0.0 and 1.0, indicating how far the
// traceline traveled start to end before it hit something. Depending
// on what conditions were passed to this traceline forward function,
// it could either be a wall or another entity.

new Float:end_origin[3]
get_tr2(trace, TR_vecEndPos, end_origin)
// The official end of the traceline. Not necesarily the same as the
// second argument passed to this traceline forward function.

new Float:normal[3]
get_tr2(trace, TR_vecPlaneNormal, normal)
// Returns a 1 unit long vector normal to the spot that it hit. Note
// that "normal" has a special connotation here. It doesn't mean "regular."
</pawn>

==== Useful Stocks ====
===== is_wall_between_points =====
This returns true if there's a wall between ''start'' and ''end''.
<pawn>stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
// Create the trace handle! It is best to create it!
new ptr = create_tr2()

// The main traceline function!
// This function ignores GLASS, MISSILE and MONSTERS!
// Here is an example of how you should combine all the flags!
engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS | IGNORE_MONSTERS | IGNORE_MISSILE, ignore_ent, ptr)

// We are interested in the fraction parameter
new fraction
get_tr2(ptr, TR_flFraction, fraction)

// Free the trace handle (don't forget to do this!)
free_tr2(ptr)

// If = 1.0 then it didn't hit anything!
return (fraction != 1.0)
}</pawn>

==== Extra Info ====
http://developer.valvesoftware.com/wiki/TraceLines

http://forums.alliedmods.net/showthread.php?t=66076

[[Category:Scripting (AMX Mod X)]]

=== EngFunc_TraceTexture, DLLFunc_PM_FindTextureType ===
The TraceTexture function detects the texture of an entity from a direction

The FindTextureType function allows to get the type of the material of the texture.

==== Usage ====
<pawn>engfunc(EngFunc_TraceTexture, ent, Float:start[3], Float:end[3], texture_name, len)</pawn>
* ent is the entity that we want to get the texture
* start is the point from where the trace starts
* end is the point where the trace ends
* texture_name - here we save the texture name
* len - the texture_name string length

<pawn>dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>
* texture_name is the name of the texture that we have gotten with TraceTexture

The function returns the material of the texture, which can be one of the following:

* C : concrete
* D : dirt
* G : grate
* M : metal
* N : snow
* P : computer
* S : slosh
* T : tile
* V : ventilation
* W : wood
* Y : glass

'''Example:'''

<pawn>new texture_name[64], texture_type
engfunc(EngFunc_TraceTexture, 0, start, end, texture_name, charsmax(texture_name))
texture_type = dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>

==== Notes ====
'''Improper use of these functions may crash the server!'''

To avoid crashing the server use the TraceTexture:
* on any entities (even worldspawn) except players
* when there is at least one player connected
* with a big distance between the two points (> 2000.0)

=== EngFunc_TraceModel ===
This function traces between 2 origins a model and gives us properties about it.
It acts just like a TraceLine but it ignores all the entities except the one we want to hit!

==== Usage ====
<pawn>engfunc(EngFunc_TraceModel, const Float:start[3], const Float:end[3], hull, ent_to_hit, ptr)</pawn>
* start - start origin
* end - end origin
* hull - the hull that is moved check above to see them
* ent_to_hit - the entity that you want to hit (this is a must!)
* ptr - the trace handle pointer, acts the same as the one in trace line!

The constants that we can use in hull:

#define HULL_POINT 0 // This means that we are moving a point from the start to the end
#define HULL_HUMAN 1 // That means that we move a cube of a player from start to end
#define HULL_LARGE 2 // That means that we move a bigger cube that one of the player from start to end
// (used in HL for big monsters!)
#define HULL_HEAD 3 // This means that we move from start to end the hull of a ducked player

==== Extra Info ====
TraceModel example: http://forums.alliedmods.net/showthread.php?p=850698

[[#EngFunc_TraceLine]] explanation.

=== EngFunc_TraceToss ===
Trace the point where some entity movement will finish.
If for some reason the entity movement must be blocked for other entity (or worldspawn), TraceToss will detect that situation taking in account the original entity bounding boxes.

==== Usage ====
<pawn>engfunc(EngFunc_TraceToss, ent, skipent, tr)</pawn>
* ent = The entity which movement we want to trace
* skipent = The entity to skip in trace
* tr = trace handle to store the result

[[Image:Tracetoss.jpg|thumb|EngFunc_TraceToss example]]
==== Example ====

In the image you can see a player jumping and 2 points.

''Start Point'' is the origin of the player when TraceToss was called.

''End Point'' is the point returned in TR result.

So the player is making a parabola from START to END.
The green line is only for testing purposes and show from where to where the trace is.
This was tested with gravity = 400.

== Model/Decal/Texture Functions ==
=== EngFunc_SetModel ===
Properly sets a new model on an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetModel, iEnt, sModel)</pawn>
* iEnt = Entity index
* sModel = Model file name to set on entity (ex: "models/player/vip/vip.mdl")

==== Engine Alternative ====
<pawn>entity_set_model(entity, model[])</pawn>
http://www.amxmodx.org/funcwiki.php?go=func&id=354

=== EngFunc_ModelIndex ===
Returns an unique index of the model name provided.
It's actually the same number that precache_model() returns.

A model index is used for example in some TE_* messages. ( TE_LIGHTNING, TE_GLOWSPRITE, etc.. See message_const.inc file ).

The model index of an entity is stored in pev_modelindex.

==== Usage ====
<pawn>ModelIndex = engfunc(EngFunc_ModelIndex, "models/MyModel.mdl")</pawn>
ModelIndex will have the model index for "models/MyModel.mdl" after the function call.

=== EngFunc_ModelFrames ===
Returns the frames count of a model.

==== Usage ====
<pawn>ModelFrames = engfunc(EngFunc_ModelFrames, ModelIndex)</pawn>
* ModelIndex = The model index. Value you can get from precache_model() or [[#EngFunc_ModelIndex|EngFunc_ModelIndex]].

=== EngFunc_DecalIndex ===
Returns an unique index of the decal name provided.

A decal index is used for example in some TE_* messages. ( TE_PLAYERDECAL, TE_DECAL, etc.. See message_const.inc file ).

All the available decals are stored in the decals.wad file. ( Located at your mod root directory )

As side-note a plugin [[http://forums.alliedmods.net/showthread.php?p=247677 "Decals/Models Lister"]] is available to see a list of decals/models index/name. ( Only CS and HL )

==== Usage ====
<pawn>DecalIndex = engfunc(EngFunc_DecalIndex, "{bigshot1")</pawn>
DecalIndex will have the decal index for "{bigshot1" after the function call.

FakeMeta Functions Detailed Descriptions

2010-09-07T16:18:26Z

Seta00: Added EngFunc_DecalIndex

== Point Functions ==
=== EngFunc_PointContents ===
This function checks an origin and gives us information of its whearabouts.

The constants that this function returns are these:
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7 // Removed at csg time
#define CONTENTS_CLIP -8 // Changed to contents_solid
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
#define CONTENTS_LADDER -16
#define CONTENT_FLYFIELD -17
#define CONTENT_GRAVITY_FLYFIELD -18
#define CONTENT_FOG -19

==== Usage ====
<pawn>static Float:origin[3]
static result
result = engfunc(EngFunc_PointContents, origin)
// if for example result is CONTENTS_SKY
// then the origin that we see is in the sky we can for example use this to see where a player is aming if he is aiming at sky this will be the result! </pawn>

=== EngFunc_GetBonePosition ===
[[Image:PlayerSkeleton.jpg|frame|This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.]]
This function allows to get the bone positions of an entity. This is best used on getting specific player origin points.

These are the bones that a player has:

Bone 1 Name: "Bip01"
Bone 2 Name: "Bip01 Pelvis"
Bone 3 Name: "Bip01 Spine"
Bone 4 Name: "Bip01 Spine1"
Bone 5 Name: "Bip01 Spine2"
Bone 6 Name: "Bip01 Spine3"
Bone 7 Name: "Bip01 Neck"
Bone 8 Name: "Bip01 Head"
Bone 9 Name: "Bone01"
Bone 10 Name: "Bip01 L Clavicle"
Bone 11 Name: "Bip01 L UpperArm"
Bone 12 Name: "Bip01 L Forearm"
Bone 13 Name: "Bip01 L Hand"
Bone 14 Name: "Bip01 L Finger0"
Bone 15 Name: "Bip01 L Finger01"
Bone 16 Name: "Bip01 L Finger1"
Bone 17 Name: "Bip01 L Finger11"
Bone 18 Name: "-- L knuckle"
Bone 19 Name: "-- L Forearm twist"
Bone 20 Name: "-- L wrist"
Bone 21 Name: "-- L Elbow"
Bone 22 Name: "-- L bicep twist"
Bone 23 Name: "-- L shoulder outside"
Bone 24 Name: "-- L Shoulder inside"
Bone 25 Name: "Bip01 R Clavicle"
Bone 26 Name: "Bip01 R UpperArm"
Bone 27 Name: "Bip01 R Forearm"
Bone 28 Name: "Bip01 R Hand"
Bone 29 Name: "Bip01 R Finger0"
Bone 30 Name: "Bip01 R Finger01"
Bone 31 Name: "Bip01 R Finger1"
Bone 32 Name: "Bip01 R Finger11"
Bone 33 Name: "-- R knuckle"
Bone 34 Name: "-- R wrist"
Bone 35 Name: "-- R forearm twist"
Bone 36 Name: "-- R Elbow"
Bone 37 Name: "-- R bicep twist"
Bone 38 Name: "-- R Shoulder inside"
Bone 39 Name: "-- R shoulder outside"
Bone 40 Name: "-- Neck smooth"
Bone 41 Name: "-- R Butt"
Bone 42 Name: "-- L butt"
Bone 43 Name: "Bip01 L Thigh"
Bone 44 Name: "Bip01 L Calf"
Bone 45 Name: "Bip01 L Foot"
Bone 46 Name: "Bip01 L Toe0"
Bone 47 Name: "-- L ankle"
Bone 48 Name: "-- L Knee"
Bone 49 Name: "Bip01 R Thigh"
Bone 50 Name: "Bip01 R Calf"
Bone 51 Name: "Bip01 R Foot"
Bone 52 Name: "Bip01 R Toe0"
Bone 53 Name: "-- R Ankle"
Bone 54 Name: "-- R Knee"
Bone 55 Name: "Bomb"

==== Usage ====
<pawn>// ENTITY is the player entity id
// BONE_NUMBER you have to choose from the list above
// bone_origin[3] is the vector where we save the bone origin
// bone_angles[3] the vector that holds the angles of the bone.
engfunc(EngFunc_GetBonePosition, ENTITY, BONE_NUMBER, Float:bone_origin[3], Float:bone_angles[3])</pawn>

==== Useful Stocks ====
These stocks are made for CS/CZ, you need to port them to other mods.
===== get_bone_hitgroup =====
This gets the hitgroup of the bone:
<pawn>#define BONE_HIT_HEAD 8
#define BONE_HIT_CHEST 6
#define BONE_HIT_STOMACH 4
#define BONE_HIT_LEFTARM 24
#define BONE_HIT_RIGHTARM 39
#define BONE_HIT_LEFTLEG 48
#define BONE_HIT_RIGHTLEG 54
#define HEAD_NECK 40
#define BONE_L_BUTT 41
#define BONE_R_BUTT 42

stock get_bone_hitgroup(number)
{
switch (number)
{
case HEAD_NECK:
{
return HIT_HEAD
}
case BONE_L_BUTT:
{
return HIT_LEFTLEG
}
case BONE_R_BUTT:
{
return HIT_RIGHTLEG
}
}

if (1 <= number <= BONE_HIT_STOMACH)
return HIT_STOMACH

if (BONE_HIT_STOMACH < number <= BONE_HIT_CHEST)
return HIT_CHEST

if (BONE_HIT_CHEST < number <= BONE_HIT_HEAD)
return HIT_HEAD

if (BONE_HIT_HEAD < number <= BONE_HIT_LEFTARM)
return HIT_LEFTARM

if (BONE_HIT_LEFTARM < number <= BONE_HIT_RIGHTARM)
return HIT_RIGHTARM

if (BONE_HIT_RIGHTARM < number <= BONE_HIT_LEFTLEG)
return HIT_LEFTLEG

if (BONE_HIT_LEFTLEG < number <= BONE_HIT_RIGHTLEG)
return HIT_RIGHTLEG

return HIT_GENERIC
}</pawn>

===== find_closest_bone_to_gunshot =====
This gets the closest bone to the gunshot (Use this in FM_TraceLine and Ham_TraceAttack):
<pawn>#define DISTANCE_CLEAR_HIT 2.0

stock find_closest_bone_to_gunshot(victim, Float:endtrace[3])
{
new Float:angles[3], Float:origin[3], Float:dist = 9999999.99, Float:curorigin[3], bone_nr
for (new i=1;i<=54;i++)
{
// Get the bone position
engfunc(EngFunc_GetBonePosition, victim, i, curorigin, angles)
// Calculate the distance vector
xs_vec_sub(curorigin, endtrace, angles)

// If this is smaller than the last small distance remember the value!
if (xs_vec_len(angles) <= dist)
{
origin = curorigin
dist = xs_vec_len(angles)
bone_nr = i
}

// If distance is smaller than CLEARHIT! Break (We accept the last value!)
if (dist <= DISTANCE_CLEAR_HIT)
{
break
}
}

// Return the bone
return bone_nr
}</pawn>

== Messaging Functions ==
=== EngFunc_MessageBegin ===
This function is used to generate client messages.

==== Usage ====
Syntax:
<pawn>engfunc(EngFunc_MessageBegin, dest, msg_type, origin[3] = {0, 0, 0}, player = 0)</pawn>
Example:
<pawn>static Float:origin[3] // Origin should be a Float
pev(id, pev_origin, origin) // Get user origin
engfunc(EngFunc_MessageBegin,MSG_BROADCAST,SVC_TEMPENTITY,origin,0) // Create message</pawn>
With MSG_ONE_UNRELIABLE:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>
With MSG_ALL:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>

dest can be:

#define MSG_BROADCAST 0 // Unreliable to all, There is not id
#define MSG_ONE 1 // Reliable to one (msg_entity)
#define MSG_ALL 2 // Reliable to all, There is not origin
#define MSG_INIT 3 // Write to the init string
#define MSG_PVS 4 // Ents in PVS of org
#define MSG_PAS 5 // Ents in PAS of org
#define MSG_PVS_R 6 // Reliable to PVS
#define MSG_PAS_R 7 // Reliable to PAS
#define MSG_ONE_UNRELIABLE 8 // Send to one client, but don't put in reliable stream,
// put in unreliable datagram (could be dropped), there is not origin
#define MSG_SPEC 9 // Sends to all spectator proxies

'''Before calling another EngFunc_MessageBegin you must call message_end().'''

== Entity Search Functions ==
=== EngFunc_FindEntityInSphere ===
Find entities within a radius. '''The function returns the next entity id after the start entity.'''

[[Image:FindEntityInSphere.png|thumb|3D diagram to show how the function works.]]
If we use
<pawn>engfunc(EngFunc_FindEntityInSphere, -1, origin, radius)</pawn>
In the situation described on the picture the function call above will return 1,
<pawn>engfunc(EngFunc_FindEntityInSphere, 20, origin, radius)</pawn>
will return 30 and
<pawn>engfunc(EngFunc_FindEntityInSphere, 100, origin, radius)</pawn>
will return 0, meaning that it didn't find an entity with an id grater than 100.

==== Usage ====
<pawn>engfunc(EngFunc_FindEntityInSphere, ent_to_start, origin, radius)</pawn>

=== EngFunc_EntitiesInPVS ===

This function checks entities that are in the [[PVS]] of an entity.
'''It can't be used on worldspawn.'''

The function returns the first entity on the [[PVS]] and then you can traverse through the results using pev_chain/EV_ENT_chain.
A NULL value of pev_chain/EV_ENT_chain indicates the end of the chain.

==== Usage ====
<pawn>public whatisonPVS(id)
{
static next, chain
static class[32]

next = engfunc(EngFunc_EntitiesInPVS, id)
while(next)
{
pev(next, pev_classname, class, charsmax(class))
chain = pev(next, pev_chain)

server_print("Found entity in player (%i) PVS: ent(%i) class(%s)", id, next, class)

if(!chain)
break

next = chain
}
}</pawn>

=== EngFunc_FindEntityByString ===
Returns the first entity found that matches the search criteria.

You can use any of string type attributes of entities:

classname Type of entity
globalname This is the name of the global variable that can be used to control the state of the entity
model The model of the entity
target Entity that this entity is handling
targetname The name given to this entity that another entity searches for to handle it
netname Player or NPC name
message Seems to be used mainly to store sound (string). It happens to store others things, depending the need of the entity
noise Noise variables do different things for different ents
noise1 This is the move sound for doors
noise2 This is the stop sound for doors
noise3 This is for blocking game_player_equip and player_weaponstrip

==== Usage ====
<pawn>iEnt = engfunc(EngFunc_FindEntityByString, iStartEnt, sAttribute, sValue)</pawn>
Parameters:
* iStartEnt: Start searching on this entity (ex: 0 = worldspawn)
* sAttribute: Name of attribute over which we need to search (ex: classname)
* sValue: Text string that we are searching for (ex: func_breakable)

The function returns the first entity matching the criteria.

=== EngFunc_FindClientInPVS ===
Returns the next "player" entity in someone's [[PVS]] using a global loop.

==== Usage ====
<pawn>iEnt2 = engfunc(EngFunc_FindClientInPVS, iEnt)</pawn>
Parameters:
* iEnt Source entity. Seek someone within iEnt's [[PVS]]

Unlike [[#EngFunc_EntitiesInPVS]], it does not return a series of chained entities. Instead, it works like a global loop of entities.
No matter which source entity you use, this function maintains the last index used and returns the next entity in source entity [[PVS]].

This function must be called several times to find every entity in [[PVS]] and can also return the source entity but it can't be called twice inside the same function because it will return the same entity.

==== Notes ====
It's not clear the main purpose of this function because you can get similar results with [[#EngFunc_EntitiesInPVS]].

[[#EngFunc_CheckVisibility]] and [[#EngFunc_EntitiesInPVS]] are better functions to use.

== Trace Functions ==
=== EngFunc_TraceLine ===
This function traces between 2 origins and gives us information about it.

These are the constants we can use as flags:

#define DONT_IGNORE_MONSTERS 0
#define IGNORE_MONSTERS 1
#define IGNORE_MISSILE 2
#define IGNORE_GLASS 0x100

'''These constants can be used together.'''

Ex: IGNORE_MISSILE | IGNORE_MONSTERS | IGNORE_GLASS - This makes the traceline ignore missiles, monsters (players) and glass.

==== Usage ====

Example of doing a traceline between two origins, and ignoring glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr)</pawn>

Now considering glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr)</pawn>

<gallery>
File:Traceline1.jpg|Traceline result if glass is ignored. The entity is ignored because of its solid flag
File:Traceline2.jpg|Traceline result if glass is not ignored.
File:Traceline3.jpg|Traceline result if glass is ignored but there's an entity with blocking solid flags in the way
File:Traceline4.jpg|Traceline result if glass is ignored, and the entity in the way has non-blocking flags
</gallery>

==== Other Traceline functions ====
This creates a trace handle. It's important to do this because we don't want our plugins to mess with eachothers info.
<pawn>new ptr = create_tr2()</pawn>

And this frees the trace handle:
<pawn>free_tr2(ptr)</pawn>

Getter and setter:
<pawn>[g|s]et_tr2(trace_handle, CONSTANT, argument_if_setting)</pawn>
Where CONSTANT can be one of the following enumerations:
<pawn>enum TraceResult
{
TR_AllSolid, // int
TR_StartSolid, // int
TR_InOpen, // int
TR_InWater, // int
TR_flFraction, // float
TR_vecEndPos, // float array[3]
TR_flPlaneDist, // float
TR_vecPlaneNormal, // float array[3]
TR_pHit, // int (edict_t*)
TR_iHitgroup, // int
};</pawn>

'''Getting the array and Float values require the third parameter to be passed.'''

Example:
<pawn>
new startsolid = get_tr2(trace, TR_StartSolid)
// TR_StartSolid is a boolean that says whether you were "inside" something
// (usually the world) when the trace started (point A)
// TR_AllSolid tells you if you ever got out of the "inside" or not.

new inopen = get_tr2(trace, TR_InOpen)
// TR_InOpen means that the start point is in Open
// That means in the world and not in an ent or something

new hit = get_tr2(trace, TR_pHit)
// What was hit by the traceline. It will either be a player index,
// entity index, 0 (part of map), or -1 (didn't hit anything;
// doesn't happen with player tracelines).

new hitgroup = get_tr2(trace, TR_iHitgroup)
// If the traceline hit another player, returns will be HIT_HEAD,
// HIT_CHEST, HIT_LEFTLEG... etc. If the traceline hit part of the
// map, this returns HIT_GENERIC.

new Float:fraction
get_tr2(trace, TR_flFraction, fraction)
// Returns a number between 0.0 and 1.0, indicating how far the
// traceline traveled start to end before it hit something. Depending
// on what conditions were passed to this traceline forward function,
// it could either be a wall or another entity.

new Float:end_origin[3]
get_tr2(trace, TR_vecEndPos, end_origin)
// The official end of the traceline. Not necesarily the same as the
// second argument passed to this traceline forward function.

new Float:normal[3]
get_tr2(trace, TR_vecPlaneNormal, normal)
// Returns a 1 unit long vector normal to the spot that it hit. Note
// that "normal" has a special connotation here. It doesn't mean "regular."
</pawn>

==== Useful Stocks ====
===== is_wall_between_points =====
This returns true if there's a wall between ''start'' and ''end''.
<pawn>stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
// Create the trace handle! It is best to create it!
new ptr = create_tr2()

// The main traceline function!
// This function ignores GLASS, MISSILE and MONSTERS!
// Here is an example of how you should combine all the flags!
engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS | IGNORE_MONSTERS | IGNORE_MISSILE, ignore_ent, ptr)

// We are interested in the fraction parameter
new fraction
get_tr2(ptr, TR_flFraction, fraction)

// Free the trace handle (don't forget to do this!)
free_tr2(ptr)

// If = 1.0 then it didn't hit anything!
return (fraction != 1.0)
}</pawn>

==== Extra Info ====
http://developer.valvesoftware.com/wiki/TraceLines

http://forums.alliedmods.net/showthread.php?t=66076

[[Category:Scripting (AMX Mod X)]]

=== EngFunc_TraceTexture, DLLFunc_PM_FindTextureType ===
The TraceTexture function detects the texture of an entity from a direction

The FindTextureType function allows to get the type of the material of the texture.

==== Usage ====
<pawn>engfunc(EngFunc_TraceTexture, ent, Float:start[3], Float:end[3], texture_name, len)</pawn>
* ent is the entity that we want to get the texture
* start is the point from where the trace starts
* end is the point where the trace ends
* texture_name - here we save the texture name
* len - the texture_name string length

<pawn>dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>
* texture_name is the name of the texture that we have gotten with TraceTexture

The function returns the material of the texture, which can be one of the following:

* C : concrete
* D : dirt
* G : grate
* M : metal
* N : snow
* P : computer
* S : slosh
* T : tile
* V : ventilation
* W : wood
* Y : glass

'''Example:'''

<pawn>new texture_name[64], texture_type
engfunc(EngFunc_TraceTexture, 0, start, end, texture_name, charsmax(texture_name))
texture_type = dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>

==== Notes ====
'''Improper use of these functions may crash the server!'''

To avoid crashing the server use the TraceTexture:
* on any entities (even worldspawn) except players
* when there is at least one player connected
* with a big distance between the two points (> 2000.0)

=== EngFunc_TraceModel ===
This function traces between 2 origins a model and gives us properties about it.
It acts just like a TraceLine but it ignores all the entities except the one we want to hit!

==== Usage ====
<pawn>engfunc(EngFunc_TraceModel, const Float:start[3], const Float:end[3], hull, ent_to_hit, ptr)</pawn>
* start - start origin
* end - end origin
* hull - the hull that is moved check above to see them
* ent_to_hit - the entity that you want to hit (this is a must!)
* ptr - the trace handle pointer, acts the same as the one in trace line!

The constants that we can use in hull:

#define HULL_POINT 0 // This means that we are moving a point from the start to the end
#define HULL_HUMAN 1 // That means that we move a cube of a player from start to end
#define HULL_LARGE 2 // That means that we move a bigger cube that one of the player from start to end
// (used in HL for big monsters!)
#define HULL_HEAD 3 // This means that we move from start to end the hull of a ducked player

==== Extra Info ====
TraceModel example: http://forums.alliedmods.net/showthread.php?p=850698

[[#EngFunc_TraceLine]] explanation.

=== EngFunc_TraceToss ===
Trace the point where some entity movement will finish.
If for some reason the entity movement must be blocked for other entity (or worldspawn), TraceToss will detect that situation taking in account the original entity bounding boxes.

==== Usage ====
<pawn>engfunc(EngFunc_TraceToss, ent, skipent, tr)</pawn>
* ent = The entity which movement we want to trace
* skipent = The entity to skip in trace
* tr = trace handle to store the result

[[Image:Tracetoss.jpg|thumb|EngFunc_TraceToss example]]
==== Example ====

In the image you can see a player jumping and 2 points.

''Start Point'' is the origin of the player when TraceToss was called.

''End Point'' is the point returned in TR result.

So the player is making a parabola from START to END.
The green line is only for testing purposes and show from where to where the trace is.
This was tested with gravity = 400.

== Model/Decal/Texture Functions ==
=== EngFunc_SetModel ===
Properly sets a new model on an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetModel, iEnt, sModel)</pawn>
* iEnt = Entity index
* sModel = Model file name to set on entity (ex: "models/player/vip/vip.mdl")

==== Engine Alternative ====
<pawn>entity_set_model(entity, model[])</pawn>
http://www.amxmodx.org/funcwiki.php?go=func&id=354

=== EngFunc_ModelIndex ===
Returns an unique index of the model name provided.
It's actually the same number that precache_model() returns.

A model index is used for example in some TE_* messages. ( TE_LIGHTNING, TE_GLOWSPRITE, etc.. See message_const.inc file ).

The model index of an entity is stored in pev_modelindex.

==== Usage ====
<pawn>ModelIndex = engfunc(EngFunc_ModelIndex, "models/MyModel.mdl")</pawn>
ModelIndex will have the model index for "models/MyModel.mdl" after the function call.

=== EngFunc_ModelFrames ===
Returns the frames count of a model.

==== Usage ====
<pawn>ModelFrames = engfunc(EngFunc_ModelFrames, ModelIndex)</pawn>
* ModelIndex = The model index. Value you can get from precache_model() or [[#EngFunc_ModelIndex|EngFunc_ModelIndex]].

=== EngFunc_DecalIndex ===
Returns an unique index of the decal name provided.

A decal index is used for example in some TE_* messages. ( TE_PLAYERDECAL, TE_DECAL, etc.. See message_const.inc file ).

All the available decals are stored in the decals.wad file. ( Located at your mod root directory )

As side-note a plugin [[http://forums.alliedmods.net/showthread.php?p=247677 "Decals/Models Lister"]] is available to see a list of decals/models index/name. ( Only CS and HL )

==== Usage ====
<pawn>DecalIndex = engfunc(EngFunc_DecalIndex, "{bigshot1")</pawn>
DecalIndex will have the decal index for "{bigshot1" after the function call.

FakeMeta Functions Detailed Descriptions

2010-09-07T16:13:31Z

Seta00: Added EngFunc_ModelFrames

== Point Functions ==
=== EngFunc_PointContents ===
This function checks an origin and gives us information of its whearabouts.

The constants that this function returns are these:
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7 // Removed at csg time
#define CONTENTS_CLIP -8 // Changed to contents_solid
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
#define CONTENTS_LADDER -16
#define CONTENT_FLYFIELD -17
#define CONTENT_GRAVITY_FLYFIELD -18
#define CONTENT_FOG -19

==== Usage ====
<pawn>static Float:origin[3]
static result
result = engfunc(EngFunc_PointContents, origin)
// if for example result is CONTENTS_SKY
// then the origin that we see is in the sky we can for example use this to see where a player is aming if he is aiming at sky this will be the result! </pawn>

=== EngFunc_GetBonePosition ===
[[Image:PlayerSkeleton.jpg|frame|This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.]]
This function allows to get the bone positions of an entity. This is best used on getting specific player origin points.

These are the bones that a player has:

Bone 1 Name: "Bip01"
Bone 2 Name: "Bip01 Pelvis"
Bone 3 Name: "Bip01 Spine"
Bone 4 Name: "Bip01 Spine1"
Bone 5 Name: "Bip01 Spine2"
Bone 6 Name: "Bip01 Spine3"
Bone 7 Name: "Bip01 Neck"
Bone 8 Name: "Bip01 Head"
Bone 9 Name: "Bone01"
Bone 10 Name: "Bip01 L Clavicle"
Bone 11 Name: "Bip01 L UpperArm"
Bone 12 Name: "Bip01 L Forearm"
Bone 13 Name: "Bip01 L Hand"
Bone 14 Name: "Bip01 L Finger0"
Bone 15 Name: "Bip01 L Finger01"
Bone 16 Name: "Bip01 L Finger1"
Bone 17 Name: "Bip01 L Finger11"
Bone 18 Name: "-- L knuckle"
Bone 19 Name: "-- L Forearm twist"
Bone 20 Name: "-- L wrist"
Bone 21 Name: "-- L Elbow"
Bone 22 Name: "-- L bicep twist"
Bone 23 Name: "-- L shoulder outside"
Bone 24 Name: "-- L Shoulder inside"
Bone 25 Name: "Bip01 R Clavicle"
Bone 26 Name: "Bip01 R UpperArm"
Bone 27 Name: "Bip01 R Forearm"
Bone 28 Name: "Bip01 R Hand"
Bone 29 Name: "Bip01 R Finger0"
Bone 30 Name: "Bip01 R Finger01"
Bone 31 Name: "Bip01 R Finger1"
Bone 32 Name: "Bip01 R Finger11"
Bone 33 Name: "-- R knuckle"
Bone 34 Name: "-- R wrist"
Bone 35 Name: "-- R forearm twist"
Bone 36 Name: "-- R Elbow"
Bone 37 Name: "-- R bicep twist"
Bone 38 Name: "-- R Shoulder inside"
Bone 39 Name: "-- R shoulder outside"
Bone 40 Name: "-- Neck smooth"
Bone 41 Name: "-- R Butt"
Bone 42 Name: "-- L butt"
Bone 43 Name: "Bip01 L Thigh"
Bone 44 Name: "Bip01 L Calf"
Bone 45 Name: "Bip01 L Foot"
Bone 46 Name: "Bip01 L Toe0"
Bone 47 Name: "-- L ankle"
Bone 48 Name: "-- L Knee"
Bone 49 Name: "Bip01 R Thigh"
Bone 50 Name: "Bip01 R Calf"
Bone 51 Name: "Bip01 R Foot"
Bone 52 Name: "Bip01 R Toe0"
Bone 53 Name: "-- R Ankle"
Bone 54 Name: "-- R Knee"
Bone 55 Name: "Bomb"

==== Usage ====
<pawn>// ENTITY is the player entity id
// BONE_NUMBER you have to choose from the list above
// bone_origin[3] is the vector where we save the bone origin
// bone_angles[3] the vector that holds the angles of the bone.
engfunc(EngFunc_GetBonePosition, ENTITY, BONE_NUMBER, Float:bone_origin[3], Float:bone_angles[3])</pawn>

==== Useful Stocks ====
These stocks are made for CS/CZ, you need to port them to other mods.
===== get_bone_hitgroup =====
This gets the hitgroup of the bone:
<pawn>#define BONE_HIT_HEAD 8
#define BONE_HIT_CHEST 6
#define BONE_HIT_STOMACH 4
#define BONE_HIT_LEFTARM 24
#define BONE_HIT_RIGHTARM 39
#define BONE_HIT_LEFTLEG 48
#define BONE_HIT_RIGHTLEG 54
#define HEAD_NECK 40
#define BONE_L_BUTT 41
#define BONE_R_BUTT 42

stock get_bone_hitgroup(number)
{
switch (number)
{
case HEAD_NECK:
{
return HIT_HEAD
}
case BONE_L_BUTT:
{
return HIT_LEFTLEG
}
case BONE_R_BUTT:
{
return HIT_RIGHTLEG
}
}

if (1 <= number <= BONE_HIT_STOMACH)
return HIT_STOMACH

if (BONE_HIT_STOMACH < number <= BONE_HIT_CHEST)
return HIT_CHEST

if (BONE_HIT_CHEST < number <= BONE_HIT_HEAD)
return HIT_HEAD

if (BONE_HIT_HEAD < number <= BONE_HIT_LEFTARM)
return HIT_LEFTARM

if (BONE_HIT_LEFTARM < number <= BONE_HIT_RIGHTARM)
return HIT_RIGHTARM

if (BONE_HIT_RIGHTARM < number <= BONE_HIT_LEFTLEG)
return HIT_LEFTLEG

if (BONE_HIT_LEFTLEG < number <= BONE_HIT_RIGHTLEG)
return HIT_RIGHTLEG

return HIT_GENERIC
}</pawn>

===== find_closest_bone_to_gunshot =====
This gets the closest bone to the gunshot (Use this in FM_TraceLine and Ham_TraceAttack):
<pawn>#define DISTANCE_CLEAR_HIT 2.0

stock find_closest_bone_to_gunshot(victim, Float:endtrace[3])
{
new Float:angles[3], Float:origin[3], Float:dist = 9999999.99, Float:curorigin[3], bone_nr
for (new i=1;i<=54;i++)
{
// Get the bone position
engfunc(EngFunc_GetBonePosition, victim, i, curorigin, angles)
// Calculate the distance vector
xs_vec_sub(curorigin, endtrace, angles)

// If this is smaller than the last small distance remember the value!
if (xs_vec_len(angles) <= dist)
{
origin = curorigin
dist = xs_vec_len(angles)
bone_nr = i
}

// If distance is smaller than CLEARHIT! Break (We accept the last value!)
if (dist <= DISTANCE_CLEAR_HIT)
{
break
}
}

// Return the bone
return bone_nr
}</pawn>

== Messaging Functions ==
=== EngFunc_MessageBegin ===
This function is used to generate client messages.

==== Usage ====
Syntax:
<pawn>engfunc(EngFunc_MessageBegin, dest, msg_type, origin[3] = {0, 0, 0}, player = 0)</pawn>
Example:
<pawn>static Float:origin[3] // Origin should be a Float
pev(id, pev_origin, origin) // Get user origin
engfunc(EngFunc_MessageBegin,MSG_BROADCAST,SVC_TEMPENTITY,origin,0) // Create message</pawn>
With MSG_ONE_UNRELIABLE:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>
With MSG_ALL:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>

dest can be:

#define MSG_BROADCAST 0 // Unreliable to all, There is not id
#define MSG_ONE 1 // Reliable to one (msg_entity)
#define MSG_ALL 2 // Reliable to all, There is not origin
#define MSG_INIT 3 // Write to the init string
#define MSG_PVS 4 // Ents in PVS of org
#define MSG_PAS 5 // Ents in PAS of org
#define MSG_PVS_R 6 // Reliable to PVS
#define MSG_PAS_R 7 // Reliable to PAS
#define MSG_ONE_UNRELIABLE 8 // Send to one client, but don't put in reliable stream,
// put in unreliable datagram (could be dropped), there is not origin
#define MSG_SPEC 9 // Sends to all spectator proxies

'''Before calling another EngFunc_MessageBegin you must call message_end().'''

== Entity Search Functions ==
=== EngFunc_FindEntityInSphere ===
Find entities within a radius. '''The function returns the next entity id after the start entity.'''

[[Image:FindEntityInSphere.png|thumb|3D diagram to show how the function works.]]
If we use
<pawn>engfunc(EngFunc_FindEntityInSphere, -1, origin, radius)</pawn>
In the situation described on the picture the function call above will return 1,
<pawn>engfunc(EngFunc_FindEntityInSphere, 20, origin, radius)</pawn>
will return 30 and
<pawn>engfunc(EngFunc_FindEntityInSphere, 100, origin, radius)</pawn>
will return 0, meaning that it didn't find an entity with an id grater than 100.

==== Usage ====
<pawn>engfunc(EngFunc_FindEntityInSphere, ent_to_start, origin, radius)</pawn>

=== EngFunc_EntitiesInPVS ===

This function checks entities that are in the [[PVS]] of an entity.
'''It can't be used on worldspawn.'''

The function returns the first entity on the [[PVS]] and then you can traverse through the results using pev_chain/EV_ENT_chain.
A NULL value of pev_chain/EV_ENT_chain indicates the end of the chain.

==== Usage ====
<pawn>public whatisonPVS(id)
{
static next, chain
static class[32]

next = engfunc(EngFunc_EntitiesInPVS, id)
while(next)
{
pev(next, pev_classname, class, charsmax(class))
chain = pev(next, pev_chain)

server_print("Found entity in player (%i) PVS: ent(%i) class(%s)", id, next, class)

if(!chain)
break

next = chain
}
}</pawn>

=== EngFunc_FindEntityByString ===
Returns the first entity found that matches the search criteria.

You can use any of string type attributes of entities:

classname Type of entity
globalname This is the name of the global variable that can be used to control the state of the entity
model The model of the entity
target Entity that this entity is handling
targetname The name given to this entity that another entity searches for to handle it
netname Player or NPC name
message Seems to be used mainly to store sound (string). It happens to store others things, depending the need of the entity
noise Noise variables do different things for different ents
noise1 This is the move sound for doors
noise2 This is the stop sound for doors
noise3 This is for blocking game_player_equip and player_weaponstrip

==== Usage ====
<pawn>iEnt = engfunc(EngFunc_FindEntityByString, iStartEnt, sAttribute, sValue)</pawn>
Parameters:
* iStartEnt: Start searching on this entity (ex: 0 = worldspawn)
* sAttribute: Name of attribute over which we need to search (ex: classname)
* sValue: Text string that we are searching for (ex: func_breakable)

The function returns the first entity matching the criteria.

=== EngFunc_FindClientInPVS ===
Returns the next "player" entity in someone's [[PVS]] using a global loop.

==== Usage ====
<pawn>iEnt2 = engfunc(EngFunc_FindClientInPVS, iEnt)</pawn>
Parameters:
* iEnt Source entity. Seek someone within iEnt's [[PVS]]

Unlike [[#EngFunc_EntitiesInPVS]], it does not return a series of chained entities. Instead, it works like a global loop of entities.
No matter which source entity you use, this function maintains the last index used and returns the next entity in source entity [[PVS]].

This function must be called several times to find every entity in [[PVS]] and can also return the source entity but it can't be called twice inside the same function because it will return the same entity.

==== Notes ====
It's not clear the main purpose of this function because you can get similar results with [[#EngFunc_EntitiesInPVS]].

[[#EngFunc_CheckVisibility]] and [[#EngFunc_EntitiesInPVS]] are better functions to use.

== Trace Functions ==
=== EngFunc_TraceLine ===
This function traces between 2 origins and gives us information about it.

These are the constants we can use as flags:

#define DONT_IGNORE_MONSTERS 0
#define IGNORE_MONSTERS 1
#define IGNORE_MISSILE 2
#define IGNORE_GLASS 0x100

'''These constants can be used together.'''

Ex: IGNORE_MISSILE | IGNORE_MONSTERS | IGNORE_GLASS - This makes the traceline ignore missiles, monsters (players) and glass.

==== Usage ====

Example of doing a traceline between two origins, and ignoring glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr)</pawn>

Now considering glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr)</pawn>

<gallery>
File:Traceline1.jpg|Traceline result if glass is ignored. The entity is ignored because of its solid flag
File:Traceline2.jpg|Traceline result if glass is not ignored.
File:Traceline3.jpg|Traceline result if glass is ignored but there's an entity with blocking solid flags in the way
File:Traceline4.jpg|Traceline result if glass is ignored, and the entity in the way has non-blocking flags
</gallery>

==== Other Traceline functions ====
This creates a trace handle. It's important to do this because we don't want our plugins to mess with eachothers info.
<pawn>new ptr = create_tr2()</pawn>

And this frees the trace handle:
<pawn>free_tr2(ptr)</pawn>

Getter and setter:
<pawn>[g|s]et_tr2(trace_handle, CONSTANT, argument_if_setting)</pawn>
Where CONSTANT can be one of the following enumerations:
<pawn>enum TraceResult
{
TR_AllSolid, // int
TR_StartSolid, // int
TR_InOpen, // int
TR_InWater, // int
TR_flFraction, // float
TR_vecEndPos, // float array[3]
TR_flPlaneDist, // float
TR_vecPlaneNormal, // float array[3]
TR_pHit, // int (edict_t*)
TR_iHitgroup, // int
};</pawn>

'''Getting the array and Float values require the third parameter to be passed.'''

Example:
<pawn>
new startsolid = get_tr2(trace, TR_StartSolid)
// TR_StartSolid is a boolean that says whether you were "inside" something
// (usually the world) when the trace started (point A)
// TR_AllSolid tells you if you ever got out of the "inside" or not.

new inopen = get_tr2(trace, TR_InOpen)
// TR_InOpen means that the start point is in Open
// That means in the world and not in an ent or something

new hit = get_tr2(trace, TR_pHit)
// What was hit by the traceline. It will either be a player index,
// entity index, 0 (part of map), or -1 (didn't hit anything;
// doesn't happen with player tracelines).

new hitgroup = get_tr2(trace, TR_iHitgroup)
// If the traceline hit another player, returns will be HIT_HEAD,
// HIT_CHEST, HIT_LEFTLEG... etc. If the traceline hit part of the
// map, this returns HIT_GENERIC.

new Float:fraction
get_tr2(trace, TR_flFraction, fraction)
// Returns a number between 0.0 and 1.0, indicating how far the
// traceline traveled start to end before it hit something. Depending
// on what conditions were passed to this traceline forward function,
// it could either be a wall or another entity.

new Float:end_origin[3]
get_tr2(trace, TR_vecEndPos, end_origin)
// The official end of the traceline. Not necesarily the same as the
// second argument passed to this traceline forward function.

new Float:normal[3]
get_tr2(trace, TR_vecPlaneNormal, normal)
// Returns a 1 unit long vector normal to the spot that it hit. Note
// that "normal" has a special connotation here. It doesn't mean "regular."
</pawn>

==== Useful Stocks ====
===== is_wall_between_points =====
This returns true if there's a wall between ''start'' and ''end''.
<pawn>stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
// Create the trace handle! It is best to create it!
new ptr = create_tr2()

// The main traceline function!
// This function ignores GLASS, MISSILE and MONSTERS!
// Here is an example of how you should combine all the flags!
engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS | IGNORE_MONSTERS | IGNORE_MISSILE, ignore_ent, ptr)

// We are interested in the fraction parameter
new fraction
get_tr2(ptr, TR_flFraction, fraction)

// Free the trace handle (don't forget to do this!)
free_tr2(ptr)

// If = 1.0 then it didn't hit anything!
return (fraction != 1.0)
}</pawn>

==== Extra Info ====
http://developer.valvesoftware.com/wiki/TraceLines

http://forums.alliedmods.net/showthread.php?t=66076

[[Category:Scripting (AMX Mod X)]]

=== EngFunc_TraceTexture, DLLFunc_PM_FindTextureType ===
The TraceTexture function detects the texture of an entity from a direction

The FindTextureType function allows to get the type of the material of the texture.

==== Usage ====
<pawn>engfunc(EngFunc_TraceTexture, ent, Float:start[3], Float:end[3], texture_name, len)</pawn>
* ent is the entity that we want to get the texture
* start is the point from where the trace starts
* end is the point where the trace ends
* texture_name - here we save the texture name
* len - the texture_name string length

<pawn>dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>
* texture_name is the name of the texture that we have gotten with TraceTexture

The function returns the material of the texture, which can be one of the following:

* C : concrete
* D : dirt
* G : grate
* M : metal
* N : snow
* P : computer
* S : slosh
* T : tile
* V : ventilation
* W : wood
* Y : glass

'''Example:'''

<pawn>new texture_name[64], texture_type
engfunc(EngFunc_TraceTexture, 0, start, end, texture_name, charsmax(texture_name))
texture_type = dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>

==== Notes ====
'''Improper use of these functions may crash the server!'''

To avoid crashing the server use the TraceTexture:
* on any entities (even worldspawn) except players
* when there is at least one player connected
* with a big distance between the two points (> 2000.0)

=== EngFunc_TraceModel ===
This function traces between 2 origins a model and gives us properties about it.
It acts just like a TraceLine but it ignores all the entities except the one we want to hit!

==== Usage ====
<pawn>engfunc(EngFunc_TraceModel, const Float:start[3], const Float:end[3], hull, ent_to_hit, ptr)</pawn>
* start - start origin
* end - end origin
* hull - the hull that is moved check above to see them
* ent_to_hit - the entity that you want to hit (this is a must!)
* ptr - the trace handle pointer, acts the same as the one in trace line!

The constants that we can use in hull:

#define HULL_POINT 0 // This means that we are moving a point from the start to the end
#define HULL_HUMAN 1 // That means that we move a cube of a player from start to end
#define HULL_LARGE 2 // That means that we move a bigger cube that one of the player from start to end
// (used in HL for big monsters!)
#define HULL_HEAD 3 // This means that we move from start to end the hull of a ducked player

==== Extra Info ====
TraceModel example: http://forums.alliedmods.net/showthread.php?p=850698

[[#EngFunc_TraceLine]] explanation.

=== EngFunc_TraceToss ===
Trace the point where some entity movement will finish.
If for some reason the entity movement must be blocked for other entity (or worldspawn), TraceToss will detect that situation taking in account the original entity bounding boxes.

==== Usage ====
<pawn>engfunc(EngFunc_TraceToss, ent, skipent, tr)</pawn>
* ent = The entity which movement we want to trace
* skipent = The entity to skip in trace
* tr = trace handle to store the result

[[Image:Tracetoss.jpg|thumb|EngFunc_TraceToss example]]
==== Example ====

In the image you can see a player jumping and 2 points.

''Start Point'' is the origin of the player when TraceToss was called.

''End Point'' is the point returned in TR result.

So the player is making a parabola from START to END.
The green line is only for testing purposes and show from where to where the trace is.
This was tested with gravity = 400.

== Model/Decal/Texture Functions ==
=== EngFunc_SetModel ===
Properly sets a new model on an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetModel, iEnt, sModel)</pawn>
* iEnt = Entity index
* sModel = Model file name to set on entity (ex: "models/player/vip/vip.mdl")

==== Engine Alternative ====
<pawn>entity_set_model(entity, model[])</pawn>
http://www.amxmodx.org/funcwiki.php?go=func&id=354

=== EngFunc_ModelIndex ===
Returns an unique index of the model name provided.
It's actually the same number that precache_model() returns.

A model index is used for example in some TE_* messages. ( TE_LIGHTNING, TE_GLOWSPRITE, etc.. See message_const.inc file ).

The model index of an entity is stored in pev_modelindex.

==== Usage ====
<pawn>ModelIndex = engfunc(EngFunc_ModelIndex, "models/MyModel.mdl")</pawn>
ModelIndex will have the model index for "models/MyModel.mdl" after the function call.

=== EngFunc_ModelFrames ===
Returns the frames count of a model.

==== Usage ====
<pawn>ModelFrames = engfunc(EngFunc_ModelFrames, ModelIndex)</pawn>
* ModelIndex = The model index. Value you can get from precache_model() or [[#EngFunc_ModelIndex]].

FakeMeta Functions Detailed Descriptions

2010-09-07T16:11:55Z

Seta00: Added EngFunc_ModelIndex

== Point Functions ==
=== EngFunc_PointContents ===
This function checks an origin and gives us information of its whearabouts.

The constants that this function returns are these:
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7 // Removed at csg time
#define CONTENTS_CLIP -8 // Changed to contents_solid
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
#define CONTENTS_LADDER -16
#define CONTENT_FLYFIELD -17
#define CONTENT_GRAVITY_FLYFIELD -18
#define CONTENT_FOG -19

==== Usage ====
<pawn>static Float:origin[3]
static result
result = engfunc(EngFunc_PointContents, origin)
// if for example result is CONTENTS_SKY
// then the origin that we see is in the sky we can for example use this to see where a player is aming if he is aiming at sky this will be the result! </pawn>

=== EngFunc_GetBonePosition ===
[[Image:PlayerSkeleton.jpg|frame|This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.]]
This function allows to get the bone positions of an entity. This is best used on getting specific player origin points.

These are the bones that a player has:

Bone 1 Name: "Bip01"
Bone 2 Name: "Bip01 Pelvis"
Bone 3 Name: "Bip01 Spine"
Bone 4 Name: "Bip01 Spine1"
Bone 5 Name: "Bip01 Spine2"
Bone 6 Name: "Bip01 Spine3"
Bone 7 Name: "Bip01 Neck"
Bone 8 Name: "Bip01 Head"
Bone 9 Name: "Bone01"
Bone 10 Name: "Bip01 L Clavicle"
Bone 11 Name: "Bip01 L UpperArm"
Bone 12 Name: "Bip01 L Forearm"
Bone 13 Name: "Bip01 L Hand"
Bone 14 Name: "Bip01 L Finger0"
Bone 15 Name: "Bip01 L Finger01"
Bone 16 Name: "Bip01 L Finger1"
Bone 17 Name: "Bip01 L Finger11"
Bone 18 Name: "-- L knuckle"
Bone 19 Name: "-- L Forearm twist"
Bone 20 Name: "-- L wrist"
Bone 21 Name: "-- L Elbow"
Bone 22 Name: "-- L bicep twist"
Bone 23 Name: "-- L shoulder outside"
Bone 24 Name: "-- L Shoulder inside"
Bone 25 Name: "Bip01 R Clavicle"
Bone 26 Name: "Bip01 R UpperArm"
Bone 27 Name: "Bip01 R Forearm"
Bone 28 Name: "Bip01 R Hand"
Bone 29 Name: "Bip01 R Finger0"
Bone 30 Name: "Bip01 R Finger01"
Bone 31 Name: "Bip01 R Finger1"
Bone 32 Name: "Bip01 R Finger11"
Bone 33 Name: "-- R knuckle"
Bone 34 Name: "-- R wrist"
Bone 35 Name: "-- R forearm twist"
Bone 36 Name: "-- R Elbow"
Bone 37 Name: "-- R bicep twist"
Bone 38 Name: "-- R Shoulder inside"
Bone 39 Name: "-- R shoulder outside"
Bone 40 Name: "-- Neck smooth"
Bone 41 Name: "-- R Butt"
Bone 42 Name: "-- L butt"
Bone 43 Name: "Bip01 L Thigh"
Bone 44 Name: "Bip01 L Calf"
Bone 45 Name: "Bip01 L Foot"
Bone 46 Name: "Bip01 L Toe0"
Bone 47 Name: "-- L ankle"
Bone 48 Name: "-- L Knee"
Bone 49 Name: "Bip01 R Thigh"
Bone 50 Name: "Bip01 R Calf"
Bone 51 Name: "Bip01 R Foot"
Bone 52 Name: "Bip01 R Toe0"
Bone 53 Name: "-- R Ankle"
Bone 54 Name: "-- R Knee"
Bone 55 Name: "Bomb"

==== Usage ====
<pawn>// ENTITY is the player entity id
// BONE_NUMBER you have to choose from the list above
// bone_origin[3] is the vector where we save the bone origin
// bone_angles[3] the vector that holds the angles of the bone.
engfunc(EngFunc_GetBonePosition, ENTITY, BONE_NUMBER, Float:bone_origin[3], Float:bone_angles[3])</pawn>

==== Useful Stocks ====
These stocks are made for CS/CZ, you need to port them to other mods.
===== get_bone_hitgroup =====
This gets the hitgroup of the bone:
<pawn>#define BONE_HIT_HEAD 8
#define BONE_HIT_CHEST 6
#define BONE_HIT_STOMACH 4
#define BONE_HIT_LEFTARM 24
#define BONE_HIT_RIGHTARM 39
#define BONE_HIT_LEFTLEG 48
#define BONE_HIT_RIGHTLEG 54
#define HEAD_NECK 40
#define BONE_L_BUTT 41
#define BONE_R_BUTT 42

stock get_bone_hitgroup(number)
{
switch (number)
{
case HEAD_NECK:
{
return HIT_HEAD
}
case BONE_L_BUTT:
{
return HIT_LEFTLEG
}
case BONE_R_BUTT:
{
return HIT_RIGHTLEG
}
}

if (1 <= number <= BONE_HIT_STOMACH)
return HIT_STOMACH

if (BONE_HIT_STOMACH < number <= BONE_HIT_CHEST)
return HIT_CHEST

if (BONE_HIT_CHEST < number <= BONE_HIT_HEAD)
return HIT_HEAD

if (BONE_HIT_HEAD < number <= BONE_HIT_LEFTARM)
return HIT_LEFTARM

if (BONE_HIT_LEFTARM < number <= BONE_HIT_RIGHTARM)
return HIT_RIGHTARM

if (BONE_HIT_RIGHTARM < number <= BONE_HIT_LEFTLEG)
return HIT_LEFTLEG

if (BONE_HIT_LEFTLEG < number <= BONE_HIT_RIGHTLEG)
return HIT_RIGHTLEG

return HIT_GENERIC
}</pawn>

===== find_closest_bone_to_gunshot =====
This gets the closest bone to the gunshot (Use this in FM_TraceLine and Ham_TraceAttack):
<pawn>#define DISTANCE_CLEAR_HIT 2.0

stock find_closest_bone_to_gunshot(victim, Float:endtrace[3])
{
new Float:angles[3], Float:origin[3], Float:dist = 9999999.99, Float:curorigin[3], bone_nr
for (new i=1;i<=54;i++)
{
// Get the bone position
engfunc(EngFunc_GetBonePosition, victim, i, curorigin, angles)
// Calculate the distance vector
xs_vec_sub(curorigin, endtrace, angles)

// If this is smaller than the last small distance remember the value!
if (xs_vec_len(angles) <= dist)
{
origin = curorigin
dist = xs_vec_len(angles)
bone_nr = i
}

// If distance is smaller than CLEARHIT! Break (We accept the last value!)
if (dist <= DISTANCE_CLEAR_HIT)
{
break
}
}

// Return the bone
return bone_nr
}</pawn>

== Messaging Functions ==
=== EngFunc_MessageBegin ===
This function is used to generate client messages.

==== Usage ====
Syntax:
<pawn>engfunc(EngFunc_MessageBegin, dest, msg_type, origin[3] = {0, 0, 0}, player = 0)</pawn>
Example:
<pawn>static Float:origin[3] // Origin should be a Float
pev(id, pev_origin, origin) // Get user origin
engfunc(EngFunc_MessageBegin,MSG_BROADCAST,SVC_TEMPENTITY,origin,0) // Create message</pawn>
With MSG_ONE_UNRELIABLE:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>
With MSG_ALL:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>

dest can be:

#define MSG_BROADCAST 0 // Unreliable to all, There is not id
#define MSG_ONE 1 // Reliable to one (msg_entity)
#define MSG_ALL 2 // Reliable to all, There is not origin
#define MSG_INIT 3 // Write to the init string
#define MSG_PVS 4 // Ents in PVS of org
#define MSG_PAS 5 // Ents in PAS of org
#define MSG_PVS_R 6 // Reliable to PVS
#define MSG_PAS_R 7 // Reliable to PAS
#define MSG_ONE_UNRELIABLE 8 // Send to one client, but don't put in reliable stream,
// put in unreliable datagram (could be dropped), there is not origin
#define MSG_SPEC 9 // Sends to all spectator proxies

'''Before calling another EngFunc_MessageBegin you must call message_end().'''

== Entity Search Functions ==
=== EngFunc_FindEntityInSphere ===
Find entities within a radius. '''The function returns the next entity id after the start entity.'''

[[Image:FindEntityInSphere.png|thumb|3D diagram to show how the function works.]]
If we use
<pawn>engfunc(EngFunc_FindEntityInSphere, -1, origin, radius)</pawn>
In the situation described on the picture the function call above will return 1,
<pawn>engfunc(EngFunc_FindEntityInSphere, 20, origin, radius)</pawn>
will return 30 and
<pawn>engfunc(EngFunc_FindEntityInSphere, 100, origin, radius)</pawn>
will return 0, meaning that it didn't find an entity with an id grater than 100.

==== Usage ====
<pawn>engfunc(EngFunc_FindEntityInSphere, ent_to_start, origin, radius)</pawn>

=== EngFunc_EntitiesInPVS ===

This function checks entities that are in the [[PVS]] of an entity.
'''It can't be used on worldspawn.'''

The function returns the first entity on the [[PVS]] and then you can traverse through the results using pev_chain/EV_ENT_chain.
A NULL value of pev_chain/EV_ENT_chain indicates the end of the chain.

==== Usage ====
<pawn>public whatisonPVS(id)
{
static next, chain
static class[32]

next = engfunc(EngFunc_EntitiesInPVS, id)
while(next)
{
pev(next, pev_classname, class, charsmax(class))
chain = pev(next, pev_chain)

server_print("Found entity in player (%i) PVS: ent(%i) class(%s)", id, next, class)

if(!chain)
break

next = chain
}
}</pawn>

=== EngFunc_FindEntityByString ===
Returns the first entity found that matches the search criteria.

You can use any of string type attributes of entities:

classname Type of entity
globalname This is the name of the global variable that can be used to control the state of the entity
model The model of the entity
target Entity that this entity is handling
targetname The name given to this entity that another entity searches for to handle it
netname Player or NPC name
message Seems to be used mainly to store sound (string). It happens to store others things, depending the need of the entity
noise Noise variables do different things for different ents
noise1 This is the move sound for doors
noise2 This is the stop sound for doors
noise3 This is for blocking game_player_equip and player_weaponstrip

==== Usage ====
<pawn>iEnt = engfunc(EngFunc_FindEntityByString, iStartEnt, sAttribute, sValue)</pawn>
Parameters:
* iStartEnt: Start searching on this entity (ex: 0 = worldspawn)
* sAttribute: Name of attribute over which we need to search (ex: classname)
* sValue: Text string that we are searching for (ex: func_breakable)

The function returns the first entity matching the criteria.

=== EngFunc_FindClientInPVS ===
Returns the next "player" entity in someone's [[PVS]] using a global loop.

==== Usage ====
<pawn>iEnt2 = engfunc(EngFunc_FindClientInPVS, iEnt)</pawn>
Parameters:
* iEnt Source entity. Seek someone within iEnt's [[PVS]]

Unlike [[#EngFunc_EntitiesInPVS]], it does not return a series of chained entities. Instead, it works like a global loop of entities.
No matter which source entity you use, this function maintains the last index used and returns the next entity in source entity [[PVS]].

This function must be called several times to find every entity in [[PVS]] and can also return the source entity but it can't be called twice inside the same function because it will return the same entity.

==== Notes ====
It's not clear the main purpose of this function because you can get similar results with [[#EngFunc_EntitiesInPVS]].

[[#EngFunc_CheckVisibility]] and [[#EngFunc_EntitiesInPVS]] are better functions to use.

== Trace Functions ==
=== EngFunc_TraceLine ===
This function traces between 2 origins and gives us information about it.

These are the constants we can use as flags:

#define DONT_IGNORE_MONSTERS 0
#define IGNORE_MONSTERS 1
#define IGNORE_MISSILE 2
#define IGNORE_GLASS 0x100

'''These constants can be used together.'''

Ex: IGNORE_MISSILE | IGNORE_MONSTERS | IGNORE_GLASS - This makes the traceline ignore missiles, monsters (players) and glass.

==== Usage ====

Example of doing a traceline between two origins, and ignoring glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr)</pawn>

Now considering glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr)</pawn>

<gallery>
File:Traceline1.jpg|Traceline result if glass is ignored. The entity is ignored because of its solid flag
File:Traceline2.jpg|Traceline result if glass is not ignored.
File:Traceline3.jpg|Traceline result if glass is ignored but there's an entity with blocking solid flags in the way
File:Traceline4.jpg|Traceline result if glass is ignored, and the entity in the way has non-blocking flags
</gallery>

==== Other Traceline functions ====
This creates a trace handle. It's important to do this because we don't want our plugins to mess with eachothers info.
<pawn>new ptr = create_tr2()</pawn>

And this frees the trace handle:
<pawn>free_tr2(ptr)</pawn>

Getter and setter:
<pawn>[g|s]et_tr2(trace_handle, CONSTANT, argument_if_setting)</pawn>
Where CONSTANT can be one of the following enumerations:
<pawn>enum TraceResult
{
TR_AllSolid, // int
TR_StartSolid, // int
TR_InOpen, // int
TR_InWater, // int
TR_flFraction, // float
TR_vecEndPos, // float array[3]
TR_flPlaneDist, // float
TR_vecPlaneNormal, // float array[3]
TR_pHit, // int (edict_t*)
TR_iHitgroup, // int
};</pawn>

'''Getting the array and Float values require the third parameter to be passed.'''

Example:
<pawn>
new startsolid = get_tr2(trace, TR_StartSolid)
// TR_StartSolid is a boolean that says whether you were "inside" something
// (usually the world) when the trace started (point A)
// TR_AllSolid tells you if you ever got out of the "inside" or not.

new inopen = get_tr2(trace, TR_InOpen)
// TR_InOpen means that the start point is in Open
// That means in the world and not in an ent or something

new hit = get_tr2(trace, TR_pHit)
// What was hit by the traceline. It will either be a player index,
// entity index, 0 (part of map), or -1 (didn't hit anything;
// doesn't happen with player tracelines).

new hitgroup = get_tr2(trace, TR_iHitgroup)
// If the traceline hit another player, returns will be HIT_HEAD,
// HIT_CHEST, HIT_LEFTLEG... etc. If the traceline hit part of the
// map, this returns HIT_GENERIC.

new Float:fraction
get_tr2(trace, TR_flFraction, fraction)
// Returns a number between 0.0 and 1.0, indicating how far the
// traceline traveled start to end before it hit something. Depending
// on what conditions were passed to this traceline forward function,
// it could either be a wall or another entity.

new Float:end_origin[3]
get_tr2(trace, TR_vecEndPos, end_origin)
// The official end of the traceline. Not necesarily the same as the
// second argument passed to this traceline forward function.

new Float:normal[3]
get_tr2(trace, TR_vecPlaneNormal, normal)
// Returns a 1 unit long vector normal to the spot that it hit. Note
// that "normal" has a special connotation here. It doesn't mean "regular."
</pawn>

==== Useful Stocks ====
===== is_wall_between_points =====
This returns true if there's a wall between ''start'' and ''end''.
<pawn>stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
// Create the trace handle! It is best to create it!
new ptr = create_tr2()

// The main traceline function!
// This function ignores GLASS, MISSILE and MONSTERS!
// Here is an example of how you should combine all the flags!
engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS | IGNORE_MONSTERS | IGNORE_MISSILE, ignore_ent, ptr)

// We are interested in the fraction parameter
new fraction
get_tr2(ptr, TR_flFraction, fraction)

// Free the trace handle (don't forget to do this!)
free_tr2(ptr)

// If = 1.0 then it didn't hit anything!
return (fraction != 1.0)
}</pawn>

==== Extra Info ====
http://developer.valvesoftware.com/wiki/TraceLines

http://forums.alliedmods.net/showthread.php?t=66076

[[Category:Scripting (AMX Mod X)]]

=== EngFunc_TraceTexture, DLLFunc_PM_FindTextureType ===
The TraceTexture function detects the texture of an entity from a direction

The FindTextureType function allows to get the type of the material of the texture.

==== Usage ====
<pawn>engfunc(EngFunc_TraceTexture, ent, Float:start[3], Float:end[3], texture_name, len)</pawn>
* ent is the entity that we want to get the texture
* start is the point from where the trace starts
* end is the point where the trace ends
* texture_name - here we save the texture name
* len - the texture_name string length

<pawn>dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>
* texture_name is the name of the texture that we have gotten with TraceTexture

The function returns the material of the texture, which can be one of the following:

* C : concrete
* D : dirt
* G : grate
* M : metal
* N : snow
* P : computer
* S : slosh
* T : tile
* V : ventilation
* W : wood
* Y : glass

'''Example:'''

<pawn>new texture_name[64], texture_type
engfunc(EngFunc_TraceTexture, 0, start, end, texture_name, charsmax(texture_name))
texture_type = dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>

==== Notes ====
'''Improper use of these functions may crash the server!'''

To avoid crashing the server use the TraceTexture:
* on any entities (even worldspawn) except players
* when there is at least one player connected
* with a big distance between the two points (> 2000.0)

=== EngFunc_TraceModel ===
This function traces between 2 origins a model and gives us properties about it.
It acts just like a TraceLine but it ignores all the entities except the one we want to hit!

==== Usage ====
<pawn>engfunc(EngFunc_TraceModel, const Float:start[3], const Float:end[3], hull, ent_to_hit, ptr)</pawn>
* start - start origin
* end - end origin
* hull - the hull that is moved check above to see them
* ent_to_hit - the entity that you want to hit (this is a must!)
* ptr - the trace handle pointer, acts the same as the one in trace line!

The constants that we can use in hull:

#define HULL_POINT 0 // This means that we are moving a point from the start to the end
#define HULL_HUMAN 1 // That means that we move a cube of a player from start to end
#define HULL_LARGE 2 // That means that we move a bigger cube that one of the player from start to end
// (used in HL for big monsters!)
#define HULL_HEAD 3 // This means that we move from start to end the hull of a ducked player

==== Extra Info ====
TraceModel example: http://forums.alliedmods.net/showthread.php?p=850698

[[#EngFunc_TraceLine]] explanation.

=== EngFunc_TraceToss ===
Trace the point where some entity movement will finish.
If for some reason the entity movement must be blocked for other entity (or worldspawn), TraceToss will detect that situation taking in account the original entity bounding boxes.

==== Usage ====
<pawn>engfunc(EngFunc_TraceToss, ent, skipent, tr)</pawn>
* ent = The entity which movement we want to trace
* skipent = The entity to skip in trace
* tr = trace handle to store the result

[[Image:Tracetoss.jpg|thumb|EngFunc_TraceToss example]]
==== Example ====

In the image you can see a player jumping and 2 points.

''Start Point'' is the origin of the player when TraceToss was called.

''End Point'' is the point returned in TR result.

So the player is making a parabola from START to END.
The green line is only for testing purposes and show from where to where the trace is.
This was tested with gravity = 400.

== Model/Decal/Texture Functions ==
=== EngFunc_SetModel ===
Properly sets a new model on an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetModel, iEnt, sModel)</pawn>
* iEnt = Entity index
* sModel = Model file name to set on entity (ex: "models/player/vip/vip.mdl")

==== Engine Alternative ====
<pawn>entity_set_model(entity, model[])</pawn>
http://www.amxmodx.org/funcwiki.php?go=func&id=354

=== EngFunc_ModelIndex ===
Returns an unique index of the model name provided.
It's actually the same number that precache_model() returns.

A model index is used for example in some TE_* messages. ( TE_LIGHTNING, TE_GLOWSPRITE, etc.. See message_const.inc file ).

The model index of an entity is stored in pev_modelindex.

==== Usage ====
<pawn>ModelIndex = engfunc(EngFunc_ModelIndex, "models/MyModel.mdl")</pawn>
ModelIndex will have the model index for "models/MyModel.mdl" after the function call.

FakeMeta Functions Detailed Descriptions

2010-09-07T16:09:58Z

Seta00: Added EngFunc_SetModel

== Point Functions ==
=== EngFunc_PointContents ===
This function checks an origin and gives us information of its whearabouts.

The constants that this function returns are these:
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7 // Removed at csg time
#define CONTENTS_CLIP -8 // Changed to contents_solid
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
#define CONTENTS_LADDER -16
#define CONTENT_FLYFIELD -17
#define CONTENT_GRAVITY_FLYFIELD -18
#define CONTENT_FOG -19

==== Usage ====
<pawn>static Float:origin[3]
static result
result = engfunc(EngFunc_PointContents, origin)
// if for example result is CONTENTS_SKY
// then the origin that we see is in the sky we can for example use this to see where a player is aming if he is aiming at sky this will be the result! </pawn>

=== EngFunc_GetBonePosition ===
[[Image:PlayerSkeleton.jpg|frame|This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.]]
This function allows to get the bone positions of an entity. This is best used on getting specific player origin points.

These are the bones that a player has:

Bone 1 Name: "Bip01"
Bone 2 Name: "Bip01 Pelvis"
Bone 3 Name: "Bip01 Spine"
Bone 4 Name: "Bip01 Spine1"
Bone 5 Name: "Bip01 Spine2"
Bone 6 Name: "Bip01 Spine3"
Bone 7 Name: "Bip01 Neck"
Bone 8 Name: "Bip01 Head"
Bone 9 Name: "Bone01"
Bone 10 Name: "Bip01 L Clavicle"
Bone 11 Name: "Bip01 L UpperArm"
Bone 12 Name: "Bip01 L Forearm"
Bone 13 Name: "Bip01 L Hand"
Bone 14 Name: "Bip01 L Finger0"
Bone 15 Name: "Bip01 L Finger01"
Bone 16 Name: "Bip01 L Finger1"
Bone 17 Name: "Bip01 L Finger11"
Bone 18 Name: "-- L knuckle"
Bone 19 Name: "-- L Forearm twist"
Bone 20 Name: "-- L wrist"
Bone 21 Name: "-- L Elbow"
Bone 22 Name: "-- L bicep twist"
Bone 23 Name: "-- L shoulder outside"
Bone 24 Name: "-- L Shoulder inside"
Bone 25 Name: "Bip01 R Clavicle"
Bone 26 Name: "Bip01 R UpperArm"
Bone 27 Name: "Bip01 R Forearm"
Bone 28 Name: "Bip01 R Hand"
Bone 29 Name: "Bip01 R Finger0"
Bone 30 Name: "Bip01 R Finger01"
Bone 31 Name: "Bip01 R Finger1"
Bone 32 Name: "Bip01 R Finger11"
Bone 33 Name: "-- R knuckle"
Bone 34 Name: "-- R wrist"
Bone 35 Name: "-- R forearm twist"
Bone 36 Name: "-- R Elbow"
Bone 37 Name: "-- R bicep twist"
Bone 38 Name: "-- R Shoulder inside"
Bone 39 Name: "-- R shoulder outside"
Bone 40 Name: "-- Neck smooth"
Bone 41 Name: "-- R Butt"
Bone 42 Name: "-- L butt"
Bone 43 Name: "Bip01 L Thigh"
Bone 44 Name: "Bip01 L Calf"
Bone 45 Name: "Bip01 L Foot"
Bone 46 Name: "Bip01 L Toe0"
Bone 47 Name: "-- L ankle"
Bone 48 Name: "-- L Knee"
Bone 49 Name: "Bip01 R Thigh"
Bone 50 Name: "Bip01 R Calf"
Bone 51 Name: "Bip01 R Foot"
Bone 52 Name: "Bip01 R Toe0"
Bone 53 Name: "-- R Ankle"
Bone 54 Name: "-- R Knee"
Bone 55 Name: "Bomb"

==== Usage ====
<pawn>// ENTITY is the player entity id
// BONE_NUMBER you have to choose from the list above
// bone_origin[3] is the vector where we save the bone origin
// bone_angles[3] the vector that holds the angles of the bone.
engfunc(EngFunc_GetBonePosition, ENTITY, BONE_NUMBER, Float:bone_origin[3], Float:bone_angles[3])</pawn>

==== Useful Stocks ====
These stocks are made for CS/CZ, you need to port them to other mods.
===== get_bone_hitgroup =====
This gets the hitgroup of the bone:
<pawn>#define BONE_HIT_HEAD 8
#define BONE_HIT_CHEST 6
#define BONE_HIT_STOMACH 4
#define BONE_HIT_LEFTARM 24
#define BONE_HIT_RIGHTARM 39
#define BONE_HIT_LEFTLEG 48
#define BONE_HIT_RIGHTLEG 54
#define HEAD_NECK 40
#define BONE_L_BUTT 41
#define BONE_R_BUTT 42

stock get_bone_hitgroup(number)
{
switch (number)
{
case HEAD_NECK:
{
return HIT_HEAD
}
case BONE_L_BUTT:
{
return HIT_LEFTLEG
}
case BONE_R_BUTT:
{
return HIT_RIGHTLEG
}
}

if (1 <= number <= BONE_HIT_STOMACH)
return HIT_STOMACH

if (BONE_HIT_STOMACH < number <= BONE_HIT_CHEST)
return HIT_CHEST

if (BONE_HIT_CHEST < number <= BONE_HIT_HEAD)
return HIT_HEAD

if (BONE_HIT_HEAD < number <= BONE_HIT_LEFTARM)
return HIT_LEFTARM

if (BONE_HIT_LEFTARM < number <= BONE_HIT_RIGHTARM)
return HIT_RIGHTARM

if (BONE_HIT_RIGHTARM < number <= BONE_HIT_LEFTLEG)
return HIT_LEFTLEG

if (BONE_HIT_LEFTLEG < number <= BONE_HIT_RIGHTLEG)
return HIT_RIGHTLEG

return HIT_GENERIC
}</pawn>

===== find_closest_bone_to_gunshot =====
This gets the closest bone to the gunshot (Use this in FM_TraceLine and Ham_TraceAttack):
<pawn>#define DISTANCE_CLEAR_HIT 2.0

stock find_closest_bone_to_gunshot(victim, Float:endtrace[3])
{
new Float:angles[3], Float:origin[3], Float:dist = 9999999.99, Float:curorigin[3], bone_nr
for (new i=1;i<=54;i++)
{
// Get the bone position
engfunc(EngFunc_GetBonePosition, victim, i, curorigin, angles)
// Calculate the distance vector
xs_vec_sub(curorigin, endtrace, angles)

// If this is smaller than the last small distance remember the value!
if (xs_vec_len(angles) <= dist)
{
origin = curorigin
dist = xs_vec_len(angles)
bone_nr = i
}

// If distance is smaller than CLEARHIT! Break (We accept the last value!)
if (dist <= DISTANCE_CLEAR_HIT)
{
break
}
}

// Return the bone
return bone_nr
}</pawn>

== Messaging Functions ==
=== EngFunc_MessageBegin ===
This function is used to generate client messages.

==== Usage ====
Syntax:
<pawn>engfunc(EngFunc_MessageBegin, dest, msg_type, origin[3] = {0, 0, 0}, player = 0)</pawn>
Example:
<pawn>static Float:origin[3] // Origin should be a Float
pev(id, pev_origin, origin) // Get user origin
engfunc(EngFunc_MessageBegin,MSG_BROADCAST,SVC_TEMPENTITY,origin,0) // Create message</pawn>
With MSG_ONE_UNRELIABLE:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>
With MSG_ALL:
<pawn>engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message</pawn>

dest can be:

#define MSG_BROADCAST 0 // Unreliable to all, There is not id
#define MSG_ONE 1 // Reliable to one (msg_entity)
#define MSG_ALL 2 // Reliable to all, There is not origin
#define MSG_INIT 3 // Write to the init string
#define MSG_PVS 4 // Ents in PVS of org
#define MSG_PAS 5 // Ents in PAS of org
#define MSG_PVS_R 6 // Reliable to PVS
#define MSG_PAS_R 7 // Reliable to PAS
#define MSG_ONE_UNRELIABLE 8 // Send to one client, but don't put in reliable stream,
// put in unreliable datagram (could be dropped), there is not origin
#define MSG_SPEC 9 // Sends to all spectator proxies

'''Before calling another EngFunc_MessageBegin you must call message_end().'''

== Entity Search Functions ==
=== EngFunc_FindEntityInSphere ===
Find entities within a radius. '''The function returns the next entity id after the start entity.'''

[[Image:FindEntityInSphere.png|thumb|3D diagram to show how the function works.]]
If we use
<pawn>engfunc(EngFunc_FindEntityInSphere, -1, origin, radius)</pawn>
In the situation described on the picture the function call above will return 1,
<pawn>engfunc(EngFunc_FindEntityInSphere, 20, origin, radius)</pawn>
will return 30 and
<pawn>engfunc(EngFunc_FindEntityInSphere, 100, origin, radius)</pawn>
will return 0, meaning that it didn't find an entity with an id grater than 100.

==== Usage ====
<pawn>engfunc(EngFunc_FindEntityInSphere, ent_to_start, origin, radius)</pawn>

=== EngFunc_EntitiesInPVS ===

This function checks entities that are in the [[PVS]] of an entity.
'''It can't be used on worldspawn.'''

The function returns the first entity on the [[PVS]] and then you can traverse through the results using pev_chain/EV_ENT_chain.
A NULL value of pev_chain/EV_ENT_chain indicates the end of the chain.

==== Usage ====
<pawn>public whatisonPVS(id)
{
static next, chain
static class[32]

next = engfunc(EngFunc_EntitiesInPVS, id)
while(next)
{
pev(next, pev_classname, class, charsmax(class))
chain = pev(next, pev_chain)

server_print("Found entity in player (%i) PVS: ent(%i) class(%s)", id, next, class)

if(!chain)
break

next = chain
}
}</pawn>

=== EngFunc_FindEntityByString ===
Returns the first entity found that matches the search criteria.

You can use any of string type attributes of entities:

classname Type of entity
globalname This is the name of the global variable that can be used to control the state of the entity
model The model of the entity
target Entity that this entity is handling
targetname The name given to this entity that another entity searches for to handle it
netname Player or NPC name
message Seems to be used mainly to store sound (string). It happens to store others things, depending the need of the entity
noise Noise variables do different things for different ents
noise1 This is the move sound for doors
noise2 This is the stop sound for doors
noise3 This is for blocking game_player_equip and player_weaponstrip

==== Usage ====
<pawn>iEnt = engfunc(EngFunc_FindEntityByString, iStartEnt, sAttribute, sValue)</pawn>
Parameters:
* iStartEnt: Start searching on this entity (ex: 0 = worldspawn)
* sAttribute: Name of attribute over which we need to search (ex: classname)
* sValue: Text string that we are searching for (ex: func_breakable)

The function returns the first entity matching the criteria.

=== EngFunc_FindClientInPVS ===
Returns the next "player" entity in someone's [[PVS]] using a global loop.

==== Usage ====
<pawn>iEnt2 = engfunc(EngFunc_FindClientInPVS, iEnt)</pawn>
Parameters:
* iEnt Source entity. Seek someone within iEnt's [[PVS]]

Unlike [[#EngFunc_EntitiesInPVS]], it does not return a series of chained entities. Instead, it works like a global loop of entities.
No matter which source entity you use, this function maintains the last index used and returns the next entity in source entity [[PVS]].

This function must be called several times to find every entity in [[PVS]] and can also return the source entity but it can't be called twice inside the same function because it will return the same entity.

==== Notes ====
It's not clear the main purpose of this function because you can get similar results with [[#EngFunc_EntitiesInPVS]].

[[#EngFunc_CheckVisibility]] and [[#EngFunc_EntitiesInPVS]] are better functions to use.

== Trace Functions ==
=== EngFunc_TraceLine ===
This function traces between 2 origins and gives us information about it.

These are the constants we can use as flags:

#define DONT_IGNORE_MONSTERS 0
#define IGNORE_MONSTERS 1
#define IGNORE_MISSILE 2
#define IGNORE_GLASS 0x100

'''These constants can be used together.'''

Ex: IGNORE_MISSILE | IGNORE_MONSTERS | IGNORE_GLASS - This makes the traceline ignore missiles, monsters (players) and glass.

==== Usage ====

Example of doing a traceline between two origins, and ignoring glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr)</pawn>

Now considering glass:
<pawn>engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr)</pawn>

<gallery>
File:Traceline1.jpg|Traceline result if glass is ignored. The entity is ignored because of its solid flag
File:Traceline2.jpg|Traceline result if glass is not ignored.
File:Traceline3.jpg|Traceline result if glass is ignored but there's an entity with blocking solid flags in the way
File:Traceline4.jpg|Traceline result if glass is ignored, and the entity in the way has non-blocking flags
</gallery>

==== Other Traceline functions ====
This creates a trace handle. It's important to do this because we don't want our plugins to mess with eachothers info.
<pawn>new ptr = create_tr2()</pawn>

And this frees the trace handle:
<pawn>free_tr2(ptr)</pawn>

Getter and setter:
<pawn>[g|s]et_tr2(trace_handle, CONSTANT, argument_if_setting)</pawn>
Where CONSTANT can be one of the following enumerations:
<pawn>enum TraceResult
{
TR_AllSolid, // int
TR_StartSolid, // int
TR_InOpen, // int
TR_InWater, // int
TR_flFraction, // float
TR_vecEndPos, // float array[3]
TR_flPlaneDist, // float
TR_vecPlaneNormal, // float array[3]
TR_pHit, // int (edict_t*)
TR_iHitgroup, // int
};</pawn>

'''Getting the array and Float values require the third parameter to be passed.'''

Example:
<pawn>
new startsolid = get_tr2(trace, TR_StartSolid)
// TR_StartSolid is a boolean that says whether you were "inside" something
// (usually the world) when the trace started (point A)
// TR_AllSolid tells you if you ever got out of the "inside" or not.

new inopen = get_tr2(trace, TR_InOpen)
// TR_InOpen means that the start point is in Open
// That means in the world and not in an ent or something

new hit = get_tr2(trace, TR_pHit)
// What was hit by the traceline. It will either be a player index,
// entity index, 0 (part of map), or -1 (didn't hit anything;
// doesn't happen with player tracelines).

new hitgroup = get_tr2(trace, TR_iHitgroup)
// If the traceline hit another player, returns will be HIT_HEAD,
// HIT_CHEST, HIT_LEFTLEG... etc. If the traceline hit part of the
// map, this returns HIT_GENERIC.

new Float:fraction
get_tr2(trace, TR_flFraction, fraction)
// Returns a number between 0.0 and 1.0, indicating how far the
// traceline traveled start to end before it hit something. Depending
// on what conditions were passed to this traceline forward function,
// it could either be a wall or another entity.

new Float:end_origin[3]
get_tr2(trace, TR_vecEndPos, end_origin)
// The official end of the traceline. Not necesarily the same as the
// second argument passed to this traceline forward function.

new Float:normal[3]
get_tr2(trace, TR_vecPlaneNormal, normal)
// Returns a 1 unit long vector normal to the spot that it hit. Note
// that "normal" has a special connotation here. It doesn't mean "regular."
</pawn>

==== Useful Stocks ====
===== is_wall_between_points =====
This returns true if there's a wall between ''start'' and ''end''.
<pawn>stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
// Create the trace handle! It is best to create it!
new ptr = create_tr2()

// The main traceline function!
// This function ignores GLASS, MISSILE and MONSTERS!
// Here is an example of how you should combine all the flags!
engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS | IGNORE_MONSTERS | IGNORE_MISSILE, ignore_ent, ptr)

// We are interested in the fraction parameter
new fraction
get_tr2(ptr, TR_flFraction, fraction)

// Free the trace handle (don't forget to do this!)
free_tr2(ptr)

// If = 1.0 then it didn't hit anything!
return (fraction != 1.0)
}</pawn>

==== Extra Info ====
http://developer.valvesoftware.com/wiki/TraceLines

http://forums.alliedmods.net/showthread.php?t=66076

[[Category:Scripting (AMX Mod X)]]

=== EngFunc_TraceTexture, DLLFunc_PM_FindTextureType ===
The TraceTexture function detects the texture of an entity from a direction

The FindTextureType function allows to get the type of the material of the texture.

==== Usage ====
<pawn>engfunc(EngFunc_TraceTexture, ent, Float:start[3], Float:end[3], texture_name, len)</pawn>
* ent is the entity that we want to get the texture
* start is the point from where the trace starts
* end is the point where the trace ends
* texture_name - here we save the texture name
* len - the texture_name string length

<pawn>dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>
* texture_name is the name of the texture that we have gotten with TraceTexture

The function returns the material of the texture, which can be one of the following:

* C : concrete
* D : dirt
* G : grate
* M : metal
* N : snow
* P : computer
* S : slosh
* T : tile
* V : ventilation
* W : wood
* Y : glass

'''Example:'''

<pawn>new texture_name[64], texture_type
engfunc(EngFunc_TraceTexture, 0, start, end, texture_name, charsmax(texture_name))
texture_type = dllfunc(DLLFunc_PM_FindTextureType, texture_name)</pawn>

==== Notes ====
'''Improper use of these functions may crash the server!'''

To avoid crashing the server use the TraceTexture:
* on any entities (even worldspawn) except players
* when there is at least one player connected
* with a big distance between the two points (> 2000.0)

=== EngFunc_TraceModel ===
This function traces between 2 origins a model and gives us properties about it.
It acts just like a TraceLine but it ignores all the entities except the one we want to hit!

==== Usage ====
<pawn>engfunc(EngFunc_TraceModel, const Float:start[3], const Float:end[3], hull, ent_to_hit, ptr)</pawn>
* start - start origin
* end - end origin
* hull - the hull that is moved check above to see them
* ent_to_hit - the entity that you want to hit (this is a must!)
* ptr - the trace handle pointer, acts the same as the one in trace line!

The constants that we can use in hull:

#define HULL_POINT 0 // This means that we are moving a point from the start to the end
#define HULL_HUMAN 1 // That means that we move a cube of a player from start to end
#define HULL_LARGE 2 // That means that we move a bigger cube that one of the player from start to end
// (used in HL for big monsters!)
#define HULL_HEAD 3 // This means that we move from start to end the hull of a ducked player

==== Extra Info ====
TraceModel example: http://forums.alliedmods.net/showthread.php?p=850698

[[#EngFunc_TraceLine]] explanation.

=== EngFunc_TraceToss ===
Trace the point where some entity movement will finish.
If for some reason the entity movement must be blocked for other entity (or worldspawn), TraceToss will detect that situation taking in account the original entity bounding boxes.

==== Usage ====
<pawn>engfunc(EngFunc_TraceToss, ent, skipent, tr)</pawn>
* ent = The entity which movement we want to trace
* skipent = The entity to skip in trace
* tr = trace handle to store the result

[[Image:Tracetoss.jpg|thumb|EngFunc_TraceToss example]]
==== Example ====

In the image you can see a player jumping and 2 points.

''Start Point'' is the origin of the player when TraceToss was called.

''End Point'' is the point returned in TR result.

So the player is making a parabola from START to END.
The green line is only for testing purposes and show from where to where the trace is.
This was tested with gravity = 400.

== Model/Decal/Texture Functions ==
=== EngFunc_SetModel ===
Properly sets a new model on an entity.

==== Usage ====
<pawn>engfunc(EngFunc_SetModel, iEnt, sModel)</pawn>
* iEnt = Entity index
* sModel = Model file name to set on entity (ex: "models/player/vip/vip.mdl")

==== Engine Alternative ====
<pawn>entity_set_model(entity, model[])</pawn>
http://www.amxmodx.org/funcwiki.php?go=func&id=354

FakeMeta Functions Detailed Descriptions

2010-09-07T16:07:37Z

Seta00: Added EngFunc_TraceToss

File:Tracetoss.jpg

2010-09-07T16:05:27Z

Seta00: EngFunc_TraceToss example.

EngFunc_TraceToss example.

FakeMeta Functions Detailed Descriptions

2010-09-07T16:03:06Z

Seta00: Added EngFunc_TraceModel

FakeMeta Functions Detailed Descriptions

2010-09-07T15:24:12Z

Seta00: Added category

FakeMeta Functions Detailed Descriptions

2010-09-07T15:22:06Z

Seta00: fixed links

FakeMeta Functions Detailed Descriptions

2010-09-07T15:21:39Z

Seta00: TraceLine

File:Traceline4.jpg

2010-09-07T14:46:09Z

Seta00: Traceline result from point to point.

Traceline result from point to point.

File:Traceline3.jpg

2010-09-07T14:45:40Z

Seta00: Traceline result if glass is ignored, with an blocking entity in its way.

Traceline result if glass is ignored, with an blocking entity in its way.

File:Traceline2.jpg

2010-09-07T14:45:03Z

Seta00: Traceline result if glass is not ignored.

Traceline result if glass is not ignored.

File:Traceline1.jpg

2010-09-07T14:44:31Z

Seta00: Traceline result if glass is ignored.

Traceline result if glass is ignored.

FakeMeta Functions Detailed Descriptions

2010-09-07T05:31:05Z

Seta00: typo on EntitiesInPVS name

FakeMeta Functions Detailed Descriptions

2010-09-07T05:30:06Z

Seta00: Entity Search Functions

File:FindEntityInSphere.png

2010-09-07T05:03:48Z

Seta00: 3D diagram to show how EngFunc_FindEntityInSphere works.

3D diagram to show how EngFunc_FindEntityInSphere works.

FakeMeta Functions Detailed Descriptions

2010-09-07T02:35:24Z

Seta00: Created page and added first functions.

File:PlayerSkeleton.jpg

2010-09-07T02:18:16Z

Seta00: This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.

This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.

Writing Extensions

2010-09-06T16:06:24Z

Seta00: /* Include Paths */

SourceMod's Extension System is a powerful way to greatly enhance the flexibility of your SourceMod plugins. You can take full advantage of SourceMod's Core, using the interfaces it provides, to create C++ plugins, plugin events, plugin native functions, and shared interfaces. Extensions can also hook into Metamod:Source.

This article goes into the details of creating a SourceMod Extension. Knowledge of C++ is required.

=SDK Structure=
First, download the [[SourceMod SDK]] from the [[SourceMod]] website. The directory structure looks like this:
*<tt>extensions</tt>
**<tt>geoip/</tt> - Source code to the GeoIP extension
**<tt>mysql/</tt> - Source code to the MySQL extension
**<tt>threader/</tt> - Source code to the Threader extension
*<tt>plugins/</tt> - Source code to all of SourceMod's plugins
**<tt>include/</tt> - The include files which document plugin API
*<tt>public/</tt> - Interface files for SourceMod's Core Interfaces
**<tt>extensions/</tt> - Interfaces that are provided by extensions
**<tt>sample_ext/</tt> - The Sample Extension SDK
**<tt>sourcepawn</tt> - The include/interface files for SourcePawn
*<tt>sourcepawn/</tt>
**<tt>compiler/</tt> - The SourcePawn Compiler

=Starting an Extension=
For simplicity, this article will assume you are using the SDK base files. These are:
*<tt>sdk/smsdk_config.h</tt> - Configuration settings (we will be editing this)
*<tt>sdk/smsdk_ext.h</tt> - Header for SDK wrappers (usually never needs to be edited)
**''Note: Sometimes, this may be updated by the SourceMod Dev Team. Using a newest version is recommended.'
*<tt>sdk/smsdk_ext.cpp</tt> - Source for SDK wrappers (usually never needs to be edited)
**''Note: Sometimes, this may be updated by the SourceMod Dev Team. Using a newest version is recommended.'
*<tt>extension.h</tt> - User file for main extension header
*<tt>extension.cpp</tt> - User file for main extension code

''The <tt>extension.*</tt> files are not technically part of the SDK. However, they are provided to give users a starting point and some documentation.''

'''Note:''' For help setting up Visual Studio, please see [[#Setting up Visual Studio|Setting up Visual Studio]].

The first step of creating your extension is to configure it. Open the <tt>smsdk_config.h</tt> file and edit each of the following defines. Use the information below to guide you.
*<tt>SMEXT_CONF_NAME</tt> - The general name for your Extension (should be short).
*<tt>SMEXT_CONF_DESCRIPTION</tt> - A short description of what your extension does.
*<tt>SMEXT_CONF_VERSION</tt> - A version number string. By convention, SourceMod uses the four set build number notation. I.e. for 1.2.3.4:
**<tt>1</tt> is the "Major" release version.
**<tt>2</tt> is the "Minor" release version.
**<tt>3</tt> is the "Maintenance" or "Revision" version.
**<tt>4</tt> is the "Build," usually an internal source control number.
*<tt>SMEXT_CONF_AUTHOR</tt> - Your name (or whoever/whatever authored the plugin).
*<tt>SMEXT_CONF_URL</tt> - The URL/homepage of this extension.
*<tt>SMEXT_CONF_LOGTAG</tt> - The logtag your extension will use for SourceMod logging. By convention, try to keep this under ten characters or so, and to make it all caps.
*<tt>SMEXT_CONF_LICENSE</tt> - Right now, the SourceMod Dev Team mandates that 3rd party extensions must be under an Open Source license. Putting a license abbreviation or very short message here is appropriate. For more information, see [[SourceMod License]].
*<tt>SMEXT_CONF_DATESTRING</tt> - You do not need to modify this.
*<tt>SMEXT_CONF_METAMOD</tt> - If your plugin requires using SourceHook or Metamod:Source, uncomment this line.

Next, you may want to change the name of the default class that <tt>extension.h</tt> declares. To do this...
<ul><li>Open <tt>extension.h</tt> and change "Sample" in this line:
<cpp>class Sample : public SDKExtension</cpp></li>
<li>Open <tt>extension.cpp</tt> and change the two lines to correspond to your new class name. You can also change the global singleton that's declared, although you cannot remove the <tt>SMEXT_LINK</tt> line (this lets SourceMod load your extension).</li>
</ul>

==Visual Studio Users==
Make sure you change the name of your <tt>.dll</tt> file. The naming convention for SourceMod extensions is <tt>name.ext.dll</tt>, where <tt>name</tt> is a short name for your extension. You are free to change this, but it is highly recommended that you keep the <tt>.ext.dll</tt> intact.

You can do this by going to <tt>Project</tt> -> <tt>Properties</tt> -> <tt>Configuration Properties</tt> -> <tt>Linker</tt> -> <tt>General</tt>. Set the <tt>Output File</tt> option appropriately.

==Linux Users==
Simply edit the <tt>Makefile</tt> and change the <tt>BINARY</tt> line near the top. Make sure you do not add any trailing spaces at the end of the name, or the build won't come out right.

You should now be able to compile a blank extension!

=Creating Native Functions=
''Main article: [[Natives (SourceMod Development)]]''

Most of the time, an extension exists to add "native functions" to the plugin system. Native functions are simply the functions that plugins can use in SourceMod. They are coded in C++ and have a short prototype declaration in an include file.

==Prototyping==
The first step to creating a native is to <tt>spec it</tt>, or <tt>prototype</tt> it. This is a simple but often time consuming process, but if you get in the habit of it, your documentation will be much better. Let's first create a very simply native. Here is a prototype for it, which we will place in <tt>sample.inc</tt>:
<pawn>/**
* Returns the square of a number.
*
* @param num Number to square.
* @return The square of num.
*/
native SquareNumber(num);</pawn>

The <tt>native</tt> keyword tells the compiler that this function exists in an outside source. The comment style is similar to [http://www.stack.nl/~dimitri/doxygen/ doxygen] or [http://java.sun.com/j2se/javadoc/ Javadoc], and is preferred by the SourceMod Development Team.

==Implementing==
Now that our function is documented, it's time to create it! Each native function is bound to a C++ function. The prototype for this function looks like:
<cpp>cell_t Function(IPluginContext *pContext, const cell_t *params);</cpp>

A quick explanation of these types:
*<tt>cell_t</tt> - This is a 32bit signed integer, the generic data type for Pawn.
*<tt>IPluginContext</tt> - This interface provides Virtual Machine functions for retrieving or modifying memory in the plugin.
*<tt>params</tt> - This is the "stack" of parameters that the plugin passed. It is an array from [0..N] where 0 contains N.
**For example, if one parameter was passed, and the parameter is 25:
***<tt>params[0]</tt> == 1
***<tt>params[1]</tt> == 25
**Even though it tells you how many parameters are passed, you do not need to verify this number. The compiler will always pass the correct number of parameters in. The only time you need to verify it is for backwards compatibility or variable parameter lists, which will be discussed later.

Now, let's write our native function:
<cpp>cell_t SquareNumber(IPluginContext *pContext, const cell_t *params)
{
cell_t number = params[1];
return number * number;
}</cpp>

==Binding==
Now, the final step is to bind our native. Natives are bound in ''native lists''. Each list must be terminated by a <tt>NULL</tt> bind. Example:
<cpp>const sp_nativeinfo_t MyNatives[] =
{
{"SquareNumber", SquareNumber},
{NULL, NULL},
};</cpp>

The first column/member is a string containing the name you've assigned to the native. The second column/member is the C++ function you're binding to. Here, both contain the same name, but it is certainly possible to bind a function to any valid Pawn function name, and likewise, you can bind one function to more than one name.

Lastly, you must tell Core about your native list. There are two places that are good to do this. Whichever you choose, you must uncomment the function in <tt>extension.h</tt> and implement it in <tt>extension.cpp</tt>.
*<tt>SDK_OnLoad</tt> - This is called when your extension is first loaded. If you do not require any outside interfaces, it is safe to add natives here.
*<tt>SDK_OnAllLoaded</tt> - This is called when all extensions have been loaded. This is generally a better place to add natives.

Let's say we choose <tt>SDK_OnAllLoaded</tt>, we'd then have code like this:
<cpp>void Sample::SDK_OnAllLoaded()
{
sharesys->AddNatives(myself, MyNatives);
}</cpp>
''Note: <tt>myself</tt> is a global variable declared in the SDK. It is a pointer that identifies your extension.''

For more information on writing natives, see [[Natives (SourceMod Development)]].

=Creating Events/Forwards=
Events are an integral part to SourceMod. An Event is formally called a ''Forward''. Forwards are functions inside a plugin which are not called by the plugin itself, but are triggered from an external source. For example, <tt>OnClientConnect</tt> is a forward which is triggered when a player connects to a server.

There are two major types of forwards:
*'''Managed''': This forward is global and has a name. To use this forward, the function must be declared as <tt>public</tt> inside the user's script. Any plugin having this public function will receive the event.
*'''Unmanaged''': This forward is private in nature. For example, the <tt>HookUserMessage</tt> native lets users specify a function to be called when a specific user message is sent. This is done with an unmanaged forward, and adding functions to this forward is not automatic. In general, function calls for unmanaged forwards are not public, although they can be.

''Note: To enable the Forward interface, you must uncomment the definition <tt>SMEXT_ENABLE_FORWARDSYS</tt> in smsdk_config.h.''
==Managed Forwards==
Let's say we want to create a forward that will be called when a player uses say chat. For simplicity, let's assume you already have a function that tells you when a player says say chat. We will just be creating the forward for it.

As we did before, first let's prototype our global forward. In our include file, we add this:
<pawn>/**
* @brief Called whenever a client says something in chat.
*
* @param client Index of the client.
* @param text String containing the say text.
* @return Pl_Handled to block text from printing, Pl_Continue otherwise.
*/
forward ResultType:OnPlayerSayChat(client, const String:text[]);</pawn>

The <tt>forward</tt> keyword tells the compiler that any function having this name must be declared exactly the same. In a plugin, this would

The next step is to declare your forward somewhere at the top of your <tt>extension.cpp</tt> file. This will look like:
<cpp>IForward *g_pSayChat = NULL</cpp>

Next, re-using our code from above, let's create this forward in <tt>SDK_OnAllLoaded</tt>:
<cpp>void Sample::SDK_OnAllLoaded()
{
sharesys->AddNatives(myself, MyNatives);
g_pSayChat = forwards->CreateForward("OnPlayerSayChat", ET_Event, 2, NULL, Param_Cell, Param_String);
}</cpp>

Explanation of parameters:
*<tt>"OnPlayerSayChat"</tt> - The name of our forward.
*<tt>ET_Event</tt> - Since forwards can execute multiple functions in multiple scripts, this is one of the ways of specifying what to do with the return value of each function. <tt>ET_Event</tt> means "return the highest value, do not allow stops." A stop refers to <tt>Pl_Stop</tt>, which lets a plugin block the rest of the event chain.
*<tt>2</tt> - This is the number of parameters our forward will have.
*<tt>NULL</tt> - Not used in our example. This lets you pass parameters by array rather than variable arguments.
*<tt>Param_Cell</tt> - The first parameter is a cell (integer).
*<tt>Param_String</tt> - The second parameter is a string.

Now, we write a quick function in our module to call this forward:
<cpp>/** Fires the say chat event in plugins. Returns true to allow the text, false to block. */
bool FireChatEvent(int client, const char *text)
{
if (!g_pSayChat)
{
return true;
}

cell_t result = 0;
g_pSayChat->PushCell(client);
g_pSayChat->PushString(text);
g_pSayChat->Execute(&result);

if (result == Pl_Handled)
{
return false;
}

return true;
}</cpp>

As you can see, this was pretty simple. Each parameter is "pushed" one at a time, in ascending order. First we push the client index as a cell, then the text as a string. Once done, we execute, and the value will be returned by reference.

Lastly, there is a caveat. Unlike natives, SourceMod does not automatically clean up forwards for us when are done. We have to make sure we destroy them. Uncomment <tt>SDK_OnUnload</tt> from <tt>extension.h</tt> and implement it like so:
<cpp>void Sample::SDK_OnUnload()
{
forwards->ReleaseForward(g_pSayChat);
}</cpp>

==Unmanaged Forwards==
Now things get a bit more complicated. However, unmanaged forwards are essentially the same -- they just give you more flexibility. Let's consider the managed example with a new twist. We want to let users add and remove hooks from their plugins, rather than having one global forward. The standard way to do this is with ''function IDs''.

Example prototype:
<pawn>funcenum SayChatHook
{
forward(client, const String:text[]);
}

native AddSayChatHook(SayChatHook:hook);
native RemoveSayChatHook(SayChatHook:hook);</pawn>

The <tt>funcenum</tt> syntax lets you define all the valid prototypes for your hook. In this example, the only valid method is a function declared like this (only MyHook can be changed):
<pawn>MyHook(client, const String:text[])</pawn>

How do we make such a beast? The first step is setting up our forward.
<cpp>IChangeableForward *g_pSayChat = NULL;
/* ... */
void Sample::SDK_OnAllLoaded()
{
g_pSayChat = forwards->CreateForwardEx(NULL, ET_Hook, 2, NULL, Param_Cell, Param_String);
}</cpp>

Notice two big differences. We now use <tt>IChangeableForward</tt> instead of <tt>IForward</tt>, and we use <tt>CreateForwardEx</tt> instead. The initial first parameter specifies a name for our forward - we're going to ignore this.

Now, we need to create our natives. These will be fairly simple:
<cpp>cell_t AddSayChatHook(IPluginContext *pContext, const cell_t *params)
{
g_pSayChat->AddFunction(pContext, static_cast<funcid_t>(params[1]));
return 1;
}

cell_t RemoveSayChatHook(IPluginContext *pContext, const cell_t *params)
{
IPluginFunction *pFunction = pContext->GetFunctionById(static_cast<funcid_t>(params[1]));
g_pSayChat->RemoveFunction(pFunction);
return 1;
}</cpp>
''Note: These natives must be added -- that step is removed here and explained earlier.''

You do not need to worry about a plugin unloading - Core will automatically remove the functions for you. Since an <tt>IChangeableForward</tt> is also an <tt>IForward</tt>, the <tt>FireChatEvent</tt> function from earlier does not need to change. We're done!

==Creating Interfaces==
Do you want your extension to share an interface? If so, first you should create an ''interface file''. This file should contain everything your interface needs - this way other authors can easily reference it. Your interface must inherit the <tt>SMInterface</tt> class. It must also declare two global macros that uniquely identify your interface. It must also implement two functions: <tt>GetInterfaceName</tt> and <tt>GetInterfaceVersion</tt>.

The two defines must start with <tt>SMINTERFACE_</tt> and end with <tt>_NAME</tt> and <tt>_VERSION</tt> respectively. The first must be a string and the second must be an unsigned integer. This integer represents your interface's version number. While you are free to use it however you please, by default it should be linearly increased. If you make breaking changes or change the versioning scheme, you must overload the <tt>IsVersionCompat</tt> function in <tt>SMInterface</tt>.

Example:
<cpp>#ifndef _INCLUDE_MYINTERFACE_FILE_H_
#define _INCLUDE_MYINTERFACE_FILE_H_

#include <IShareSys.h>

#define SMINTERFACE_MYINTERFACE_NAME "IMyInterface"
#define SMINTERFACE_MYINTERFACE_VERSION 1

class IMyInterface : public SourceMod::SMInterface
{
public:
virtual const char *GetInterfaceName()
{
return SMINTERFACE_MYINTERFACE_NAME;
}
virtual unsigned int GetInterfaceVersion()
{
return SMINTERFACE_MYINTERFACE_VERSION;
}
public:
/**
* @brief This function does nothing.
*/
virtual void DoNothingAtAll() =0;
};

#endif //_INCLUDE_MYINTERFACE_FILE_H_</cpp>

Notice, of course, that our interface is ''pure virtual''. This means it must be implemented in the extension. Assuming you know C++, this should be fairly straight forward, so let's skip right to how to add this interface to the SourceMod shared system:
<cpp>bool Sample::SDK_OnLoad(char *error, size_t err_max, bool late)
{
sharesys->AddInterface(myself, &g_MyInterface);
return true;
}</cpp>
''Note: We do this in <tt>SDK_OnLoad()</tT> instead of <tt>SDK_OnAllLoaded()</tt>. Otherwise, an extension might try to search for your interface during <tt>SDK_OnAllLoaded()</tt>, and it might fail depending on the load order.''

That simple? Yup! Now other extensions can use your interface.

=Using Interfaces/Other Extensions=
There are a variety of interfaces that are available, but not loaded by default in the Extension SDK. These interfaces can be retrieved and used in your extension.

==Core Interfaces==
If they are provided by Core, getting them is very simple. Many interfaces can simply be uncommented in <tt>smsdk_config.h</tt> and they will become usable. See the "Available Interfaces" list below for the exposure list.

Otherwise, most of the <tt>.h</tt> interface files in the root of the <tt>public</tt> folder in the SDK are Core interfaces. For example, code to use the IPluginManager interface might look like this:
<cpp>#include <IPluginSys.h>

IPluginManager *g_pPlugins = NULL;

bool Sample::SDK_OnLoad(char *error, size_t err_max, bool late)
{
SM_GET_IFACE(PLUGINSYSTEM, g_pPlugins);
return true;
}</cpp>

Where did we get <tt>PLUGINSYSTEM</tt> from? Observe the two lines in <tt>IPluginSys.h</tt>:
<cpp>#define SMINTERFACE_PLUGINSYSTEM_NAME "IPluginManager"
#define SMINTERFACE_PLUGINSYSTEM_VERSION 1</cpp>

The <tt>SM_GET_IFACE</tt> macro uses the text in between the <tt>SMINTERFACE_</tt> and the <tt>_NAME</tt> characters. It also uses the version for compatibility checking. If it can't find the interface, it automatically prints to the error buffer and returns false.

===Default Interfaces===
There are interfaces which are grabbed by the Extension SDK by default. You do not need to query for them on load, or even check if they are valid or not. They are:
*<tt>IShareSys</tt> - Exposed as <tt>sharesys</tt>, found in <tt>IShareSys.h</tt>
*<tt>HANDLESYSTEM</tt> - Exposed as <tt>handlesys</tt>, found in <tt>IHandleSys.h</tt>
*<tt>SOURCEMOD</tt> - Exposed as <tt>g_pSM</tt>, found in <tt>ISourceMod.h</tt>
*<tt>FORWARDMANAGER</tt> - Exposed as <tt>forwards</tt>, found in <tt>IForwardSys.h</tt>

===Available Interfaces===
*<tt>SMEXT_ENABLE_FORWARDSYS</tt>: <tt>forwards</tt>
*<tt>SMEXT_ENABLE_HANDLESYS</tt>: <tt>handlesys</tt>
*<tt>SMEXT_ENABLE_PLAYERHELPERS</tt>: <tt>playerhelpers</tt>
*<tt>SMEXT_ENABLE_DBMANAGER</tt>: <tt>dbi</tt>
*<tt>SMEXT_ENABLE_GAMECONF</tt>: <tt>gameconfs</tt>
*<tt>SMEXT_ENABLE_MEMUTILS</tt>: <tt>memutils</tt>
*<tt>SMEXT_ENABLE_GAMEHELPERS</tt>: <tt>gamehelpers</tt>
*<tt>SMEXT_ENABLE_TIMERSYS</tt>: <tt>timersys</tt>
*<tt>SMEXT_ENABLE_THREADER</tt>: <tt>threader</tt>

==External Interfaces==
The situation changes if your extension requires ''another extension'', since extensions may load in a completely random order. The first step is to mark the other extension as a dependency. Let's say you want to use the <tt>IThreader.h</tt> interfaces from <tt>threader.ext.dll</tt>. First, we declare it as such:

<cpp>bool Sample::SDK_OnLoad(char *error, size_t err_max, bool late)
{
sharesys->AddDependency(myself, "thread.ext", true, true);
return true;
}</cpp>

The two boolean parameters to <tt>AddDependency</tt> mean, respectively: "try to automatically load this extension" and "this extension cannot work without the dependency."

Second, we query for the interface in <tt>SDK_OnAllLoaded</tt>. Since we don't know when <tt>thread.ext</tt> will actually be loaded, we have to wait until everything is definitely loaded.
<cpp>IThreader *g_pThreader = NULL;
/* ... */
void Sample::SDK_OnAllLoaded()
{
SM_GET_LATE_IFACE(THREADER, g_pThreader);
}</cpp>

Third, we need to find a way to fail if this interface was never found. The way to do this is by uncommenting <tt>QueryRunning</tt> from <tt>extension.h</tt> and implementing it:
<cpp>bool Sample::QueryRunning(char *error, size_t err_max)
{
SM_CHECK_IFACE(THREADER, g_pThreader);
return true;
}</cpp>

When SourceMod queries your extension, the macro above will either validate the pointer or return false. If it returns false, SourceMod marks your extension as failed.

==Caveats==
===NULL Interfaces===
There are a few ways that external interfaces can make your code complicated. The first is simple but a common oversight. Don't assume interfaces will be okay. For example, say we want to create a thread once we get the <tt>IThreader</tt> interface. Our code should something like this:

<cpp>void Sample::SDK_OnAllLoaded()
{
SM_GET_IFACE(THREADER, g_pThreader);

if (QueryRunning(NULL, 0))
{
g_pThreader->MakeThread(/* stuff */);
}
}</cpp>

Note that we ''query ourself'' in order to find if it's safe to continue executing code. We could also have simply checked if <tt>g_pThreader</tt> is <tt>NULL</tt>, but self-querying has a bonus: if your extension continues to do things like hook events or add listeners, you will be preventing your extension from entirely initializing itself while one interface is bad. Always make sure you have sanity checks like this where needed.

===Dynamic Unloading===
The second major caveat is that extensions can be dynamically unloaded. If you specified yourself as having a dependency and that each dependency is required, you will have no problem. Your extension will be unloaded before the interface is removed, and you can clean up memory/hooks in your <tt>SDK_OnUnload()</tt> code. There are two situations where this is a different story.

====Optional Interfaces====
The first situation is if you are not requiring an extension that contains an interface. Now, when the extension unloads, your extension will not be unloaded first. This creates a small problem, as you must clean up without being unloaded. There are two functions you can implement in your extension class to resolve this, both documented in <tt>IExtensionSys.h</tt>:
*<tt>QueryInterfaceDrop</tt> - Allows you to request unloading when a specific interface is unloaded. This is the default behavior for all interfaces. If you want to block this functionality, continue reading.
*<tt>NotifyInterfaceDrop</tt> - This is called when an interface is dropped. If your plugin will not be unloaded, you can use this to clean up any resources on a specific interface being removed.

====Circular Dependencies====
The second situation is a bit more complicated. It is possible for two extensions to have circular dependencies. For example:
*Extension "A" requires extension "B."
*Extension "B" requires extension "A."

If either extension is unloaded, the opposite extension is unloaded normally. The first extension then receives the interface drop callbacks. In this situation, it is essential that the <tt>NotifyInterfaceDrop</tt> function be implemented and used with the circular interface. Otherwise, you risk crashing when your extension unloads (or at the very least, leaking memory). Since the actual drop order is undefined, it means both extensions must implement this function to be safe.

=Automatic Loading=
There are two types of automatic loading: Dynamic and Global. Dynamic loading means your extension is only loaded when a plugin requires it. Global loading means your extension loads no matter what.

==Dynamic Autoloading==
Dynamic loading requires that you create an include file for plugins. Plugins that include your file will automatically load your extension. This requires implementing the <tt>Extension</tt> structure found in <tt>core.inc</tt>. You must expose the structure as <tt>public</tt>, and the name must start with "<tt>__ext_</tt>".

<pawn>/**
* Do not edit below this line!
*/
public Extension:__ext_geoip =
{
name = "GeoIP",
file = "geoip.ext",
#if defined AUTOLOAD_EXTENSIONS
autoload = 1,
#else
autoload = 0,
#endif
#if defined REQUIRE_EXTENSIONS
required = 1,
#else
required = 0,
#endif
};
</pawn>

Explanations:
*name: The name of your module as written in <tt>SMEXT_CONF_NAME</tt>.
*file: The platform-inspecific portion of your extension's file name.
*autoload: Specifies that your module should always dynamically autoload by default. You can tweak this to either never autoload or always autoload (without letting the user toggle).
*required: Specifies whether or not this extension is '''required''' by your plugin. If for some reason your extension fails to load (or is not found), the plugin will also fail to load. This is changeable if you wish to override the default behavior.

You can copy and paste this example, but remember to modify the following portions:
*__ext_geoip: Change the "geoip" portion to your own unique variable name.
*"GeoIP: Change the GeoIP portion to your extension's name. This should match the name you chose as <tt>SMEXT_CONF_NAME</tt>.
*"geoip.ext": Change this to your extension's file name, without the .dll/.so portion.

==Global Autoloading==
To have your extension always autoload, you must create a ''.autoload'' file in the <tt>extensions</tt> folder. For example, to have the <tt>threader.ext.dll</tt> or <tt>threader.ext.so</tt> extensions autoload, you'd create the following file in <tt>extensions</tt>: <tt>threader.autoload</tt>.

A few notes:
*This only works for extensions using the .ext.<platform> convention. SourceMod cuts off the ".autoload" portion of the file, then adds on ".ext.dll" or ".ext.so" which will not work on custom files.
*The file does not need to contain anything, it simply needs to exist.

=Conventions=

==Designing API/Natives==
*Start interface names with the capital letter 'I'.
*Use a consistent naming convention. SourceMod uses [http://msdn2.microsoft.com/en-us/library/ms229002.aspx Microsoft/Pascal] naming. Avoid Java/Camel casing for both API and natives.
*When exposing interfaces, make sure your exposure defines start with <tt>SMINTERFACE_</tt> and end with <tt>_NAME</tt> and <tt>_VERSION</tt>

==External Naming==
*Logtags (<tt>SMEXT_CONF_LOGTAG</tt>) should be short names (under 10 characters or so) in all capital letters.
*Your extension file name should never have <tt>_i486</tt> or other unnecessary platform-specific notations in its name.
*Your extension file name should always end in <tt>.ext.so</tt> or <tt>.ext.dll</tt> depending on the platform. The <tt>.ext.</tt> is SourceMod convention.

=Setting up Visual Studio=
==Paths==
'''Visual Studio 2003''': Tools -> Options -> Projects, VC++ Directories

'''Visual Studio 2005''': Tools -> Options -> Projects and Solutions -> VC++ Directories

===Include Paths===
*SourceMod only:
**sdk\public\extensions
**sdk\public\sourcepawn
**sdk\public
*SourceMM (Note that sourcemm might be 'trunk' for you):
**sourcemm\core
**sourcemm\core\sourcehook
*HL2SDK:
**game\shared
**public\vstdlib
**public\tier1
**public\tier0
**public\engine
**public
**dlls

===Link Paths===
*HL2SDK:
**lib\public for version 2005
**lib-vc7\public for version 2003

==Compiler Options==
Note: These options are set by default in the sample Extension SDK. 
Note: These options should be set for every build (Release/Debug/others).

For VS 2005, goto Project->Properties.

*General
**<tt>Character Set</tt>: '''Use Multi-Byte Character Set'''
*C/C++
**General
***<tt>Detect 64-bit Portability Issues</tt>: '''No'''
**Preprocessor
***<tt>Preprocessor Defines</tt>: Add <tt>_CRT_SECURE_NO_DEPRECATE</tt>, <tt>_CRT_NONSTDC_NO_DEPRECATE</tt>, <tt>SOURCEMOD_BUILD</tt> and <tt>WIN32</tt>
**Code Generation
***<tt>Runtime Library</tt>: Multi-threaded or /MT (for Release), Multi-threaded Debug or /MTd (for Debug)
*Linker
**General
***<tt>Output File</tt>: Change <tt>$(ProjectName)</tt> to <tt>$(ProjectName).ext</tt>, or use your own custom string.
**Input
***<tt>Additional Dependencies</tt>: <tt>tier0.lib tier1.lib vstdlib.lib</tt> (for SourceMM attached extensions only)

[[Category:SourceMod]]
[[Category:SourceMod Development]]

Pawn Tutorial

2010-01-14T01:56:11Z

Seta00:

{{qnotice|This guide is rather hardcoded to [[AMX Mod X]]. It needs to be mode generic.}}

This guide is designed to give you a more in-depth overview of the basics of programming in [[Pawn]].

=Introduction=
Pawn is an embeddable, (almost) typeless, easy to use scripting language that is compiled for a virtual machine. [[AMX Mod X]] uses Pawn to route scripting functions to the Half-Life engine, using the Pawn [[Virtual Machine]] and [[Metamod]] ([[Pawn]] is written in C, Metamod is written in C++). While you write Pawn scripts in a text editor, the scripts must be compiled with a "Compiler", which produces a binary for AMX Mod X. The AMX Mod X team distributes a specially modified Pawn compiler.

Programming scripts in Pawn is relatively easy, and does not have concepts in other languages that are unnecessary for general use, such as pointers, vectors, structs, classes, allocation, et cetera.

==Language Paradigms==
Pawn was originally named "[[Small]]" to emphasize the size of the language specification. The language sacrifices many features found in modern languages to achieve simplicity and speed, which are required for embedded uses.
*No typing
**Pawn only has one data type -- the "[[Cell_(Pawn)|cell]]". It is the size of the processor's integral pointer (4 bytes for 32bit processor, 8 bytes for 64bit processors). This has two major implications - Pawn bytecode is processor specific, and pointers can fit inside a cell.
**[[Tagging_(Pawn)|Tagging]] - Pawn lets you create weakly statically typed "tags", which can be associated with variables for primitive operator overloading. For example, Pawn has no concept of floating point numbers (only integers). Instead, operators are overloaded with the Float: tag to redirect computation to new functions. Tag-checking is only enforced as a warning.
**Since Pawn only has one datatype, it does not support structs, records, objects, or anything else.
**Pawn does support arrays of cells, which leads to C-style arrays for strings.
*No garbage collection
**Pawn has no "heap" allocation built-in. All variables are stored on the stack or in the data section. Therefore, no garbage collection is necessary and memory leaks are not possible from the language specification alone.
*Procedural
**Pawn is entirely comprised of single, non-nested subroutines. There are no lambda functions, member functions, constructors, et cetera. Functions can either be internal (within the script) or public (exposed to the VM by name, like C's "extern").
*No thread-safety
**Pawn is targetted toward single-thread instances.

==Implementation Features==
*Cross-platform compatible compiler, which outputs bytecode and debug browsing information.
*Cross-platform compatible Virtual Machine (VM), with support for debug browsing, halting/stopping execution, and interacting with scripts from C/C++ libraries.
*IA32 JIT Compiler for vastly increasing script execution time.

Because the footprints of the VM and JIT are so small, Pawn is ideal inside games which need a simple and highly fast event system, embedded devices or applications, and realtime systems.

==License==
Pawn is licensed under the [[ZLib/libpng_License]] license.

=Variables=
Variables are simple structures for holding data throughout a period of time in your script.

==Types==
Small has just three data types for declaring variables. The default variable type is a regular whole number, or integer. A variable name, for backwards compatibility, should be 19 characters or less, and MUST start with a letter. It can contain the symbols A-Z, a-z, 0-9, and the underscore ("_"). It is important to note that variable names are case sensitive - "myvar", "MyVaR", and "MYVAR" are three separate symbols.

===Integers===
The simplest data type in Pawn is an "integer". Integers are whole numbers. To declare a new integer variable, use the "new" operator like so:

<pawn>new a //Declare empty variable "a"
new b=5 //Declare variable "b" and set it to 5.
new c=5.0 //This is invalid, technically not a whole number!
new d="hello" //"hello" is not a number either, this is invalid.

//You can also declare multiple variables on one line:
new e,f,g,h
new x=7, y=3
new z = 1_000_000 // Pawn supports numbers like this. So big values are easier to read.</pawn>

===Floats===
You can also declare a variable as a "Float", which means it can store numbers with decimal places. These are called "floating point" numbers:

<pawn>new Float:a //Declare empty floating point variable "a"
new Float:b=5.3 //This will declare a new variable "b" and assign 5.3 to it.
new Float:c=5 //This is valid, but the compiler will give you a warning.
new Float:d="hello" //This is invalid, "hello" is not a decimal number.</pawn>

You can also do the following:
<pawn>//float(n) is a function that takes a number n and makes it a
// floating point number.
new Float:var = float(5)
new Float:var2 = 5.0
new Float:var3 = 1.0*5
new var4 = floatround(5.0)
//Note: floatround(n) is a function that takes a number n and rounds it to a whole number.
// this makes the assignment to a regular integer variable valid.</pawn>

Note - Spacing does generally not matter, as long as the compiler can tell symbols apart from each other. If your spacing is REALLY bad, you will get errors or maybe even warnings. For example, "new var = 5" and "new var=5" are the same, but "newvar=5" is totally wrong.

===Booleans===
The last variable type is "boolean". It is very simple - it is either "true", or "false". Both "true" and "false" are predefined data structures.

<pawn>new bool:IsItOn //Declares a new variable "IsItOn" which is automatically false
new bool:xyz=true //Declares a new variable "xyz" set to true</pawn>

=Arrays=

Pawn features basic "arrays". An array is a simple type of aggregate data. This means you can store multiple values in one variable! An array follows the same rules as a regular variable, and it has the same types. It simply can contain multiple values. You define an array with brackets, and how many values it can hold. For example:

<pawn>//This will declare a variable called "Players" which holds 32 numbers.
new Players[32]

//You can now store values in any of the 32 "slots" this array has.
// The slots are numbered from 0 to n-1, or in this case, 0 to 31.
//Every slot starts off as 0.

//Set slot 0 to 5
Players[0] = 5

//Set slot 1 to whatever is in slot 0, in this case, the number 5
Players[1] = Players[0]

//This is invalid!
//Although there are 32 slots, they are numbered from 0 to 31.
//Doing this results in AMX Native Error 4 - AMX_ERR_BOUNDS
// or, it simply won't compile!
Players[32] = 15

//This is also totally invalid
Players[-1] = 6

new a = 3
//This is also totally invalid.
//a must be a constant number.
new BadArray[a]

//So this is valid:
const b = 3
new GoodArray[b]

//You can also use Compiler Directives (See last section)

#define ARRAY_SIZE 3
new Array[ARRAY_SIZE]</pawn>

Arrays can also be declared with groups of data default, such as:

<pawn>new Numbers[4] = {0,1,2,3}
//Note: it is important that you make sure the amount of numbers
// you pass and the size of the array match</pawn>

You can also use any data type with arrays:

<pawn>//Array of floating points:
new Float:Numbers[4] = {0.0, 1.2, 2.4, 3.8}
//Array of booleans. Note this sets every slot to true.
new bool:playerHasGun[33] = {true, ...}</pawn>

=Strings=

You have probably noticed that an important data type is missing - characters (letters and symbols). These are called "strings", and in Pawn, they are technically numbers! A string is an array of numbers that translate to ASCII (character) symbols. For example:

<pawn>//This will declare a number array "myString" that contains the data "Hello".
//It will have 6 slots, because there are 5 characters.
//The last slot is reserved for the number 0, which tells the Pawn engine that it is a string.
new myString[] = "Hello"</pawn>

Note: anything in between /* and */ is also a comment. You cannot use /* */ inside a /* */. The following set of commands achieves the same purpose, however, it is longer and not recommended. This works because each character of the string "Hello" is stored in a slot in the array.
<pawn>new myString[6]
myString[0] = 'H'
myString[1] = 'e'
myString[2] = 'l'
myString[3] = 'l'
myString[4] = 'o'
myString[5] = 0</pawn>

{{qnotice|Arrays that are meant to be strings must end in a 0, or the null character. This is so you know where the string ends.}}

You CANNOT do this! While it may compile, it is highly dangerous as it might cause overflow errors:
<pawn>new myString[6]
myString = "Hello" //INVALID!
myString[0] = "Hello" //INVALID!
//To add data to a string, you can do this:
new goodString[7]
copy(goodString, 6, "Hello")</pawn>

Note that we copied 6 cells of the array into an array that can hold 7. If we were to copy 7 bytes into this array, copy() could potentially copy an extra byte for the Null character, overflowing the array. This is called a [[buffer overflow]] and must be carefully avoided.

More examples:
<pawn>//Copy is a function that takes three parameters:
copy(destination[], length, source[])
//It copies the string inside the source array and places
// it into the destination array, but only copies up to length characters.

//Lastly, to prove that a string is really an array of numbers, this is completely valid:
new weird[6]
weird[0] = 68
weird[1] = 65
weird[2] = 73
weird[3] = 86
weird[4] = 68
weird[5] = 0
//This will set the variable "weird" to the string "DAVID".
//To see how letters and symbols translate into numbers, visit www.asctiitable.com </pawn>

=Functions=

Pawn allows you to define your own functions. This comes in handy for removing code that is used in multiple places. Note that all functions should return a value. To do this, you use the "return" command, which immediately halts the function and returns the value of the expression passed to it. No code is executed in a function once the return is found. Here are some examples:

<pawn>//This is a function that takes no parameters and returns 1.
//When activated, it uses the (non-existant) print function.
show()
{
print("Hello!")

return 1 //End, return 1
}

//Activate like this:
show()</pawn>

You can also declare functions to take parameters.

<pawn>//This declares a function called "add_two_numbers", which takes two numbers and returns the sum.
add_two_numbers(first, second)
{
new sum = first + second

return sum //Return the sum
}
//Then you can use your new function like this:

new a,b
a = 5
b = 12
new c = add_two_numbers(a,b)
//c will now be equal to 17.</pawn>

You are not limited by what types of data parameters can accept. When you give parameters to a function, it is called "passing". You can pass either data or a variable to a function.

<pawn>//This defines a new function called "add_two_floats"
// which takes two floating points and returns the sum
Float:add_two_floats(Float:first, Float:second)
{
new Float:sum = first + second

return sum
}

new Float:a
new Float:b
a = 5.0
b = 6.3
new Float:c
c = add_two_floats( a+b )
//c is now equal to 11.3</pawn>

You can even pass arrays! You do not have to specify the size of the array. If you do, you must make sure you are calling the function with an array of equal size and type.
<pawn>add_two_from_array(array[], a, b)
{
new first = array[a]
new second = array[b]
new sum = add_two_numbers(first, second) //use our function from earlier

return sum
}</pawn>

Note, that when you pass arrays through a function they are passed through what is called "by reference". When a normal variable is passed to a function, it is copied in memory, and the copy is sent and then deleted afterwards. This is not the case with an array. Because arrays can be very large, the array is "referenced" instead of copied. This means if you change the array, afterwards it will stay changed. For example:

<pawn>//This function will switch slots a and b inside any array passed to this function.
swap_slots(array[], a, b)
{
//Note, you need to temporarily hold one of the slots before swapping them
//Otherwise, you can't swap both values! This is a classic problem.
//If you have a and b, setting b equal to a eliminates the original value in b.
new temp

temp = array[b]
array[b] = array[a]
array[a] = temp
}

new myArray[2]
myArray[0] = 5
myArray[1] = 6
swap_slots(myArray, 0, 1)
//myArray[0] is 6, myArray[1] is 5</pawn>

You can prevent arrays from being modified by declaring them "constant", like so:
<pawn>add_two_from_array(const array[], a, b)
{
new first = array[a]
new second = array[b]
new sum = add_two_from_array(first, second)
return sum
}
//Note, now when you use the function, you are guaranteed that the array will not be modified.</pawn>

This function modifies an array passed as a constant. It will not work.
<pawn>bad_function(const array[])
{
array[0] = 0
}</pawn>

=Expressions=

Expressions are just what they sound like from mathematics. They are groupings of symbols that return one piece of data. Expressions are normally comprised of parenthetical expressions, and are evaluated in a certain order (from innermost to outermost, parenthesis first, then multiplication, division, addition, subtraction, et cetera). You can put expressions anywhere. You can set variables equal to them or pass them to functions.

<pawn>//This is the simplest expression. It returns the number zero.
0
//However, to make it easier to read, this is also valid:
(0)</pawn>

If an expression is not zero or it is not false, it not only returns a value, it also returns "true". Otherwise, it will return 0, which is also "false".

<pawn>//Here are more mathematical expressions. The mathematical operators are
// + for addition
// - for subtraction
// * for multiplication
// / for division
// % for modulus (finding the remainder of one number divided by another (5%2 is 1)
(5+6) //returns 11
((5*6)+3) //returns 33
((((5+3)/2)*4)-9) //returns 7
((5*6) % 7) //returns 2
//Here are other expressions:
(true) //returns true
(5.0 + 2.3) //returns 7.3 as a floating point</pawn>

There are also extensions of these operators for direct use on variables.
<pawn>new a = 5
new b = 6
//The first are the post/pre increment and decrement operators.
a++ //returns a+1, or 6. This is a post increment.
++a //also returns a+1, or 6. This is a pre increment.</pawn>

The difference between the two is subtle but important. a++ is evaluated LAST in an expression, while ++a is evaluated FIRST. This differences comes in handy with code that uses loops in certain ways. It is also important to know that the increment/decrement operators will not only return a+1, but set the variable a to a+1.

<pawn>a-- //returns 4, post decrement
--a //returns 4, pre decrement</pawn>

Note that a++ essentially trims down this code:
<pawn>a = a + 1</pawn>
However, there is another way to write lines of code of this form:
<pawn>a = a OP y</pawn>
Where OP is a math operator. It can be shortened to:
<pawn>a OP= x</pawn>
Observe:
<pawn>a += 1 //This sets a to a + 1
a -= b //This sets a to a - b
a *= 0 //This multiplies a by 0
a /= 2 //This divides a by 2.</pawn>

However, mathematical operators are not the only operators you are given. There are boolean operators to help you with logical circuits or logical decisions.

The and operator takes in the left expression and right expression. If both are "true", then it returns true.

<pawn>//This is false, because 1 returns true and 0 returns false.
//Since both are not true, && returns false.
(1 && 0)
(1 && 2) //Both numbers are "true", therefore the expression is true.
(true && false) //false
(false && false) //false
(true && true) //true</pawn>

The other important operator is "or". It returns true if one of two expressions are true.
<pawn>(1 || 0) //true, since one of the values is true.
(1 || 2) //true
(true || false) //true
(false || false) //false
(true || true) //true</pawn>

There are other operators as well, that you may not use as often. The "bitwise and" operator returns whether a binary bit sequence is contained in another sequence. In the technical terms, it does an "and (&&)" operation on each of the bits in both numbers. For example, say you have the number "9", which is "1001" in binary. If you want to know if that sequence contains the number "8" (1000), you can do:

<pawn>//This will return 8, which means 8 is indeed a bit in 9.
(9 & 8)
//4 (00100) is not a bit inside 16 (10000) and this will return 0.
(16 & 4)
//The next operator is "bitwise or"
//which does an "or (||)' operation on each of the bits in both numbers.
//This will take 9 (1001) and match it with 3 (0011), resulting in 1011, or 11.
(9 | 3)</pawn>

These two operators are also important, but not used often. They are the bitwise shift operators, << is a left shift and >> is a right shift. They shift the bits in a number to one direction.

<pawn>//This takes the number 3 (00011) and shifts it three places to binary (11000), or 24.
(3 << 3)
//This takes the number 24 (11000) and shifts it three places to binary (00011), or 3.
(24 >> 3)</pawn>

The last operator is "bitwise not". It returns the exact opposite of whatever is given to it. When used on a number, it will return each of the bits flipped (1 to 0, 0 to 1).

<pawn>//This returns false
(!true)
//This returns true
(!false)
//This takes 9 (binary 1001) and makes it 6 (binary 0110).
//This is the "bitwise complement" operator, which performs a !(not) on each bit.
(~(9))</pawn>

=Conditionals=

Conditionals allow you to test if an expression meets a standard, and to execute code based on that decision.

==If Statements==

The most important conditional is called "if ... then". If evaluates whether a given expression is true or false. It if is true, it executes a block of code. If not, it executes a different block of code. For example:

This is an example of the most basic if ... then statement. The first line checks to see if the expression is true. In this case, if the variable a is equal to 5, then the if statement will execute the block of code underneath it, which sets a to 6.

<pawn>if (a == 5)
{
a = 6
}</pawn>

However, what happens if a does not equal 5? Then the code will not be executed. However, you can tell it to execute code if the conditions are not met. Now, if a is equal to 5, a will be set to 6. Otherwise, it will be set to 7.

<pawn>if (a == 5)
{
a = 6
} else {
a = 7
}</pawn>

There are many different operators you can use inside the if () statement. In fact, you can use any [[#Expressions|expression]] that evaluates to true (not zero) or false (zero).

<pawn>//This will return true if a does not equal 5
if (a != 5) {}
//Returns true if a is greater than 5
if (a > 5) {}
//Returns true if a is less than 5
if (a < 5) {}
//Returns true if a is greater than or equal to 5
if (a >= 5) {}
//Returns true if a is less than or equal to 5
if (a <= 5) {}
//Returns true because 11 is true
if (5+6) {}
//Returns true of both a and b are true
if (a && b) {}
//Returns true if 7.5 is greater than c
if ( ((5*3)/2) > c) {}
//Always returns true no matter what
if (true) {}
//Never returns true
if (false) {}</pawn>
Note that array comparisons have restrictions. This is invalid:

<pawn>my arrayOne[3]
my arrayTwo[3]
if (arrayOne == arrayTwo) {</pawn>

You must do:
<pawn>if ((arrayOne[0] == arrayTwo[0]) &&
(arrayOne[1] == arrayTwo[1]) &&
(arrayOne[2] == arrayTwo[2])) {</pawn>

Obviously, this would get very tedious with large arrays. You will see later on how to easily compare strings and arrays.

The if...then model of conditional switching can be brought up to another level. Pawn provides a way for you to provide multiple levels of true and false expressions.

<pawn>//Example of "if...else if"
if (a == 5) {
//This code will be run if a is 5.
} else if (a < 6) {
//This code will be run if a is less than 6
} else if (a == 7) {
//This code will be run if a is 7.
} else {
//If none of the above conditions are met, this code will be run.
}</pawn>

It is important to note that in the above example, each code block is not "fall through". That means each of the conditions will be checked in order, and if one is true, the code will be executed and the if statement is done. It will not execute multiple true conditions.

==Switch Statements==

Lastly, there is one last type of conditional statement. It is called a "switch" statement, and it allows you to make a nicely ordered list of conditions similar to, but not as powerful as, "if...else if".

<pawn>//Example of a switch statement
switch (a)
{
case 5:
{
//This code will run if a is equal to 5
}

case 6:
{
//This code will run if a is equal to 6
}

case 7:
{
//This code will run if a is equal to 7
}

default:
{
//This code will run if all other cases fail
}
}</pawn>
Multiple conditions are also possible in pawn:
<pawn>//Example of an multiple switch statement
switch (a)
{
case 1, 2, 3:
{
//This code will run if a is equal to 1 or 2 or 3
}

case 4, 5, 6:
{
//This code will run if a is equal to 4 or 5 or6
}

case 7, 8, 9:
{
//This code will run if a is equal to 7 or 8 or 9
}

default:
{
//This code will run if all other cases fail
}
}</pawn>
You could use the switch statement also for ranges:
<pawn>//Example of an range switch statement
switch (a)
{
case 0 .. 50:
{
//This code will run if 0 <= a <= 50
}

case 51 .. 100:
{
//This code will run if 51 <= a <= 100
}

case 101 .. 200:
{
//This code will run if 101 <= a <= 200
}

default:
{
//This code will run if all other cases fail
}
}</pawn>
Note that a switch is not "fall-through". If a case is true, no other cases are evaluated.

=Looping=

Looping is essential for any language. It allows you to perform the same block of code over and over, by constructing conditions on which code should be repeated.

==For Loops==

The first and most widely used loop is called a "for loop". It takes an initial value, a condition upon which it should stop, and an incremental step. Then it executes code until it the conditions are no longer true. This lets you repeat the same block of code any number of times. Example:

<pawn>/*A for loop has three parameters:
for (initial; condition; increment)
{
//your code here
}

Before the first loop executes, it runs your initial condition.
Then it begins looping your code with these steps:
1. Check if the condition is true. If so, continue. If not, stop.
2. Run the code.
3. Run the "increment" parameter.
4. Go to step 1.
*/

//Example of a for loop
new i
new sum
for (i=1; i<=10; i++)
{
sum += i
}</pawn>

Explanation:

#The first parameter, i=1, sets the i variable to one. This happens before the looping starts.
#Next, the "increment" parameter is checked. This parameter is a post-increment operator, so 1 will be added to i after the entire code block is evaluated.
#Then the condition is checked. Is i<=10? It is currently 1, so it is indeed less than or equal to 10.
#Since the condition is true, sum+=i is executed. This means i is added into sum.
#The code block has finished, and i++ increments i to 2.
#Now it repeats.
#Is i<=10? Yes, it is 2. Now sum+=i runs again, and now sum is equal to 3.
#The code block has finished, and i now increments to 3.
#This happens until...
#The increment parameter sets i to 11. The condition is no longer true, and the for loop is finished.
#The sum variable now holds the number 55, which is the sum of 1 through 10.

This provides a nice way of managing arrays!

<pawn>//Note: this provides a nice way to loop through arrays! Observe this function below.
sum_of_array(myArray[], size)
{
//Note: Make sure the user passes the size of the array, so we don't overflow it.
new i, sum

//This loop will start at 0 and stop right before size is reached.
//If the user passes the correct size of the array,
// the loop will be going from 0 to size-1
// This correctly matches the numbers of slots in the array.
for (i=0; i<size; i++)
{
//For every time this loop executes,
// i will be a number from 0 to size-1
//Add the value of the slot (i) in the array to sum.
//Once this is finished, sum will contain
// the sum of all slots in the array.
sum += myArray[i]
}

return sum
}

new NumberArray[4]
NumberArray[0] = 3
NumberArray[1] = 1
NumberArray[2] = 4
NumberArray[3] = 1

new answer = sum_of_array(NumberArray, 4)
//answer will be 3+1+4+1, or 9

//Here is a function to compare if one array is equal to another (i.e. a string)
bool:compare_arrays(array1[], array2[], size)
{
new i
for (i=0; i<size, i++)
{
//If a slot does not match, halt the function and return false.
if (array1[i] != array2[i])
{
return false
}
}

//If the function got to this point without returning false, return true.
return true
}</pawn>

==While Loops==

The next kind of loop is also very important, and is simpler than a for loop. Called a "while" loop, it only takes one parameter: a condition. As long as the condition is true, it keeps executing code. See the above examples rewritten with while loops.

<pawn>//Basic loop
new i=0
new sum

while (++i <= 10)
{
sum+=i
}

sum_of_array(array[], size)
{
new i=0, sum

//Do this loop while i is less than the size.
//i is incremented at the end of every loop.
while (i++ < size)
{
sum += array[i]
}

return sum
}

bool:compare_arrays(array1[], array2[], size)
{
new i
while (i++ < size)
{
if (array1[i] != array2[i])
{
return false
}
}

return true
}</pawn>

==Two Dimensional Arrays==

In Pawn it is possible to have arrays where each slot is another array. This is very useful for storing a table of data, where the first section of slots is a row and the second section of slots is a column. Two dimensional arrays are declared like so:

<pawn>//This declares an array with 50 rows and 50 columns.
new BigArray[50][50]
//this declares a floating point array with 25 rows and 10 columns.
new Float:BigArray[25][10]</pawn>

Each slot in the first subset of the array becomes its own array.

<pawn>new BigArray[3][3]
BigArray[0][0] = 10
BigArray[0][1] = 20
BigArray[0][2] = 30
BigArray[1][0] = 40
BigArray[1][1] = 50
BigArray[1][2] = 60
BigArray[2][0] = 70
BigArray[2][1] = 80
BigArray[2][2] = 90</pawn>

Will result in BigArray looking like this:
:{|
|-
| BigArray
| 0
| 1
| 2
|-
| 0
| 10
| 20
| 30
|-
| 1
| 40
| 50
| 60
|-
| 2
| 70
| 80
| 90
|}

Note that our old sum_of_array() function can still work! We can do:

<pawn>new sum = sum_of_array(BigArray[2], 3)</pawn>

Because BigArray[2] contains a second, single dimensional array, containing {7,8,9}. However, let's write a 2D sum of array function.

<pawn>//This function will tally up a two dimensional array.
sum_of_table(array[][], rows, cols)
{
new i, j, sum

//Note, there is a loop inside the loop.
//This lets you go through each array inside the
// bigger array.
for (i=0; i<rows; i++)
{
for (j=0; j<cols; j++)
{
sum += array[i][j]
}
}

return sum
}</pawn>

Note, it is also possible to store an array of strings using two dimensional arrays.

<pawn>new StringList[3][] = {"Hello", "my", "friend"}
/*
StringList[0][0] through [0][5] contains "Hello"
StringList[1][0] through [1][2] contains "my"
StringList[2][0] through [2][6] contains "friend"
*/</pawn>

The table for StringList will look like:
StringList 0 1 2 3 4 5 6
0 H e l l o \0
1 m y \0
2 f r i e n d \0

Comparing strings in multidimensional arrays is also similar:

<pawn>if (StringList[0] == "Hello") //INVALID
if (StringList[0][0] == "Hello") //INVALID
if (equali(StringList[0], "Hello")) //Valid</pawn>

=Compiler Pre-processor Directives=

Compiler directives allow you to change how your code is read. This is rather advanced and will only be run over briefly.

<pawn>//To bind a symbol to a value, you can do this:
#define SYMBOL VALUE
//for example:

#define MAX_STRING 250
new String[MAX_STRING]

#define HELLO "Hello. This is a generic greeting."
new Hello[MAX_STRING] = HELLO</pawn>

You can also use #defines to change the flow of code the compiler makes.
<pawn>#if defined LINUX
//This portion will be compiled if #define LINUX exists
execute_command("ls -l")
#else
//This portion will be compiled if #define LINUX does not exist
execute_command("dir")
#endif</pawn>

You can also change how much memory your script uses.
<pawn>#pragma dynamic 4096
//This creates a 16K stack of memory (default).
//It is measured in blocks of 4 byte cells.</pawn>

You can also specify whether semicolon usage is required to terminate a line of code (by default it is not required).
<pawn>#pragma semicolon 1</pawn>

You can also change the control character( amxx std: '^' )
<pawn>#pragma ctrlchar '\'
//this sets the control character to backslash( c/c++/c#/java/... std )
// now you have to use the \ instead of ^
// e.g. "this is ^":D^" " must be now " this is \":D\" "</pawn>

=Conclusion=

This guide should have given you a VERY brief introduction to basic Pawn programming. It is by no means comprehensive and it should not constitute the entirety of one's knowledge of Pawn. To read the official Pawn documentation and language guide, go this website: http://www.compuphase.com/pawn/Pawn_Language_Guide.pdf (Note, this guide is very long and should be used as a reference. You may want to try the Small forums or the AMX Mod X forums). Continue to the next Section to see how to apply Small programming to the Half-Life and AMX Mod X engine!

=External Links=
*[http://www.compuphase.com/pawn/Pawn_Language_Guide.pdf Pawn Language Reference]
*[http://www.compuphase.com/pawn/pawn.htm Pawn Homepage]
*[http://www.compuphase.com/ ITB CompuPhase]

[[Category:Scripting (AMX Mod X)]]