Entity References (SourceMod)

2009-07-24T00:06:18Z

PRED*:

Entity References (SourceMod)

2009-07-24T00:04:05Z

PRED*: Created page with 'An entity reference is a combination of a standard entity index (used for all entities in SourceMod previously) and a pseudo-unique serial number that identifies the entity. Sinc...'

An entity reference is a combination of a standard entity index (used for all entities in SourceMod previously) and a pseudo-unique serial number that identifies the entity. Since entities are constantly being created and destroyed a cached index doesn't guarantee the underlying entity is the same, references provide a way of verifying the same entity still exists. Generally speaking, if you have an entity index you wish to cache you should convert it to a reference first. All natives (provided by SourceMod) should be able to accept references in place of indexes (wherever the parameter asks for an entity - Not clients), and these will check use the serial to check that the entity index contained in the reference is the same as when the reference was created.

SourceMod now also supports handling of logical (non-networked entities) and these use references exclusively. Natives that used to return an entity index will continue to do so in the case of networked entities (for backwards compatability) and will only return a reference for non-networked ones.

==Converting a backwards-compat index/ref to a guaranteed reference for safely caching==

<pawn>
new index = GetEntPropEnt(client, Prop_Send, "m_hActiveWeapon");

/* Convert our backwards-compat index/ref to a guaranteed reference */
new ref = EntIndexToEntRef(index);
</pawn>
==Using References to handle a logic entity==

<pawn>
new ent = -1;

while ((ent = FindEntityByClassname(ent, "logic_auto")) != INVALID_ENT_REFERENCE)
{
/**
* Get the entity index from this reference - This works on references and indexes for convenience.
* Should be a number >2048 since logic_auto is a non networked entity
*/
new index = EntRefToEntIndex(ent);

/* Fire an input on this entity - We use the reference version since this includes a serial check */
AcceptEntityInput(ent, "Kill");

}
</pawn>

Category:Game Resources

2009-05-22T04:46:46Z

PRED*: /* Team Fortress 2 */

In this category you can find resources for specific mods.

==Left 4 Dead==
[[Left_4_Dead_Events|Events]] 
[[Left_4_Voting|Voting]]

