Upload 29 files

EngFunc_AlertMessage.txt

@@ -0,0 +1,20 @@
+Fakemeta function :
+Code:
+EngFunc_AlertMessage
+
+Description :
+Prints an alert message.
+
+
+Usage:
+Code:
+engfunc(EngFunc_AlertMessage, AlertType, const Message)
+
+
+AlertType can be:
+at_notice -
+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.

EngFunc_AnimationAutomove.txt

@@ -0,0 +1,25 @@
+Fakemeta function :
+Code:
+EngFunc_AnimationAutomove
+
+Description :
+Plays the selected animation on entity
+
+
+Usage :
+Code:
+entity_set_float(iEnt, EV_FL_framerate, fFrameRate);
+entity_set_int(iEnt, EV_INT_sequence, iSequence);
+engfunc(EngFunc_AnimationAutomove, iEnt, fTime);
+
+Parameters
+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
+__________________

EngFunc_CheckVisibility.txt

@@ -0,0 +1,72 @@
+Fakemeta function:
+PHP Code:
+EngFunc_CheckVisibility 
+Description:
+This function is used to check if an entity is in your PVS.
+It can be used on all entities except worldspawn!
+Here I will show you how to use is, since this function has a paramater that must be obtained in a special way!
+
+What is PVS?
+PVS means potentially visible set, this means that the entities that we have in this list can be seen.
+PVS does not hold just the entities that we see!
+By knowing this we can get to the conclusion that PVS has the role of limiting data transfer for better internet connection/lower amount of data transfer!
+
+So in small words I want to say something like this:
+Code:
+Entity that is in PVS => Can be seen => Data Transfer about that entity
+Entity that it is not in PVS => Can not be seen => No data transfer => Save bandwidth
+How does it work?
+Well let's say that every room of the map is a cube.
+We find ourselves in a room and that also means that we are in the cube of that room.
+We can see the entities in the next rooms because the cubes of that room touch with the cube of the room we are in.
+
+How do I use this function?
+Well this function has a parameter that must be obtained in a special way. That is the "pset" parameter.
+Here is how you obtain that 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".
+
+Example Usage:
+PHP Code:
+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
+} 

EngFunc_DecalIndex.txt

@@ -0,0 +1,18 @@
+Fakemeta function :
+
+Quote:
+EngFunc_DecalIndex
+
+Description :
+
+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 )
+As side-note a plugin Decals/Models Lister is available to see a list of decals/models index/name. ( Only CS and HL )
+
+Usage :
+
+Code:
+DecalIndex = engfunc( EngFunc_DecalIndex, "{bigshot1" );
+__________________

EngFunc_FindClientInPVS.txt

@@ -0,0 +1,46 @@
+Fakemeta function:
+PHP Code:
+EngFunc_EntitiesInPVS 
+Description:
+This function checks entities that are in the PVS of an entity.
+It can be used on all entities except worldspawn!
+
+What is PVS?
+PVS means potentially visible set, this means that the entities that we have in this list can be seen.
+PVS does not hold just the entities that we see!
+By knowing this we can get to the conclusion that PVS has the role of limiting data transfer for better internet connection/lower amount of data transfer!
+
+So in small words I want to say something like this:
+Code:
+Entity that is in PVS => Can be seen => Data Transfer about that entity
+Entity that it is not in PVS => Can not be seen => No data transfer => Save bandwidth
+How does it work?
+Well let's say that every room of the map is a cube.
+We find ourselves in a room and that also means that we are in the cube of that room.
+We can see the entities in the next rooms because the cubes of that room touch with the cube of the room we are in.
+
+How do I use this function?
+Well this function doesn't work like EngFunc_FindEntityInSphere so the HL engine has another method of providing the information.
+At first this function returns a start entity and after that we can find the next entity using pev_chain/EV_ENT_chain. And so on, untill pev_chain is NULL.
+
+Example Usage:
+PHP Code:
+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
+    }
+} 

EngFunc_FindEntityInSphere.txt

@@ -0,0 +1,25 @@
+Fakemeta function:
+PHP Code:
+EngFunc_FindEntityInSphere 
+Description:
+Find entities within a radius. The function returnes the next entity id after the start entity!
+
+This is a drawing to show how this function works:
+[IMG]http://img265.**************/img265/2395/screenshot053.png[/IMG]
+
+
+If we use
+PHP Code:
+engfunc(EngFunc_FindEntityInSphere, -1, origin, radius) 
+The function in the situation above will return 1!
+PHP Code:
+engfunc(EngFunc_FindEntityInSphere, 20, origin, radius) 
+The function in the situation above will return 30!
+PHP Code:
+engfunc(EngFunc_FindEntityInSphere, 100, origin, radius) 
+The function in the situation above will return 0, meaning that it didn't find an entity with an id grater than 100!
+
+
+Usage:
+PHP Code:
+engfunc(EngFunc_FindEntityInSphere, ent_to_start, origin, radius) 

EngFunc_GetBonePosition.txt

@@ -0,0 +1,219 @@
+Fakemeta function:
+PHP Code:
+EngFunc_GetBonePosition 
+Description:
+The 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.
+
+Code:
+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"
+This image shows the locations of the bones, they are marked through blue points. The red point is the player origin.
+
+[IMG]http://img507.**************/img507/7762/playerskeleton.jpg[/IMG]
+
+
+Usage:
+PHP Code:
+// 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]) 
+Useful Stocks:
+These stocks are made for CS/CZ you need to port them to other mods.
+
+This gets the hitgroup of the bone.
+PHP Code:
+#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
+} 
+This gets the closest bone to the gunshot [Use this in FM_TraceLine and Ham_TraceAttack
+PHP Code:
+#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
+} 

EngFunc_MessageBegin.txt

@@ -0,0 +1,36 @@
+Fakemeta Function:
+
+EngFunc_MessageBegin
+
+Description:
+
+This function is used to generate client messages.
+
+Usage:
+
+engfunc(EngFunc_MessageBegin,dest,msg_type,or igin[3]={0,0,0},player=0)
+
+PHP Code:
+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 
+PHP Code:
+//With MSG_ONE_UNRELIABLE
+engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message 
+PHP Code:
+//With MSG_ALL
+ engfunc(EngFunc_MessageBegin,MSG_ONE_UNRELIABLE,SVC_TEMPENTITY,_,id) // Create message 
+dest can be :
+
+Code:
+#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()

EngFunc_ModelFrames.txt

@@ -0,0 +1,14 @@
+Fakemeta function :
+
+Quote:
+EngFunc_ModelFrames
+
+Description :
+
+Returns the frames number of a model.
+
+Usage :
+
+Code:
+ModelFrames = engfunc( EngFunc_ModelFrames, ModelIndex );
+ModelIndex = The model index. Value you can get from precache_model() or EngFunc_ModelIndex.

EngFunc_ModelIndex.txt

@@ -0,0 +1,17 @@
+Fakemeta function :
+
+Quote:
+EngFunc_ModelIndex
+
+Description :
+
+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 :
+
+Code:
+ModelIndex = engfunc( EngFunc_ModelIndex, "models/MyModel.mdl" );

EngFunc_MoveToOrigin.txt

@@ -0,0 +1,26 @@
+Fakemeta function :
+Code:
+EngFunc_MoveToOrigin
+
+Description :
+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 :
+Code:
+engfunc(EngFunc_MoveToOrigin, iEnt, Float:Destination[3], Float:Distance, iMoveType);
+
+Parameters
+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
+Code:
+#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

EngFunc_NumberOfEntities.txt

@@ -0,0 +1,16 @@
+Fakemeta function :
+Code:
+EngFunc_NumberOfEntities
+
+Description :
+Returns the number of entities in the world.
+
+
+Usage :
+Code:
+ents = engfunc(EngFunc_NumberOfEntities);
+
+Engine Replacement :
+http://www.amxmodx.org/funcwiki.php?go=func&id=356
+Code:
+ents = entity_count();

EngFunc_PointContents.txt

@@ -0,0 +1,34 @@
+Fakemeta function:
+PHP Code:
+EngFunc_PointContents 
+Description:
+This function checks an origin and gives us information of its whearabouts.
+
+The constants that this function returns are these:
+Code:
+#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:
+PHP Code:
+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! 

EngFunc_PrecacheModel.txt

@@ -0,0 +1,19 @@
+Fakemeta function :
+
+Quote:
+EngFunc_PrecacheModel
+
+Description :
+
+Precaches a model or sprite file.
+
+This should be used only when you would need to postpone the precache processus 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 :
+
+Code:
+engfunc( EngFunc_PrecacheModel, "models/MyModel.mdl" );
+engfunc( EngFunc_PrecacheModel, "sprites/MySprite.spr" );
+It returns the precached model/sprite index if successful, otherwise 0.