==Team Fortress 2==
[[Team_Fortress_2_Events|Events]] 
[http://alliedmods.net/~pred/tf2classes.txt Classnames] 
[http://alliedmods.net/~pred/ctfplayer-vtable-220509.txt CTFPlayer Virtual Functions] - Updated 22/05/09 
[http://alliedmods.net/~pred/tf-net-220509.txt Entity Properties] - Updated 22/05/09 
[http://alliedmods.net/~pred/tf-data-220509.txt DataMap Properties] - Updated 22/05/09 
[[Mod_TempEnt_List_(Source)#Team_Fortress_2|Temp Ents]] 
 
[http://alliedmods.net/~pred/CTFKnife%20vtable.txt CTFKnife Virtual Functions] 
[http://alliedmods.net/~pred/CTFWeaponBase%20Vtable.txt CTFWeaponBase Virtual Functions] 
[http://wiki.alliedmods.net/Achievement_IDs Achievement ID Numbers] 
[[Team_Fortress_2_Weapons|Team Fortress 2 Weapon Entity Names]] 

==Counter-Strike: Source==
[[Counter-Strike:_Source_Events|Events]] 
[http://alliedmods.net/~pred/csclasses.txt Classnames] 
[[CCSPlayer_offset_list_(SourceMM)|CCSPlayer Virtual Functions]] 
[[CBaseCombatWeapon_CSS_offset_list_(SourceMM)|CBaseCombatWeapon Virtual Functions]] 
[http://alliedmods.net/~pred/csdump.txt Entity Properties] 
[http://alliedmods.net/~pred/csdatamaps.txt DataMap Properties] 
[[Mod_TempEnt_List_(Source)#Counter-Strike:_Source|Temp Ents]] 
[[Counter-Strike:_Source_Weapons| Counter-Strike: Source Weapons]] 
[http://wiki.alliedmods.net/images/Counter-Strike_Source_-_Cvar_List.txt Cvar List]

Category:Game Resources

2009-05-22T03:22:51Z

PRED*: /* Team Fortress 2 */

In this category you can find resources for specific mods.

==Left 4 Dead==
[[Left_4_Dead_Events|Events]] 
[[Left_4_Voting|Voting]]

==Team Fortress 2==
[[Team_Fortress_2_Events|Events]] 
[http://alliedmods.net/~pred/tf2classes.txt Classnames] 
[http://alliedmods.net/~pred/ctfplayer-vtable-20070522.txt CTFPlayer Virtual Functions] - Updated 22/05/08 
[http://alliedmods.net/~pred/tf-net-220509.txt Entity Properties] - Updated 22/05/09 
[http://alliedmods.net/~pred/tf-data-220509.txt DataMap Properties] - Updated 22/05/09 
[[Mod_TempEnt_List_(Source)#Team_Fortress_2|Temp Ents]] 
 
[http://alliedmods.net/~pred/CTFKnife%20vtable.txt CTFKnife Virtual Functions] 
[http://alliedmods.net/~pred/CTFWeaponBase%20Vtable.txt CTFWeaponBase Virtual Functions] 
[http://wiki.alliedmods.net/Achievement_IDs Achievement ID Numbers] 
[[Team_Fortress_2_Weapons|Team Fortress 2 Weapon Entity Names]] 

==Counter-Strike: Source==
[[Counter-Strike:_Source_Events|Events]] 
[http://alliedmods.net/~pred/csclasses.txt Classnames] 
[[CCSPlayer_offset_list_(SourceMM)|CCSPlayer Virtual Functions]] 
[[CBaseCombatWeapon_CSS_offset_list_(SourceMM)|CBaseCombatWeapon Virtual Functions]] 
[http://alliedmods.net/~pred/csdump.txt Entity Properties] 
[http://alliedmods.net/~pred/csdatamaps.txt DataMap Properties] 
[[Mod_TempEnt_List_(Source)#Counter-Strike:_Source|Temp Ents]] 
[[Counter-Strike:_Source_Weapons| Counter-Strike: Source Weapons]] 
[http://wiki.alliedmods.net/images/Counter-Strike_Source_-_Cvar_List.txt Cvar List]

SourceMod Release Notes

2009-02-26T22:42:47Z

PRED*:

[[SourceMod]] Release notes for each release:

*[[SourceMod 1.1.2 Release Notes]]
*[[SourceMod 1.1.1 Release Notes]]
*[[SourceMod 1.1.0 Release Notes]]
*[[SourceMod 1.0.4 Release Notes]]
*[[SourceMod 1.0.3 Release Notes]]
*[[SourceMod 1.0.2 Release Notes]]
*[[SourceMod 1.0.1 Release Notes]]
*[[SourceMod 1.0 Release Notes]]

SourceMod 1.1.2 Release Notes

2009-02-26T22:42:31Z

PRED*: New page: __FORCETOC__ SourceMod 1.1.2 is a minor bug-fix update, intended mainly for parity with the latest Team Fortress update. If you need help upgrading, see Upgrading SourceMod. *'''This...

__FORCETOC__
SourceMod 1.1.2 is a minor bug-fix update, intended mainly for parity with the latest Team Fortress update. If you need help upgrading, see [[Upgrading SourceMod]].

*'''This release DOES NOT have configuration changes.'''
*'''This release DOES NOT break compatibility.'''
 
=Compatibility=
This release is fully backwards compatible. It is not, however, forwards compatible. Plugins compiled against SourceMod 1.1 will not run on any earlier version. If you encounter any compatibility problems, file a bug.

=Translations=
SourceMod 1.1.2 ships with a number of community provided translation packs. The following languages are included:
*Brazilian Portuguese
*Chinese Simplified
*Danish
*German
*Hungarian
*Japanese
*Latvian
*Norwegian
*Polish
*Romanian
*Russian
*Spanish
*Swedish
*Turkish

=Changelog=
*Fixed critical hits being disabled by default ({{bz|3674}})
*Critical hit hooks are now disabled until used

SourceMod 1.2.0 Release Notes

2009-02-19T07:08:20Z

PRED*: /* Changelog */

__FORCETOC__
SourceMod 1.2 is a major update. It is fully backwards compatible. Old plugins and extensions will continue to work.

=TODO List=
*<strike>[http://tinyurl.com/cgxk4w blocking-1.1.1+] HIGHEST PRIORITY</strike>
*[http://tinyurl.com/6c6qqb blocking-1.2+] HIGH PRIORITY
*[http://tinyurl.com/9xo7y7 wanted-1.2+] LOW PRIORITY

=Changelog=
*Added Left 4 Dead support ({{bz|3414}}).
*Added Age of Chivalry support ({{bz|3366}}, IceMatrix).
*Added Obsidian Conflict support ({{bz|2699}}, The DOO).
*Added sm_name command ({{bz|2150}}).
*Added extension-level dynamic hooking to bintools ({{bz|2616}}).
*Added cURL extension, available to other extensions ({{bz|3560}}).
*Split gamedata files into smaller, inheritable files ({{bz|3546}}).
*Fixed crash when an event handler fired an event of the same name ({{bz|3468}}).
*Fixed formatting error with zero precision floats ({{bz|3447}}).
*Fixed various Insurgency offsets ({{bz|3544}}).
*Fixed admin menu (topmenu) categories being selectable when not usable ({{bz|3256}}).
*Fixed sm_sql_addgroup not working ({{bz|3578}}).
*Fixed blank admins being created from invalid admin file lines ({{bz|3431}}).
*Fixed memory leak when events were hooked as EventHookMode_Post.
*Fixed nextmap trigger showing wrong output with end-of-map voting disabled and sm_trigger_show set to zero ({{bz|3597}}, mr.e.unk).
*Fixed basetriggers not working on Insurgency ({{bz|3497}}).
*Exposed IServer address to extensions ({{bz|3545}}).
*Improved database fallback mechanism in clientprefs ({{bz|3564}}).
*Improved timer handling in funcommands ({{bz|3498}}).
*Improved compile.sh to take filenames ({{bz|3550}}, jonasfietz).
*sm_kick now shows the kick reason when available.
*Split sound functions into a new plugin, sounds.smx.
*Added parsing of custom gamedata files ({{bz|3644}}).
*Fixed MsgSentNotify callbacks not firing on intercept hook ({{bz|3631}}).
*Added client validation API ({{bz|3616}}).
*Clientprefs now uses the client validation API to avoid using valves broken userid system ({{bz|3616}}).

SourceMod 1.2.0 Release Notes

2009-02-19T07:04:59Z

PRED*: /* Changelog */

Zombie Panic! Source Events

2008-12-02T22:19:25Z

PRED*: Zombie Panic! Source events temp moved to Zombie Panic! Source Events

=== player_death ===
{{qnotice|When a client dies}} 
{{begin-hl2msg|player_death|string}}
{{hl2msg|short|userid}}
{{hl2msg|short|attacker}}
{{hl2msg|string|weapon}}
{{end-hl2msg}}

=== zombie_death ===
{{qnotice|When a zombie dies}} 
{{begin-hl2msg|zombie_death|string}}
{{hl2msg|byte|count}}
{{end-hl2msg}}

=== ambient_play ===
{{qnotice|None}} 
{{begin-hl2msg|ambient_play|string}}
{{hl2msg|string|sound}}
{{hl2msg|bool|fade}}
{{end-hl2msg}}

=== game_round_restart ===
{{qnotice|None}} 
{{begin-hl2msg|game_round_restart|string}}
{{hl2msg|none|none}}
{{end-hl2msg}}

=== gravity_change ===
{{qnotice|When the gravity changes}} 
{{begin-hl2msg|gravity_change|string}}
{{hl2msg|float|newgravity}}
{{end-hl2msg}}

=== achievement_earned ===
{{qnotice|None}} 
{{begin-hl2msg|achievement_earned|string}}
{{hl2msg|byte|player}}
{{hl2msg|short|achievement}}
{{end-hl2msg}}

=== spec_target_updated ===
{{qnotice|None}} 
{{begin-hl2msg|spec_target_updated|string}}
{{hl2msg|none|none}}
{{end-hl2msg}}

Zombie Panic! Source events temp

2008-12-02T22:19:25Z

PRED*: Zombie Panic! Source events temp moved to Zombie Panic! Source Events

#REDIRECT [[Zombie Panic! Source Events]]

2008-06-29T06:09:22Z

PRED*:

GameData Query

2008-06-29T06:09:08Z

PRED*:

====Request format====
GameData updates can be requested by sending the following byte values in a TCP packet to the server.

{| class="wikitable" style="margin: 1em auto 1em auto"
! Data || Type || Comment
|-
| Header || byte || Should be equal to 'A'
|-
| Type || byte || Should be equal to 'G'
|-
| Version || short || Current SourceMod version number (1)
|-
| Major || short || Current Major release version
|-
| Minor || short || Current Minor release version
|-
| Build || short || Current build number
|-
| Count || byte || Number of MD5 Checksums
|}

GameData Query

2008-06-29T06:06:15Z

PRED*: /* Request format */

====Request format====
GameData updates can be requested by sending the following byte values in a TCP packet to the server.

{|
! Data || Type || Comment
|-
| Header || byte || Should be equal to 'A'
|-
| Type || byte || Should be equal to 'G'
|-
| Version || short || Current SourceMod version number (1)
|-
| Major || short || Current Major release version
|-
| Minor || short || Current Minor release version
|-
| Build || short || Current build number
|-
| Count || byte || Number of MD5 Checksums
|}

GameData Query

2008-06-29T06:04:23Z

PRED*: /* Request format */

====Request format====
GameData updates can be requested by sending the following byte values in a TCP packet to the server.

{|
! Data || Type || Comment
|-
| Header || [[byte]] || Should be equal to 'A'
|-
| Type || [[byte]] || Should be equal to 'G'
|-
| Version || [[short]] || Current SourceMod version number (1)
|-
| Major || [[short]] || Current Major release version
|-
| Minor || [[short]] || Current Minor release version
|-
| Build || [[short]] || Current build number
|-
| Count || [[byte]] || Number of MD5 Checksums
|}

2008-04-14T03:20:18Z

PRED*: /* Managed Forwards */

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.

==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\sourcemm
**sourcemm\sourcehook
**sourcemm
*HL2SDK:
**game_shared
**public\vstdlib
**public\tier1
**public\tier0
**public\engine
**public\dlls
**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).

*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> and <tt>_CRT_NONSTDC_NO_DEPRECATE</tt> and <tt>SOURCEMOD_BUILD</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]]