EngFunc_PrecacheSound.txt

@@ -0,0 +1,18 @@
+Fakemeta function :
+
+Quote:
+EngFunc_PrecacheSound
+
+Description :
+
+Precaches a sound, only *.wav file. ( for mp3, see EngFunc_PrecacheGeneric )
+
+This should be used only when you would need to postpone the precache processus 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 :
+
+Code:
+engfunc( EngFunc_PrecacheSound, "sound/MySound.wav" );
+It returns the precached sound index if successful, otherwise 0.

EngFunc_SetModel.txt

@@ -0,0 +1,19 @@
+Fakemeta function :
+Code:
+EngFunc_SetModel
+
+Description :
+Properly sets a new model on an entity.
+
+
+Usage :
+Code:
+engfunc(EngFunc_SetModel, iEnt, sModel);
+
+Parameters
+iEnt = Entity index
+sModel = Model file name to set on entity (ex: "models/player/vip/vip.mdl")
+Engine Replacement :
+
+Code:
+entity_set_model( entity, Model[] );

EngFunc_SetOrigin.txt

@@ -0,0 +1,20 @@
+Fakemeta function :
+Code:
+EngFunc_SetSize
+
+Description :
+Sets the bounds of an entity.
+
+
+Usage :
+Code:
+engfunc(EngFunc_SetSize, iEnt, Float:fMins[3], Float:fMaxs[3]);
+
+Parameters
+iEnt = Entity index
+fMins[3] = Mins boundings values (x,y,z)
+fMaxs[3] = Maxs boundings values (x,y,z)
+Engine Replacement :
+Code:
+entity_set_size( index, Float:mins[3], Float:maxs[3] );
+__________________

EngFunc_SetSize.txt

@@ -0,0 +1,20 @@
+Fakemeta function :
+Code:
+EngFunc_SetSize
+
+Description :
+Sets the bounds of an entity.
+
+
+Usage :
+Code:
+engfunc(EngFunc_SetSize, iEnt, Float:fMins[3], Float:fMaxs[3]);
+
+Parameters
+iEnt = Entity index
+fMins[3] = Mins boundings values (x,y,z)
+fMaxs[3] = Maxs boundings values (x,y,z)
+Engine Replacement :
+http://www.amxmodx.org/funcwiki.php?go=func&id=328
+Code:
+entity_set_size( index, Float:mins[3], Float:maxs[3] );

EngFunc_TraceLine Explanation.txt

@@ -0,0 +1,121 @@
+Fakemeta function:
+PHP Code:
+EngFunc_TraceLine 
+Description:
+This function traces between 2 origins and gives us information about it.
+
+The constants that we can use in flags:
+PHP Code:
+#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.
+
+Here is a drawing that will show you how it works!
+PHP Code:
+engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr) 
+[IMG]http://img529.**************/img529/1863/traceline1.jpg[/IMG]
+
+PHP Code:
+engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr) 
+
+
+PHP Code:
+engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr) 
+
+
+PHP Code:
+engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr) 
+
+
+
+Functions that come with the TraceLine pack:
+PHP Code:
+// Description: This creates a trace handle! 
+// It is important to use because we don't want our plugins to mess with eachothers info!
+new ptr = create_tr2() 
+PHP Code:
+// Description: This creates a trace handle! 
+// It is important to use because we don't want our plugins to mess with each others info!
+free_tr2(ptr) 
+PHP Code:
+// Description: Gets/Sets information from/in the trace_handle
+[g|s]et_tr2(trace_handle, CONSTANT, number_if_needed!) 
+CONSTANT Expresion has this posible values:
+Code:
+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
+};
+The float and array values need the third argument! Example:
+
+PHP Code:
+    new allsolid = get_tr2(trace, TR_AllSolid)
+    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." 
+Example Stock:
+PHP Code:
+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)
+} 

EngFunc_TraceLine.txt

@@ -0,0 +1,120 @@
+Fakemeta function:
+PHP Code:
+EngFunc_TraceLine 
+Description:
+This function traces between 2 origins and gives us information about it.
+
+The constants that we can use in flags:
+PHP Code:
+#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.
+
+Here is a drawing that will show you how it works!
+PHP Code:
+engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr) 
+[IMG]http://img529.**************/img529/1863/traceline1.jpg[/IMG]
+
+PHP Code:
+engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, 0, tr) 
+[IMG]http://img529.**************/img529/1415/traceline2.jpg[/IMG]
+
+PHP Code:
+engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr) 
+[IMG]http://img529.**************/img529/5815/traceline3.jpg[/IMG]
+
+PHP Code:
+engfunc(EngFunc_TraceLine, start, end, IGNORE_GLASS, 0, tr) 
+[IMG]http://img529.**************/img529/326/traceline4.jpg[/IMG]
+
+Functions that come with the TraceLine pack:
+PHP Code:
+// Description: This creates a trace handle! 
+// It is important to use because we don't want our plugins to mess with eachothers info!
+new ptr = create_tr2() 
+PHP Code:
+// Description: This creates a trace handle! 
+// It is important to use because we don't want our plugins to mess with each others info!
+free_tr2(ptr) 
+PHP Code:
+// Description: Gets/Sets information from/in the trace_handle
+[g|s]et_tr2(trace_handle, CONSTANT, number_if_needed!) 
+CONSTANT Expresion has this posible values:
+Code:
+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
+};
+The float and array values need the third argument! Example:
+
+PHP Code:
+    new allsolid = get_tr2(trace, TR_AllSolid)
+    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." 
+Example Stock:
+PHP Code:
+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)
+} 

EngFunc_TraceModel.txt

@@ -0,0 +1,21 @@
+Fakemeta function:
+PHP Code:
+EngFunc_TraceModel 
+Description:
+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!
+
+The constants that we can use in hull:
+PHP Code:
+#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 
+Usage:
+PHP Code:
+// 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!
+engfunc(EngFunc_TraceModel, const Float:start[3], const Float:end[3], hull, ent_to_hit, ptr)

EngFunc_TraceToss.txt

@@ -0,0 +1,27 @@
+Fakemeta function :
+Code:
+EngFunc_TraceToss
+
+Description :
+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 :
+Code:
+engfunc(EngFunc_TraceToss, ent, skipent, tr);
+
+Parameters
+ent = The entity which movement we want to trace
+skipent = The entity to skip in trace
+tr = trace result
+Example:
+
+If you open the attached 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.

TraceModel usage simple example..txt

@@ -0,0 +1,154 @@
+cvars
+shoot_c4 0 - disabled , 1 - ct's can shoot it, 2 - everybody can shoot it
+shoot_smoke 0 - disabled , 1 - enabled
+shoot_flash 0 - disabled , 1 - enabled
+shoot_he 0 - disabled , 1 - enabled
+
+
+#include <amxmodx>
+
+#include <fakemeta>
+#include <engine>
+#include <hamsandwich>
+
+#include <cstrike>
+
+#include <xs>
+
+new const Plugin[] = "Shoot Grenades"
+new const Author[] = "joaquimandrade"
+new const Version[] = "1.1"
+
+enum Grenade
+{
+	Flashbang,
+	He,
+	Smoke,
+	C4
+}
+
+new Cvars[Grenade]
+
+new CvarsNames[Grenade][] =
+{
+	"flash",
+	"he",
+	"smoke",
+	"c4"
+}
+
+// Arkshine
+const m_flC4Blow = 100
+
+new Trie:RegisteredClasses
+
+public plugin_precache()
+{
+	RegisteredClasses = TrieCreate()
+	
+	register_forward(FM_Spawn,"spawn")
+}
+
+public spawn(id)
+{
+	if(pev_valid(id))
+	{
+		static classname[32]
+		pev(id,pev_classname,classname,charsmax(classname))
+		
+		if(!TrieKeyExists(RegisteredClasses,classname))
+		{
+			RegisterHam(Ham_TraceAttack,classname,"globalTraceAttack")
+			TrieSetCell(RegisteredClasses,classname,true)
+		}
+	}
+}
+
+public plugin_init()
+{
+	register_plugin(Plugin,Version,Author)
+	
+	RegisterHam(Ham_TraceAttack,"worldspawn","globalTraceAttack")
+	RegisterHam(Ham_TraceAttack,"player","globalTraceAttack")
+	
+	register_cvar("shootGrenades_version",Version,FCVAR_SERVER|FCVAR_SPONLY)
+}
+
+public plugin_cfg()
+{
+	new cvarName[15]
+	
+	for(new Grenade:i=Grenade:0;i<Grenade;i++)
+	{
+		formatex(cvarName,charsmax(cvarName),"shoot_%s",CvarsNames[i])
+		Cvars[i] = register_cvar(cvarName,"1")
+	}		
+}
+
+public globalTraceAttack(this,attackerID,Float:damage,Float:direction[3],tracehandle,damagebits)
+{
+	if(1 <= attackerID <= 32)
+	{
+		static Float:origin[3]
+		pev(attackerID,pev_origin,origin)
+		
+		static Float:viewOfs[3]
+		pev(attackerID,pev_view_ofs,viewOfs)
+		
+		xs_vec_add(origin,viewOfs,origin)
+		
+		static Float:end[3]
+		get_tr2(tracehandle,TR_vecEndPos,end)
+		
+		new trace = create_tr2()
+		
+		new grenade = -1
+		
+		while((grenade = find_ent_by_class(grenade,"grenade")))
+		{
+			engfunc(EngFunc_TraceModel,origin,end,HULL_POINT,grenade,trace)
+			
+			if(get_tr2(trace,TR_pHit) == grenade)
+			{
+				new Grenade:id = fm_cs_get_grenade_type_myid(grenade)
+				
+				if(id == C4)
+				{
+					new cvarValue = get_pcvar_num(Cvars[C4])
+						
+					if((cvarValue == 2) || (cvarValue && (cs_get_user_team(attackerID) == CS_TEAM_CT)))
+					{
+						set_pdata_float(grenade,m_flC4Blow,0.0)
+						dllfunc(DLLFunc_Think,grenade)
+					}
+				}
+				else
+				{
+					if(get_pcvar_num(Cvars[id]))
+					{
+						if(id == Smoke)
+							set_pev(grenade,pev_flags,pev(grenade,pev_flags) | FL_ONGROUND)
+						
+						// Connor
+						set_pev(grenade,pev_dmgtime,0.0)
+						dllfunc(DLLFunc_Think,grenade)
+					}
+				}
+			}
+		}
+		
+		free_tr2(trace)
+	}
+}
+
+// VEN
+Grenade:fm_cs_get_grenade_type_myid(index) 
+{
+	if(get_pdata_int(index, 96) & (1<<8))
+	{
+		return C4
+	}	
+	
+	return Grenade:(get_pdata_int(index, 114) & 3)
+}
+

Traceline Tutorial.txt

@@ -0,0 +1,247 @@
+Theory
+
+What is traceline, really? Traceline is a function in the Half-Life engine which is used to draw lines from one point to another in a 3D setting. It can return information, like who (or what) was hit, and various other useful bits of info.
+
+Traceline is used in every mod in order to determine where a player is looking and shooting. Therefore, it's quite useful to learn how to manipulate traceline to your liking.
+
+The mod you're scripting for (in my case, CS) is separate from the HL engine. Metamod (and, by extension, AMX Mod X) sits between the mod DLL and the HL engine. This gives us the ability to intercept anything the mod DLL sends to the engine, and visa versa. So, when CS asks the HL engine to calculate a traceline, we can completely change the outcome.
+
+The Code
+
+We will use forwards in Fakemeta in capture the communication between CS and the HL engine. This means we'll see the data CS was going to pass the engine in order to calculate a traceline.
+PHP Code:
+#include <amxmodx>
+#include <fakemeta>
+
+public plugin_init()
+{
+    register_plugin("Traceline Tutorial", "1.0", "Nomexous")
+    
+    register_forward(FM_TraceLine, "traceline_forward")
+}
+
+public traceline_forward(Float:start[3], Float:end[3], conditions, id, trace)
+{
+    // Our traceline forward.
+} 
+The meaning of the arguments forwarded to our function may not be entirely clear, so:
+
+Float:start[3] The origin from which the traceline starts.
+
+Float:end[3] The origin the traceline is drawn to.
+
+conditions Specifies whether or not to ignore certain entities when drawing the traceline. Values can be DONT_IGNORE_MONSTERS, IGNORE_GLASS, IGNORE_MISSLE, and IGNORE_MONSTERS.
+
+id This is the entity to ignore when drawing the traceline. Presumably, you're drawing from the origin of one entity (which is inside it) to another point. With player tracelines, id is the player index of whomever is firing the traceline.
+
+trace Our trace result. This is the most important part. It holds the information about what was hit, among other things. Use get_tr2 and set_tr2 with this.
+
+The Trace Result
+
+This is the most exciting part. The variable trace holds detailed information, which can be retreived as outlined:
+PHP Code:
+public traceline_forward(Float:start[3], Float:end[3], conditions, id, trace)
+{
+    // There are more TR_* constants than are listed here; these are the
+    // ones I use most.
+    
+    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."
+} 
+(Check this out if you don't know what we mean by "normal" in this context.)
+
+Now, changing these value is as easy as using the set_tr2 function.
+
+A Potentially Evil Plugin
+
+I'm sure you've all played on a server which allowed headshots only. Good practice; body shots do no damage, headshots kill instantly, yadda yadda. But what if we could redirect a shot on any part of the body to the head? Foot shot turns into a headshot? Amazing!
+PHP Code:
+public traceline_forward(Float:start[3], Float:end[3], conditions, id, trace)
+{
+    set_tr2(trace, TR_iHitgroup, HIT_HEAD)
+    return FMRES_IGNORED
+} 
+It's quite amusing, really. Try it. If you're used to seeing blood spurt out of head on a headshot, you'll be amazed at the blood spurting out of the foot on a foot/headshot. Shotguns are extra deadly; multiple pellets are all redirected to the head at the same time. Do some if (is_user_admin(id)), and you have yourself an evil plugin.
+
+But it gets kinda hard trying to hide the fact that the blood from a headshot came out of the foot, or stomach, or whatever part of the body you happened to hit. What you want is for blood to also be redirected to the head. Because this relies on traceline, we are still fully in control:
+PHP Code:
+public traceline_forward(Float:start[3], Float:end[3], conditions, id, trace)
+{
+    set_tr2(trace, TR_iHitgroup, HIT_HEAD) // Redirect shot to head
+    
+    // Variable angles doesn't really have a use here.
+    static hit, Float:head_origin[3], Float:angles[3]
+    
+    hit = get_tr2(trace, TR_pHit) // Whomever was shot
+    engfunc(EngFunc_GetBonePosition, hit, 8, head_origin, angles) // Find origin of head bone (8)
+    
+    set_tr2(trace, TR_vecEndPos, head_origin) // Blood now comes out of the head!
+    
+    return FMRES_IGNORED
+} 
+This is even more evil. Now you can run around your own server, endlessly headshotting, no unexplainable blood. Though now you might need to explain why you can't do anything other than headshot.
+
+You can of course change whom you are shooting. Consider this anti-team attack plugin for cs:
+PHP Code:
+#include <amxmodx>
+#include <fakemeta>
+#include <cstrike>
+
+public plugin_init()
+{
+    register_plugin("Traceline Tutorial - No TA", "1.0", "Nomexous")
+    
+    register_forward(FM_TraceLine, "traceline_forward")
+}
+
+public traceline_forward(Float:start[3], Float:end[3], conditions, id, trace)
+{
+    static hit
+    
+    hit = get_tr2(trace, TR_pHit)
+    
+    // Variable id is shooter's index.
+    if (cs_get_user_team(id) == cs_get_user_team(hit))
+    {
+        // Redirect onto himself!
+        set_tr2(trace, TR_pHit, id)
+    }
+    
+    return FMRES_IGNORED
+} 
+Blood will still spray out of whomever is being shot, but the damage will be dealt to the shooter. People quickly lose the urge to team attack.
+
+I've submitted a plugin (Shot Administration) that demonstrates the evil capabilities of manipulating traceline. Take a look; tracehull is also hooked (for knife damage).
+
+Less Evil Uses of Traceline
+
+We will now use tracelines to do our bidding outside the context of player aiming. Using engfunc(), we can call draw our own tracelines to see what we hit. Of course, we're not actually shooting and dealing damage, but with the information that the trace result gives us, it can be just as useful.
+
+Lets find out if two origins are in line of sight:
+PHP Code:
+stock bool:is_in_line_of_sight(Float:origin1[3], Float:origin[2], bool:ignore_players = true)
+{
+    new trace = 0
+    engfunc(EngFunc_TraceLine, origin1, origin2, (ignore_players ? IGNORE_MONSTERS : DONT_IGNORE_MONSTERS), 0, trace)
+    
+    new Float:fraction
+    get_tr2(trace, TR_flFraction, fraction)
+    
+    return (fraction == 1.0) ? true : false
+} 
+This stock sees how far it went before it hit something. If TR_flFraction is 1.0, that means it went 100% of the way without hitting an obstacle. Therefore, the two origins are in line of sight. Alternatively, you can see what TR_pHit returns. If it returns -1, you hit nothing (meaning the two points are in line of sight). A return of 0 means you hit part of the map (you can assume it's a wall), and anything else would be the index of an entity in the way. Be careful; it might not be a player. It could possibly be a door or a func_wall.
+
+Now, let's make use of the TR_vecPlaneNormal part of our trace result. There are multiple things this is useful for. Here, I'll outline how to draw a laser normal to a surface.
+
+When a trace hits something, TR_vecPlaneNormal will have a unit vector (1 unit in length) stored to it, pointing perpendicularly away from surface at the spot it hit. To get the endpoint of the laser, we merely need to extend the length of the normal vector and add it to the origin of where we want the laser to start from. Here is a sample:
+PHP Code:
+#include <amxmodx>
+#include <fakemeta>
+
+#define PLUGIN "Draw Normal Laser Example"
+#define VERSION "1.0"
+#define AUTHOR "Nomexous"
+
+new beampoint
+
+public plugin_precache()
+{
+    // Needed to show the laser.
+    beampoint = precache_model("sprites/laserbeam.spr")
+}
+
+public plugin_init()
+{
+    register_plugin(PLUGIN, VERSION, AUTHOR)
+    
+    // I included the entire plugin because in order to draw the laser, you need to precache a sprite. Incorporate
+    // these elements into your own plugin.
+    
+    // The shoot_laser() will (if the entity is on the floor) fire a laser from the entity, normal to the surface it's resting on.
+}
+
+public shoot_laser(ent)
+{
+    // We get the origin of the entity.
+    new Float:origin[3]
+    pev(ent, pev_origin, origin)
+    
+    // We want to trace down to the floor, if it's there.
+    new Float:traceto[3]
+    traceto[0] = origin[0]
+    traceto[1] = origin[1]
+    traceto[2] = origin[2] - 10.0
+    
+    new trace = 0
+    // Draw the traceline. We're assuming the object is resting on the floor.
+    engfunc(EngFunc_TraceLine, origin, traceto, IGNORE_MONSTERS, ent, trace)
+    
+    new Float:fraction
+    get_tr2(trace, TR_flFraction, fraction)
+    // If we didn't hit anything, then we won't get a valid TR_vecPlaneNormal.
+    if (fraction == 1.0) return
+    
+    new Float:normal[3]
+    get_tr2(trace, TR_vecPlaneNormal, normal)
+    // We'll multiply the the normal vector by a scalar to make it longer.
+    normal[0] *= 400.0 // Mathematically, we multiplied the length of the vector by 400*(3)^(1/2),
+    normal[1] *= 400.0 // or, in words, four hundred times root three.
+    normal[2] *= 400.0
+    
+    // To get the endpoint, we add the normal vector and the origin.
+    new Float:endpoint[3]
+    endpoint[0] = origin[0] + normal[0]
+    endpoint[1] = origin[1] + normal[1]
+    endpoint[2] = origin[2] + normal[2]
+    
+    // Finally, we draw from the laser!
+    draw_laser(origin, endpoint, 100) // Make it stay for 10 seconds. Not a typo; staytime is in 10ths of a second.
+}
+
+public draw_laser(Float:start[3], Float:end[3], staytime)
+{                    
+    message_begin(MSG_ALL, SVC_TEMPENTITY)
+    write_byte(TE_BEAMPOINTS)
+    engfunc(EngFunc_WriteCoord, start[0])
+    engfunc(EngFunc_WriteCoord, start[1])
+    engfunc(EngFunc_WriteCoord, start[2])
+    engfunc(EngFunc_WriteCoord, end[0])
+    engfunc(EngFunc_WriteCoord, end[1])
+    engfunc(EngFunc_WriteCoord, end[2])
+    write_short(beampoint)
+    write_byte(0)
+    write_byte(0)
+    write_byte(staytime) // In tenths of a second.
+    write_byte(10)
+    write_byte(1)
+    write_byte(255) // Red
+    write_byte(0) // Green
+    write_byte(0) // Blue
+    write_byte(127)
+    write_byte(1)
+    message_end()
+}