AlliedModders Wiki - User contributions [en]

Reserved Slots (SourceMod)

2023-06-14T21:28:24Z

Impact123: Fix wrong config path

{{Languages|Reserved Slots (SourceMod)}}
==Cvars==

*[[#Reserve Type|sm_reserve_type <0|1|2>]]
*[[#Reserved Slots|sm_reserved_slots <#>]]
*[[#Hidden Slots|sm_hide_slots <0|1>]]
*[[#Max Admins|sm_reserve_maxadmins <#>]]
*[[#Kick Type|sm_reserve_kicktype <0|1|2>]]

You can edit these in the <code>cfg/sourcemod.cfg</code> file.

==Reserve Type==

sm_reserve_type <0|1|2>

This controls how reserve slots work on the server (the default is 0).

* <tt>sm_reserve_type 0</tt>

Public slots are used in preference to reserved slots. Reserved slots are freed before public slots.
No players are ever kicked and once reserved slots are filled by a reserve slot player (and the rest of the server is full) they will remain occupied until a player leaves.
The use of this is that there can always be at least one admin (assuming you only give reserved slots to admins) on the server at any time. If players inform you that there is a cheater on the server, at least one admin should be able to get it and do something about it.
If a player without reserve slot access joins when there are only reserved spaces remaining they will be kicked from the server.

* <tt>sm_reserve_type 1</tt>

If someone with reserve access joins into a reserved slot, the player with the highest latency and without reserve access (spectator players are selected first) is kicked to make room. Thus, the reserved slots always remain free. The only situation where the reserved slot(s) can become properly occupied is if the server is full with reserve slot access clients.
This is for servers that want some people to have playing preference over other. With this method admins could one by one join a full server until they all get in.

* <tt>sm_reserve_type 2</tt> - Only available in SourceMod 1.1 or higher.

The same as sm_reserve_type 1 except once a certain number of admins have been reached the reserve slot stops kicking people and anyone can join to fill the server.
You can use this to simulate having a large number of reserved slots with sm_reserve_type 0 but with only need to have 1 slot unavailable when there are less admins connected.

==Reserved Slots==

sm_reserved_slots <#>

This controls how many slots get reserved by the plugin (the default is 0).

Using sm_reserve_type 0 this is how many admins can join the server after it appears full to the public.
Using sm_reserve_type 1 this is how many slots are saved for swapping admins in (you shouldn't need more than one)

==Hidden Slots==

sm_hide_slots <0|1>

This controls the plugin hides the reserved slots (the default is 0).

If enabled (1) reserve slots are hidden in the server browser window when they are not in use. For example a 24 player server with 2 reserved slots will show as a 22 player server (until the reserved slots are occupied). If you experience that the slots are not hidden, despite setting sm_hide_slots to 1, then adding host_info_show 2 to your server.cfg may solve this problem.
To connect to the reserved slot of a server that shows as full you will need to use 'connect ip:port' in console. (e.g. 'connect 192.168.1.100:27015').

There is no possible way for the reserved slots to be visible to admins and hidden from normal users. Admin authentication can only happen after the user is fully connected to the server and their steam id is available to SourceMod. For this reason it is often better to hide the slots otherwise public users will attempt to join the server and will get kicked again (rendering the ‘autojoin’ feature useless)

==Max Admins==

sm_reserve_maxadmins <#> - Only available in SourceMod 1.1 or higher.

This controls how many admins can join the server before the reserved slots are made public (only relevant to sm_reserve_type 2)

==Kick Type==

sm_reserve_kicktype <0|1|2> - Only available in SourceMod 1.1 or higher.

This controls how a client is selected to be kicked (only relevant to sm_reserve_type 1/2)

Clients with reserve slot access or the override 'sm_reskick_immunity' are always immune to being kicked. Spectating clients are chosen before playing clients.

0 - Highest Ping 
1 - Highest Connection Time 
2 - Random Player 

==Immunity==

To make players immune from being kicked by the reserved slots plugin they need to have access to the override 'sm_reskick_immunity' (users with root or reserved slot access are already immune).

NB: This is only relevant when using sm_reserve_type 1/2.

You can either assign this override to a flag using admin_overrides.cfg (e.g. "sm_reskick_immunity" "o" - to give all users with flag 'o' (custom flag 1) immunity from being kicked)

Or

Give groups access to the overrides in admin_groups.cfg (e.g. "sm_reskick_immunity" "allow")

Then add your VIP members or other users you wish to be immune from being kicked as admins with either the flag you specified or as members of the group you gave access to. (You can create a group with 0 flags and ‘0’ normal immunity and only this override if you don't want them to have any other privileges)

Full details on overriding command access can be found at [[Overriding Command Access (SourceMod)]]

==Possible Future Additions==

These are possible feature additions that have been requested and are under consideration for inclusion in later versions of SourceMod

*Choice to redirect players instead of kicking.

[[Category:SourceMod Documentation|Categories]]

Installing Metamod:Source

2023-01-14T07:59:35Z

Impact123: Change tt to code and rlaborate where metamod-fatal.log can be found

This article will guide you through a [[Metamod:Source]] installation.

=Normal Installation=

Valve sometimes makes changes in their games that break Metamod:Source between releases. When this happens, you may need to install a snapshot versions of Metamod:Source. You can see if this is required on the [[Required Versions (SourceMod)|Required Versions]] page.

<ol>
<li>[http://www.metamodsource.net/ Download] Metamod:Source.</li>
<li>Extract the package to your game folder. For example, for Counter-Strike:Source, you would have <code>cstrike/addons/metamod</code> after extracting. If you are uploading to FTP, extract the files locally before transferring to your server's game folder.</li>
<li>Restart your server.</li>
<li>Type "meta version" in your server console (or RCON). You should see a line like: "Loaded As: Valve Server Plugin." If the command is not recognized, see the sections below.</li>
</ol>

When using a Linux server, you may see the following messages:

* An error indicating that it could not be loaded due to "wrong ELF class: ELFCLASS64". If you are using a 32-bit dedicated server installation, this is normal behavior; as long as <code>meta version</code> is recognized, Metamod:Source is installed.
* An error indicating that it could not be loaded because "/path/to/server_install/bin/libgcc_s.so.1: version `GCC_7.0.0` not found (required by /some_system_path_to/libstdc++.so.6". This is because Valve ships their own copies of those libraries. As modern systems will have newer versions, you can safely delete the listed file from the server install. Do not delete the file in the system path (usually <code>lib</code> or <code>lib32</code>).
* If you are running a 64-bit operating system yourself, you may need to install the system's 32-bit libraries.
** On Debian / Ubuntu, you can do this with <code>apt install gcc-multilib</code>.
* You may find more information about any load failures under a <code>metamod-fatal.log</code> in metamod's <code>bin</code> folder.

==Custom VDF File==
'''Note: This is normally not needed - Metamod:Source 1.10.0 and later include a <code>metamod.vdf</code> file for easier installation on most games.'''

If you have trouble getting it to load, [http://www.metamodsource.net/?go=vdf go here] to generate a VDF file specific to your game. This file should be placed into your server's <code>addons</code> directory.

Known setups that require this step:
<ol>
<li>Left 4 Dead 1</li>
<li>3rd party mods using the Source SDK Base.</li>
<li>Listen servers (created with the in-game "Create Server" option) for non-english game clients.</li>
</ol>

=GameInfo=
'''Note: This is normally not needed - if you do not understand what this is, do NOT do this unless instructed to. The above instructions are sufficient to install Metamod:Source for 99% of servers.'''

Metamod:Source 1.4.2 and lower used an older method for loading itself. The advantage of this method was that Metamod:Source could be loaded before the actual game mod, which gave it a small amount of extra functionality. This functionality was never used by plugin developers, and Steam updates kept overwriting <code>gameinfo.txt</code> files, so we switched to a different loading mechanism.

However this loading mechanism may still be desirable if you run into backwards compatibility issues, or you have a plugin which takes advantage of the early-loading mechanism. If this is your case, here are the <code>gameinfo.txt</code> directions below:

<ul>
<li>Open the file in the mod folder called "gameinfo.txt". You will see a few lines at the bottom like this:
<pre>
SearchPaths
{
Game |gameinfo_path|.
Game cstrike
Game hl2
}
</pre></li>
<li>Add a line after the "{" sign but before all of the "Game" entries that looks like this:<pre>GameBin |gameinfo_path|addons/metamod/bin
</pre>
</li>
<li>If you're using Windows, you may need to use a backwards slash (\) instead.
<li>You're done! To test whether it worked, restart your game server and type "meta version" in the server console. You should see a line that says "Loaded as: GameDLL (gameinfo.txt)." If it doesn't recognize the command, the installation probably failed. If the "Loaded as:" line says something else, <code>gameinfo.txt</code> was probably not modified correctly.</li>
<li>For more information or documentation, see [[:Category:Metamod:Source Documentation]]</li>
</ul>

The <code>gameinfo.txt</code> loading method is supported as a legacy feature only. The patcher tool is no longer provided. You can mark <code>gameinfo.txt</code> if you absolutely want to protect it from being overwritten.

We will continue to make sure Metamod:Source can load via this method for as long as the Source Engine allows it. However, we will concentrate more on supporting the new loading mechanism for general use.

[[Category:Metamod:Source Documentation]]

Reserved Slots (SourceMod)

2022-05-13T21:26:45Z

Impact123: Add note about where to change the ConVars

{{Languages|Reserved Slots (SourceMod)}}
==Cvars==

*[[#Reserve Type|sm_reserve_type <0|1|2>]]
*[[#Reserved Slots|sm_reserved_slots <#>]]
*[[#Hidden Slots|sm_hide_slots <0|1>]]
*[[#Max Admins|sm_reserve_maxadmins <#>]]
*[[#Kick Type|sm_reserve_kicktype <0|1|2>]]

You can edit these in the <code>configs/cfg/sourcemod.cfg</code> file.

==Reserve Type==

sm_reserve_type <0|1|2>

This controls how reserve slots work on the server (the default is 0).

* <tt>sm_reserve_type 0</tt>

Public slots are used in preference to reserved slots. Reserved slots are freed before public slots.
No players are ever kicked and once reserved slots are filled by a reserve slot player (and the rest of the server is full) they will remain occupied until a player leaves.
The use of this is that there can always be at least one admin (assuming you only give reserved slots to admins) on the server at any time. If players inform you that there is a cheater on the server, at least one admin should be able to get it and do something about it.
If a player without reserve slot access joins when there are only reserved spaces remaining they will be kicked from the server.

* <tt>sm_reserve_type 1</tt>

If someone with reserve access joins into a reserved slot, the player with the highest latency and without reserve access (spectator players are selected first) is kicked to make room. Thus, the reserved slots always remain free. The only situation where the reserved slot(s) can become properly occupied is if the server is full with reserve slot access clients.
This is for servers that want some people to have playing preference over other. With this method admins could one by one join a full server until they all get in.

* <tt>sm_reserve_type 2</tt> - Only available in SourceMod 1.1 or higher.

The same as sm_reserve_type 1 except once a certain number of admins have been reached the reserve slot stops kicking people and anyone can join to fill the server.
You can use this to simulate having a large number of reserved slots with sm_reserve_type 0 but with only need to have 1 slot unavailable when there are less admins connected.

==Reserved Slots==

sm_reserved_slots <#>

This controls how many slots get reserved by the plugin (the default is 0).

Using sm_reserve_type 0 this is how many admins can join the server after it appears full to the public.
Using sm_reserve_type 1 this is how many slots are saved for swapping admins in (you shouldn't need more than one)

==Hidden Slots==

sm_hide_slots <0|1>

This controls the plugin hides the reserved slots (the default is 0).

If enabled (1) reserve slots are hidden in the server browser window when they are not in use. For example a 24 player server with 2 reserved slots will show as a 22 player server (until the reserved slots are occupied).
To connect to the reserved slot of a server that shows as full you will need to use 'connect ip:port' in console. (e.g. 'connect 192.168.1.100:27015')

There is no possible way for the reserved slots to be visible to admins and hidden from normal users. Admin authentication can only happen after the user is fully connected to the server and their steam id is available to SourceMod. For this reason it is often better to hide the slots otherwise public users will attempt to join the server and will get kicked again (rendering the ‘autojoin’ feature useless)

==Max Admins==

sm_reserve_maxadmins <#> - Only available in SourceMod 1.1 or higher.

This controls how many admins can join the server before the reserved slots are made public (only relevant to sm_reserve_type 2)

==Kick Type==

sm_reserve_kicktype <0|1|2> - Only available in SourceMod 1.1 or higher.

This controls how a client is selected to be kicked (only relevant to sm_reserve_type 1/2)

Clients with reserve slot access or the override 'sm_reskick_immunity' are always immune to being kicked. Spectating clients are chosen before playing clients.

0 - Highest Ping 
1 - Highest Connection Time 
2 - Random Player 

==Immunity==

To make players immune from being kicked by the reserved slots plugin they need to have access to the override 'sm_reskick_immunity' (users with root or reserved slot access are already immune).

NB: This is only relevant when using sm_reserve_type 1/2.

You can either assign this override to a flag using admin_overrides.cfg (e.g. "sm_reskick_immunity" "o" - to give all users with flag 'o' (custom flag 1) immunity from being kicked)

Or

Give groups access to the overrides in admin_groups.cfg (e.g. "sm_reskick_immunity" "allow")

Then add your VIP members or other users you wish to be immune from being kicked as admins with either the flag you specified or as members of the group you gave access to. (You can create a group with 0 flags and ‘0’ normal immunity and only this override if you don't want them to have any other privileges)

Full details on overriding command access can be found at [[Overriding Command Access (SourceMod)]]

==Possible Future Additions==

These are possible feature additions that have been requested and are under consideration for inclusion in later versions of SourceMod

*Choice to redirect players instead of kicking.

[[Category:SourceMod Documentation|Categories]]

Introduction to SourcePawn 1.7

2021-08-15T15:54:37Z

Impact123: Add example for {x, ...} Syntax

This guide is designed to give you a very basic overview to fundamentals of scripting in SourcePawn. [[Pawn]] is a "scripting" language used to embed functionality in other programs. That means it is not a standalone language, like C++ or Java, and its details will differ based on the application. SourcePawn is the version of Pawn used in [[SourceMod]].

This guide does not tell you how to write SourceMod plugins; it is intended as an overview of the syntax and semantics of the language instead. Read the separate article, [[Introduction to SourceMod Plugins]] for SourceMod API specifics.

=Non-Programmer Intro=
This section is intended for non-programmers. If you're still confused, you may want to pick up a book on another language, such as PHP, Python, or Java, to get a better idea of what programming is like.

==Symbols/Keywords==
A symbol is a series of letters, numbers, and/or underscores, that uniquely represents something. Symbols are case-sensitive, and usually start with a letter.

There are a few reserved symbols that have special meaning. For example, <tt>if</tt>, <tt>for</tt>, and <tt>return</tt> are special constructs in the language that will explained later. They cannot be used as symbol names.

==Variables==
There a few important constructs you should know before you begin to script. The first is a '''variable'''. A variable is a symbol, or name, that holds data. For example, the variable "a" could hold the number "2", "16", "0", et cetera. Since a variable holds data, it also allocates the memory needed to store that data.

In addition to a name, variables have a '''type'''. A type tells the program how to interpret the data, and how much memory the data will use. Pawn has four types of data that are most commonly used:
* Integers, using the <tt>int</tt> type. Integer types may store a whole number from -2147483648 to 2147483647.
* Floats, using the <tt>float</tt> type. Float types may store fractional numbers in a huge range, though they are not as precise as integers.
* Characters, using the <tt>char</tt> type. Character types store one byte of character information, typically an [http://www.asciitable.com/ ASCII] character.
* Booleans, using the <tt>bool</tt> type. Booleans store either true or false.

Example of creating variables and assigning values:

<sourcepawn>int money = 5400;
float percent = 67.3;
char key = 'A';
bool enabled = false;
</sourcepawn>

==Functions==
The next important concept is '''functions'''. Functions are symbols or names that perform an action. When you invoke, or call them, they carry out a specific sequence of code and then return a result. There are a few types of functions, but every function is activated the same way. Example:

<sourcepawn>
show(56); // Calls the "show" function, and gives it the number 56.
enable(); // Calls the "enable" function with no values.
bool visible = show(a); //Calls the "show" function, stores its result in a variable.
</sourcepawn>

Every piece of data passed to a function is called a '''parameter'''. A function can have any number of parameters (there is a "reasonable" limit of 32 in SourceMod). Parameters will be explained further in the article.

==Comments==
Note any text that appears after a "//" is considered a "comment" and is not actual code. There are two comment styles:
*<tt>//</tt> - Double slash, everything following on that line is ignored.
*<tt>/* */</tt> - Multi-line comment, everything in between the asterisks is ignored. You cannot nest these.

==Block Coding==
The next concept is block coding. You can group code into "blocks" separated by { and }. This effectively makes one large block of code act as one statement. For example:

<sourcepawn>{
here;
is;
some;
code;
}</sourcepawn>

Block coding using braces is used everywhere in programming. Blocks of code can be nested within each other. It is a good idea to adapt a consistent and readable indentation style early on to prevent spaghetti-looking code.

=Language Paradigms=
Pawn may seem similar to other languages, like C, but it has fundamental differences. It is not important that you immediately understand these differences, but they may be helpful if you're familiar with another language already.
*'''Pawn is sort of typed.''' Before SourceMod 1.7, Pawn did not have types. Older code and older natives will reflect this by using tags and the <tt>new</tt> keyword. As of SourceMod 1.7, we recommend that all code use types. For more information see [[SourcePawn Transitional Syntax]].
*'''Pawn is not garbage collected.''' Pawn, as a language, has no built-in memory allocation, and thus has no garbage. If a function allocates memory, you may be responsible for freeing it.
*'''Pawn is not object oriented.''' Pawn does not have structs or objects. As of SourceMod 1.7, it has limited sugaring for treating some data types as objects, but users cannot create their own objects or classes.
*'''Pawn is single-threaded.''' As of this writing, Pawn is not thread safe.
*'''Pawn is compiled.''' Pawn is compiled to an intermediate, machine-independent code, which is stored in a ".smx" file. When loading .smx files, SourceMod translates this code to machine code for the platform and CPU it's running on.

Early language design decisions were made by ITB CompuPhase. It is designed for low-level embedded devices and is thus very small and very fast.

=Variables=
Pawn currently supports the following basic variable types:
*<tt>bool</tt> - true or false.
*<tt>char</tt> - an 8-bit ASCII character.
*<tt>int</tt> - a 32-bit signed integer.
*<tt>float</tt> - a 32-bit IEEE-754 floating point number.
*<tt>Handle</tt> - the base type of a SourceMod object

Other types may exist when defined in include files - for example, enums create new types for named integers, and many types derive from <tt>Handle</tt>.

Strings, currently, are 0-terminated arrays of <tt>char</tt>s. They're described a little further ahead.

==Declaration==
Below we include some examples of variable declarations, both valid and invalid. Keep in mind that SourcePawn has recently added new syntax, and that's what's documented below. Older code may use older declaration syntax, which is no longer supported.

<sourcepawn>
int a = 5;
float b = 5.0;
bool c = true;
bool d = false;
</sourcepawn>

Invalid variable usage:
<sourcepawn>
int a = 5.0; // Type mismatch. 5.0 is a float.
float b = 5; // Type mismatch. 5 is an integer.
</sourcepawn>

If a variable is not assigned upon declaration, it will be set to 0. For example:
<sourcepawn>
int a; // Set to 0
float b; // Set to 0.0
bool c; // Set to false
</sourcepawn>

==Assignment==
Variables can be re-assigned data after they are created. For example:
<sourcepawn>int a;
float b;
bool c;

a = 5;
b = 5.0;
c = true;
</sourcepawn>

=Arrays=
An array is a sequence of data in a list. Arrays are useful for storing multiple pieces of data in one variable, or mapping one type of data to another.

==Declaration==
An array is declared using brackets. Some examples of arrays:
<sourcepawn>
int players[32]; // Stores 32 integers.
float origin[3]; // Stores 3 floating point numbers
</sourcepawn>

By default, arrays are initialized to 0. You can assign them different default values, however:
<sourcepawn>
int numbers[5] = {1, 2, 3, 4, 5}; // Stores 1, 2, 3, 4, 5.
float origin[3] = {1.0, 2.0, 3.0}; // Stores 1.0, 2.0, 3.0.
int autoNum[3] = {1, ...}; // Stores 1, 1, 1
</sourcepawn>

You can leave out the array size if you're going to pre-assign data to it. For example:
<sourcepawn>
int numbers[] = {1, 3, 5, 7, 9};
</sourcepawn>

The compiler will automatically deduce that you intended an array of size 5.

When array is declared with brackets after its name, Pawn considers that array to have a '''fixed size'''. The size of a fixed-size array is always known. Some arrays can be '''dynamically sized''', by putting the brackets before the name. For example,

<sourcepawn>
int[] numbers = new int[MaxClients]
</sourcepawn>

This creates an array of size <tt>MaxClients</tt>, which could be anything, so the size of the array is not known until the array is allocated.

==Usage==
Using an array is just like using a normal variable. The only difference is the array must be '''indexed'''. Indexing an array means choosing the element which you wish to use.

For example, here is an example of the above code using indexes:
<sourcepawn>
int numbers[5];
float origin[3];

numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;
origin[0] = 1.0;
origin[1] = 2.0;
origin[2] = 3.0;
</sourcepawn>

Note that the '''index''' is what's in between the brackets. The index always starts from 0. That is, if an array has N elements, its valid indexes are from 0 to N-1. Accessing the data at these indexes works like a normal variable.

Using an incorrect index will cause an error. For example:
<sourcepawn>
int numbers[5];

numbers[5] = 20;</sourcepawn>

This may look correct, but 5 is not a valid index. The highest valid index is 4.

You can use any expression as an index. For example:
<sourcepawn>int a, numbers[5];

a = 1; // Set a = 1
numbers[a] = 4; // Set numbers[1] = 4
numbers[numbers[a]] = 2; // Set numbers[4] = 2
</sourcepawn>

Expressions will be discussed in depth later in the article.

=Enums=
Enums are retyped integers. A new enum can be declared as follows:

<sourcepawn>enum MyEnum // the name is optional
{
MyFirstValue, // == 0, if not explicitly assigned, the first value is zero
MySecondValue, // == 1, implicitly set to the previous value plus one
MyThirdValue = 1, // == 1, explicitly assign to one -- multiple names can share the same value
MyFourthValue, // == 2
}
</sourcepawn>

To allow implicit conversions of enums back to integers (that is, so functions expecting a value of type 'int' accepts it as one instead of generating a warning), the enum must either be anonymous (unnamed) or must start with a lowercase character.

=Strings=
Strings are a construct for storing text (or even raw binary data). A string is just an array of characters, except that the final character must be 0 (called the null terminator). Without a null terminator, Pawn would not know where to stop reading the string. All strings are [http://en.wikipedia.org/wiki/UTF-8 UTF-8] in SourcePawn.

In general, you must have an idea of how large a string will be before you store it. SourcePawn does not yet have the capability of pre-determining storage space for strings.

==Usage==
Strings are usually declared as arrays. For example:
<sourcepawn>
char message[] = "Hello!";
char clams[6] = "Clams";
</sourcepawn>

These are equivalent to doing:
<sourcepawn>
char message[7];
char clams[6];

message[0] = 'H';
message[1] = 'e';
message[2] = 'l';
message[3] = 'l';
message[4] = 'o';
message[5] = '!';
message[6] = 0;
clams[0] = 'C';
clams[1] = 'l';
clams[2] = 'a';
clams[3] = 'm';
clams[4] = 's';
clams[5] = 0;
</sourcepawn>

Although strings are rarely initialized in this manner, it is very important to remember the concept of the null terminator, which signals the end of a string. The compiler, and most SourceMod functions will automatically null-terminate for you, so it is mainly important when manipulating strings directly.

Note that a string is enclosed in double-quotes, but a character is enclosed in single quotes.

==Characters==
A character of text can be used in either a String or a cell. For example:
<sourcepawn>char text[] = "Crab";
char clam;

clam = 'D'; //Set clam to 'D'
text[0] = 'A'; //Change the 'C' to 'A', it is now 'Arab'
clam = text[0]; //Set clam to 'A'
text[1] = clam; //Change the 'r' to 'A', is is now 'AAab'
</sourcepawn>

What you can't do is mix character arrays with strings. The internal storage is different. For example:
<sourcepawn>
int clams[] = "Clams"; // Invalid.
int clams[] = {'C', 'l', 'a', 'm', 's', 0}; // Valid, but NOT A STRING.
</sourcepawn>

==Concatenation==
In programming, concatenation is the operation of joining character strings end-to-end. The benefit of this is to improve the readability of the source code for humans, since the compiler will continue to treat the strings as a single string. String literals can be concatenated with the <tt>...</tt> or <tt>\</tt> operator:

<sourcepawn>
char text[] = "This is a really long string of text that should be split over multiple lines for the sake of readability."

char text[] = "This is a really long string of text that should be "
... "split over multiple lines for the sake of readability."; // Valid.

char text[] = "This is a really long string of text that should be \
split over multiple lines for the sake of readability."; // Valid.

char prefix[] = "What you can't do, however, ";
char moreText[] = prefix ... "is concatenate using a non-literal string."; // Invalid, not a constant expression.
</sourcepawn>

=Functions=
Functions, as stated before, are isolated blocks of code that perform an action. They can be invoked, or '''called''', with '''parameters''' that give specific options.

There are two types of ways functions are called:
*'''direct call''' - You specifically call a function in your code.
*'''callback''' - The application calls a function in your code, as if it were an event trigger.

There are six types of functions:
*'''native''': A direct, internal function provided by the application.
*'''public''': A callback function that is visible to the application and other scripts.
*'''normal''': A normal function that only you can call.
*'''static''': The scope of this function is restricted to the current file, can be used in combination with stock.
*'''stock''': A normal function provided by an include file. If unused, it won't be compiled.
*'''forward''': This function is a global event provided by the application. If you implement it, it will be a callback.

All code in Pawn must exist in functions. This is in contrast to languages like PHP, Perl, and Python which let you write global code. That is because Pawn is a callback-based language: it responds to actions from a parent application, and functions must be written to handle those actions. Although our examples often contain free-floating code, this is purely for demonstration purposes. Free-floating code in our examples implies the code is part of some function.

==Declaration==
Unlike variables, functions do not need to be declared before you use them. Functions have two pieces, the '''signature''' and the '''body'''. The signature contains the name of your function and the parameters it will accept. The body is the contents of its code.

Example of a function:
<sourcepawn>
int AddTwoNumbers(int first, int second)
{
int sum = first + second;
return sum;
}</sourcepawn>

This is a simple function. The prototype is this line:
<sourcepawn>int AddTwoNumbers(int first, int second)</sourcepawn>

Broken down, it means:
*<tt>int</tt> - Return value type (integer).
*<tt>AddTwoNumbers</tt> - Name of the function.
*<tt>int first</tt> - First parameter, an integer.
*<tt>int second</tt> - Second parameter, an integer.

The body is a block of code. It creates a new variable, called <tt>sum</tt>, and assigns it the value of the two parameters added together (more on expressions later). The important thing to notice is the <tt>return</tt> statement, which tells the function to end and return a value to the caller of the function. All functions return something on completion, unless they return a special type called <tt>void</tt>.

A function can accept any type of input, and it can return any non-array type.

You can, of course, pass variables to functions:
<sourcepawn>int numbers[3] = {1, 2, 0};

numbers[2] = AddTwoNumbers(numbers[0], numbers[1]);</sourcepawn>

Note that cells are passed '''by value'''. That is, their value cannot be changed by the function. For example:
<sourcepawn>int a = 5;

ChangeValue(a);

void ChangeValue(int b)
{
b = 5;
}</sourcepawn>

This code would not change the value of <tt>a</tt>. That is because a copy of the value in <tt>a</tt> is passed instead of <tt>a</tt> itself.

More examples of functions will be provided throughout the article.

==Publics==
Public functions are used to implement callbacks. You should not create a public function unless it is specifically implementing a callback. For example, here are two callbacks from <tt>sourcemod.inc</tt>:

<sourcepawn>forward void OnPluginStart();
forward void OnClientDisconnected(int client);</sourcepawn>

To implement and receive these two events, you would write functions as such:

<sourcepawn>public void OnPluginStart()
{
/* Code here */
}

public void OnClientDisconnected(int client)
{
/* Code here */
}</sourcepawn>

The '''public''' keyword signals to the parent application that it should attach the function to the appropriate forwarded event.

==Natives==
Natives are builtin functions provided by SourceMod. You can call them as if they were a normal function. For example, SourceMod has the following function:

<sourcepawn>native float FloatRound(float num);</sourcepawn>

It can be called like so:
<sourcepawn>int rounded = FloatRound(5.2); // rounded will be 5</sourcepawn>

==Array Parameters==
You can pass arrays or Strings as parameters. It is important to note that these are passed '''by reference'''. That is, rather than making a copy of the data, the data is referenced directly. There is a simple way of explaining this more concretely.

<sourcepawn>
int example[] = {1, 2, 3, 4, 5};

ChangeArray(example, 2, 29);

void ChangeArray(int[] array, int index, int value)
{
array[index] = value;
}</sourcepawn>

The function sets the given index in the array to a given value. When it is run on our example array, it changes index 2 to from the value 3 to 29. I.e.:
<sourcepawn>example[2] = 29;</sourcepawn>

Note two important things here. First, arrays are not copied when they are passed to functions - they are passed ''by reference'', so the view of the array is consistent at all times. Second, the brackets changed position in our function signature. This is because our function accepts an array of any size, and since we don't know the size, we must use the dynamic array syntax.

To prevent an array from being modified in a function, you can mark it as <tt>const</tt>. This will raise an error on code that attempts to modify it. For example:

<sourcepawn>void CantChangeArray(const int[] array, int index, int value)
{
array[index] = value; //Won't compile
}</sourcepawn>

It is a good idea to use <tt>const</tt> in array parameters if you know the array won't be modified; this can prevent coding mistakes.

When a function takes an array as a parameter, you can also pass any indexed array element which will be interpreted as a sub-array (slice) that begins from that index. For example,
if you want to get the length of a string, you can use the strlen function like so:

<sourcepawn>
char myString[] = "myString";
int length = strlen(myString); // Set length = 8
</sourcepawn>

And if you pass an indexed array element, it will be interpreted as a slice that begins from that index like so:

<sourcepawn>
char myString[] = "myString";
int length = strlen(myString[2]); // Set length = 6
</sourcepawn>

==Named Parameters==
With functions that have many parameters with default values, you can call the function with named parameters to assign a value based on its name instead of which position it is in the argument list. For example:

<sourcepawn>
void SomeFunctionWithDefaultParams(int a, int b = 1, int c = 2, int d = 3, int e = 4);

// If you want to call it with a different value for `d` -- note the dotted argument assignment
SomeFunctionWithDefaultParams(0, .d = 14);

// This is effectively the same, but less readable:
SomeFunctionWithDefaultParams(0, _, _, 14, _);
</sourcepawn>

=Expressions=
Expressions are exactly the same as they are in mathematics. They are groups of operators/symbols which evaluate to one piece of data. They are often parenthetical (comprised of parenthesis). They contain a strict "order of operations." They can contain variables, functions, numbers, and expressions themselves can be nested inside other expressions, or even passed as parameters.

The simplest expression is a single number. For example:
<sourcepawn>
0; //Returns the number 0
(0); //Returns the number 0 as well
</sourcepawn>

Although expressions can return any value, they are also said to either return ''zero or non-zero''. In that sense, ''zero'' is ''false'', and ''non-zero'' is ''true''. For example, -1 is '''true''' in Pawn, since it is non-zero. Do not assume negative numbers are false.

The order of operations for expressions is similar to C. PMDAS: Parenthesis, Multiplication, Division, Addition, Subtraction. Here are some example expressions:
<sourcepawn>
5 + 6; //Evaluates to 11
5 * 6 + 3; //Evaluates to 33
5 * (6 + 3); //Evaluates to 45
5.0 + 2.3; //Evaluates to 7.3
(5 * 6) % 7; //Modulo operator, evaluates to 2
(5 + 3) / 2 * 4 - 9; //Evaluates to -8
</sourcepawn>

As noted, expressions can contain variables, or even functions:
<sourcepawn>
int a = 5 * 6;
int b = a * 3; //Evaluates to 90
int c = AddTwoNumbers(a, b) + (a * b);
</sourcepawn>

Note: String manipulation routines may be found in the string.inc file located in the include subdirectory. They may be browsed through the [http://docs.sourcemod.net/api/ API Reference] as well.

==Operators==
There are a few extra helpful operators in Pawn. The first set simplifies self-aggregation expressions. For example:
<sourcepawn>int a = 5;

a = a + 5;</sourcepawn>

Can be rewritten as:
<sourcepawn>int a = 5;
a += 5;</sourcepawn>

This is true of the following operators in Pawn:
*Four-function: *, /, -, +
*Bit-wise: |, &, ^, ~, <<, >>

Additionally, there are increment/decrement operators:
<sourcepawn>a = a + 1;
a = a - 1;</sourcepawn>

Can be simplified as:
<sourcepawn>a++;
a--;</sourcepawn>

As an advanced note, the ++ or -- can come before the variable (pre-increment, pre-decrement) or after the variable (post-increment, post-decrement). The difference is in how the rest of the expression containing them sees their result.

* ''Pre:'' The variable is incremented before evaluation, and the rest of the expression sees the new value.
* ''Post:'' The variable is incremented after evaluation, and the rest of the expression sees the old value.

In other words, <tt>a++</tt> evaluates to the value of <tt>a</tt> while <tt>++a</tt> evaluates to the value of <tt>a + 1</tt>. In both cases <tt>a</tt> is incremented by <tt>1</tt>.

For example:

<sourcepawn>int a = 5;
int b = a++; // b = 5, a = 6 (1)
int c = ++a; // a = 7, c = 7 (2)
</sourcepawn>

In (1) <tt>b</tt> is assigned <tt>a</tt>'s ''old'' value ''before'' it is incremented to <tt>6</tt>, but in (2) <tt>c</tt> is assigned <tt>a</tt>'s ''int'' value ''after'' it is incremented to <tt>7</tt>.

==Comparison Operators==
There are six operators for comparing two values numerically, and the result is either true (non-zero) or false (zero):
*<tt>a == b</tt> - True if a and b have the same value.
*<tt>a != b</tt> - True if a and b have different values.
*<tt>a > b</tt> - True if a is greater than b
*<tt>a >= b</tt> - True if a is greater than or equal to b
*<tt>a < b</tt> - True if a is less than b
*<tt>a <= b</tt> - True if a is less than or equal to b

For example:
<sourcepawn>
(1 != 3); //Evaluates to true because 1 is not equal to 3.
(3 + 3 == 6); //Evaluates to true because 3+3 is 6.
(5 - 2 >= 4); //Evaluates to false because 3 is less than 4.
</sourcepawn>

Note that these operators do not work on arrays or strings. That is, you cannot compare either using <tt>==</tt>.

==Truth Operators==
These truth values can be combined using three boolean operators:
*<tt>a && b</tt> - True if both a and b are true. False if a or b (or both) is false.
{| border="1" cellpadding="2" cellspacing="0" align="center"
! <tt>&&</tt> !! 0 !! 1
|-
! 0
| 0 || 0
|-
! 1
| 0 || 1
|}
*<tt>a || b</tt> - True if a or b (or both) is true. False if both a and b are false.
{| border="1" cellpadding="2" cellspacing="0" align="center"
! <tt><nowiki>||</nowiki></tt> !! 0 !! 1
|-
! 0
| 0 || 1
|-
! 1
| 1 || 1
|}
*<tt>!a</tt> - True if a is false. False if a is true.
{| border="1" cellpadding="2" cellspacing="0" align="center"
! <tt>!</tt> !! 0 !! 1
|-
!
| 1 || 0
|}

For example:
<sourcepawn>
(1 || 0); //Evaluates to true because the expression 1 is true
(1 && 0); //Evaluates to false because the expression 0 is false
(!1 || 0); //Evaluates to false because !1 is false.
</sourcepawn>

==Left/Right Values==
Two important concepts are left-hand and right-hand values, or l-values and r-values. An l-value is what appears on the left-hand side of a variable assignment, and an r-value is what appears on the right side of a variable assignment.

For example:
<sourcepawn>
int a = 5;</sourcepawn>

In this example <tt>a</tt> is an l-value and <tt>5</tt> is an r-value.

The rules:
*'''Expressions are never l-values'''.
*'''Variables are both l-values and r-values'''.

=Conditionals=
Conditional statements let you only run code if a certain condition is matched.

==If Statements==
If statements test one or more conditions. For example:

<sourcepawn>
if (a == 5)
{
/* Code that will run if the expression was true */
}</sourcepawn>

They can be extended to handle more cases as well:
<sourcepawn>
if (a == 5)
{
/* Code */
}
else if (a == 6)
{
/* Code */
}
else if (a == 7)
{
/* Code */
}</sourcepawn>

You can also handle the case of no expression being matched. For example:
<sourcepawn>
if (a == 5)
{
/* Code */
}
else
{
/* Code that will run if no expressions were true */
}</sourcepawn>

==Switch Statements==
Switch statements are restricted if statements. They test one expression for a series of possible values. For example:

<sourcepawn>
switch (a)
{
case 5:
{
/* code */
}
case 6:
{
/* code */
}
case 7:
{
/* code */
}
case 8, 9, 10:
{
/* Code */
}
default:
{
/* will run if no case matched */
}
}</sourcepawn>

Unlike some other languages, switches are not fall-through. That is, multiple cases will never be run. When a case matches its code is executed, and the switch is then immediately terminated.

=Loops=
Loops allow you to conveniently repeat a block of code while a given condition remains true.

==For Loops==
For loops are loops which have four parts:
*The '''initialization''' statement - run once before the first loop.
*The '''condition''' statement - checks whether the next loop should run, including the first one. The loop terminates when this expression evaluates to false.
*The '''iteration''' statement - run after each loop.
*The '''body''' block - run each time the '''condition''' statement evaluates to true.

<sourcepawn>
for ( /* initialization */ ; /* condition */ ; /* iteration */ )
{
/* body */
}
</sourcepawn>

A simple example is a function to sum an array:
<sourcepawn>
int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = SumArray(array, 10);

int SumArray(const int[] array, int count)
{
int total;

for (int i = 0; i < count; i++)
{
total += array[i];
}

return total;
}</sourcepawn>

Broken down:
*<tt>int i = 0</tt> - Creates a new variable for the loop, sets it to 0.
*<tt>i < count</tt> - Only runs the loop if <tt>i</tt> is less than <tt>count</tt>. This ensures that the loop stops reading at a certain point. In this case, we don't want to read invalid indexes in the array.
*<tt>i++</tt> - Increments <tt>i</tt> by one after each loop. This ensures that the loop doesn't run forever; eventually <tt>i</tt> will become too big and the loop will end.

Thus, the <tt>SumArray</tt> function will loop through each valid index of the array, each time adding that value of the array into a sum. For loops are very common for processing arrays like this.

==While Loops==
While loops are less common than for loops but are actually the simplest possible loop. They have only two parts:
*The '''condition''' statement - checked before each loop. The loop terminates when it evaluates to false.
*The '''body''' block - run each time through the loop.

<sourcepawn>
while ( /* condition */ )
{
/* body */
}
</sourcepawn>

As long as the condition expression remains true, the loop will continue. Every for loop can be rewritten as a while loop:

<sourcepawn>
/* initialization */
while ( /* condition */ )
{
/* body */
/* iteration */
}
</sourcepawn>

Here is the previous for loop rewritten as a while loop:
<sourcepawn>
int SumArray(const int[] array, int count)
{
int total, i;

while (i < count)
{
total += array[i];
i++;
}

return total;
}</sourcepawn>

There are also '''do...while''' loops which are even less common. These are the same as while loops except the condition check is AFTER each loop, rather than before. This means the loop is always run at least once. For example:

<sourcepawn>
do
{
/* body */
}
while ( /* condition */ );
</sourcepawn>

==Loop Control==
There are two cases in which you want to selectively control a loop:
*'''skipping''' one iteration of the loop but continuing as normal, or;
*'''breaking''' the loop entirely before it's finished.

Let's say you have a function which takes in an array and searches for a matching number. You want it to stop once the number is found:
<sourcepawn>
/**
* Returns the array index where the value is, or -1 if not found.
*/
int SearchInArray(const int[] array, int count, int value)
{
int index = -1;

for (int i = 0; i < count; i++)
{
if (array[i] == value)
{
index = i;
break;
}
}

return index;
}</sourcepawn>

Certainly, this function could simply <tt>return i</tt> instead, but the example shows how <tt>break</tt> will terminate the loop.

Similarly, the <tt>continue</tt> keyword skips an iteration of a loop. For example, let's say we wanted to sum all even numbers:
<sourcepawn>
int SumEvenNumbers(const int[] array, int count)
{
int sum;

for (int i = 0; i < count; i++)
{
/* If divisibility by 2 is 1, we know it's odd */
if (array[i] % 2 == 1)
{
/* Skip the rest of this loop iteration */
continue;
}
sum += array[i];
}

return sum;
}</sourcepawn>

=Scope=
Scope refers to the '''visibility''' of code. That is, code at one level may not be "visible" to code at another level. For example:

<sourcepawn>
int A, B, C;

void Function1()
{
int B;

Function2();
}

void Function2()
{
int C;
}</sourcepawn>

In this example, <tt>A</tt>, <tt>B</tt>, and <tt>C</tt> exist at '''global scope'''. They can be seen by any function. However, the <tt>B</tt> in <tt>Function1</tt> is not the same variable as the <tt>B</tt> at the global level. Instead, it is at '''local scope''', and is thus a '''local variable'''.

Similarly, <tt>Function1</tt> and <tt>Function2</tt> know nothing about each other's variables.

Not only is the variable private to <tt>Function1</tt>, but it is re-created each time the function is invoked. Imagine this:
<sourcepawn>
void Function1()
{
int B;

Function1();
}</sourcepawn>

In the above example, <tt>Function1</tt> calls itself. Of course, this is infinite recursion (a bad thing), but the idea is that each time the function runs, there is a new copy of <tt>B</tt>. When the function ends, <tt>B</tt> is destroyed, and the value is lost.

This property can be simplified by saying that a variable's scope is equal to the nesting level it is in. That is, a variable at global scope is visible globally to all functions. A variable at local scope is visible to all code blocks "beneath" its nesting level. For example:

<sourcepawn>void Function1()
{
int A;

if (A)
{
A = 5;
}
}</sourcepawn>

The above code is valid since A's scope extends throughout the function. The following code, however, is not valid:
<sourcepawn>
void Function1()
{
int A;

if (A)
{
int B = 5;
}

B = 5;
}</sourcepawn>

Notice that <tt>B</tt> is declared in a new code block. That means <tt>B</tt> is only accessible to that code block (and all sub-blocks nested within). As soon as the code block terminates, <tt>B</tt> is no longer valid.

=Dynamic Arrays=
Dynamic arrays are arrays which don't have a hardcoded size. For example:

<sourcepawn>void Function1(int size)
{
int[] array = new int[size];

/* Code */
}</sourcepawn>

Dynamic arrays can have any expression as their size as long as the expression evaluates to a number larger than 0. Like normal arrays, SourcePawn does not know the array size after it is created; you have to save it if you want it later.

Dynamic arrays are only valid at the local scope level, since code cannot exist globally.

=Extended Variable Declarations=
Variables can be declared in more ways than simply <tt>int float or char</tt>.

==static==
The <tt>static</tt> keyword is available at global and local scope. It has different meanings in each.

===Global static===
A global static variable can only be accessed from within the same file. For example:

<sourcepawn>//file1.inc
static float g_value1 = 0.15f;

//file2.inc
static float g_value2 = 0.15f;</sourcepawn>

If a plugin includes both of these files, it will not be able to use either <tt>g_value1</tt> or <tt>g_value2</tt>. This is a simple information hiding mechanism, and is similar to declaring member variables as <tt>private</tt> in languages like C++, Java, or C#.

===Local static===
A local static variable is a global variable that is only visible from its local lexical scope. For example:

<sourcepawn>
int MyFunction(int inc)
{
static int counter = -1;

counter += inc;

return counter;
}</sourcepawn>

In this example, <tt>counter</tt> is technically a global variable -- it is initialized once to -1 and is never initialized again. It does not exist on the stack. That means each time <tt>MyFunction</tt> runs, the <tt>counter</tt> variable and its storage in memory is the same.

Take this example:
<sourcepawn>MyFunction(5);
MyFunction(6);
MyFunction(10);</sourcepawn>

In this example, <tt>counter</tt> will be <tt>-1 + 5 + 6 + 10</tt>, or <tt>20</tt>, because it persists beyond the frame of the function. Note this may pose problems for recursive functions: if your function may be recursive, then <tt>static</tt> is usually not a good idea unless your code is re-entrant.

The benefit of a local static variable is that you don't have to clutter your script with global variables. As long as the variable doesn't need to be read by another function, you can squirrel it inside the function and its persistence will be guaranteed.

Note that statics can exist in any local scope:

<sourcepawn>
int MyFunction(int inc)
{
if (inc > 0)
{
static int counter;
return (counter += inc);
}
return -1;
}</sourcepawn>

[[Category:SourceMod Scripting]]

{{LanguageSwitch}}

Scripting FAQ (SourceMod)

2012-09-22T03:19:00Z

Impact123: /* How do I hook +commands, such as +zoom and +attack? */ Removed the == IN_ATTACK, this only confuses users

[[Image:Yak.gif]]
yak wuz heer

=How do I learn SourcePawn?=
A good start is on the [[Introduction to SourcePawn]] page, which will teach you the SourcePawn language. Then go through the [[Introduction to SourceMod Plugins]], which will teach you how to write your first plug-in.

=Where can I find all the SourcePawn functions and other information?=
All SourceMod plug-ins have this line:

<pawn>#include <sourcemod></pawn>

This line instructs the compiler to retrieve the file <tt>sourcemod.inc</tt> from the <tt>sourcemod/scripting/include</tt> folder. Every function, variable, and definition can be found in the <tt>.inc</tt> files inside the <tt>sourcemod/scripting/include</tt> folder.

But searching through all those files can be quite tedious. Thankfully, the honourable [https://forums.alliedmods.net/member.php?u=9443 Nican] created an API reference viewable on the web, complete with searching and commenting: [http://docs.sourcemod.net/api/ http://docs.sourcemod.net/api/]

Also, if you are in the SourceMod IRC channel ([irc://irc.gamesurge.net/sourcemod #sourcemod on GameSurge]), you can use the <tt>!api</tt> command to search [https://forums.alliedmods.net/member.php?u=9443 Nican's] API reference:
<pre><theY4Kman> !api Netclass
<yakbot> theY4Kman: GetEntityNetClass(edict, String:clsname[], maxlength): Retrieves an entity's networkable serverclass name. This is not the same as the classname and is used for networkable state changes. (http://docs.sourcemod.net/api/index.php?fastload=show&id=66)</pre>

=How do I find the classname of an entity? (e.g., "<tt>weapon_knife</tt>" or "<tt>prop_physics</tt>")=
The classname of an entity (not to be confused with a netclass such as <tt>CCSPlayer</tt>) is a unique identifier. It's the most well known of entity names. To find it, use the function [http://docs.sourcemod.net/api/index.php?fastload=show&id=65 GetEdictClassname()]:

<pawn>decl String:classname[128];
GetEdictClassname(myentity, classname, sizeof(classname));

PrintToServer("myentity classname: %s", classname);
// myentity classname: weapon_knife</pawn>

=How do I block regular commands, such as <tt>kill</tt> and <tt>say</tt>?=
As of version 1.3, the recommended way to hook and block commands is with [http://docs.sourcemod.net/api/index.php?fastload=show&id=949 AddCommandListener()]. Previously, using [http://docs.sourcemod.net/api/index.php?fastload=show&id=470 RegConsoleCmd()] with the command name was the only way to hook commands, but this creates a whole new command for the command dispatch to check every time any command is executed. [http://docs.sourcemod.net/api/index.php?fastload=show&id=949 AddCommandListener()] creates only a lightweight hook, processed only when the specific command is executed.

Here's how to use it to block the <tt>say</tt> command:

<pawn>public OnPluginStart()
{
AddCommandListener(SayCallback, "say");
}

public Action:SayCallback(client, const String:command[], argc)
{
Return Plugin_Handled;
}</pawn>

=How do I hook +commands, such as <tt>+zoom</tt> and <tt>+attack</tt>?=
Unlike regular commands, <tt>+commands</tt> are handled on the client's computer, then sent to the server in a more compressed fashion. This means [http://docs.sourcemod.net/api/index.php?fastload=show&id=949 AddCommandListener()] cannot be used to hook <tt>+commands</tt>. As of version 1.3, the recommended solution is to use the global forward [http://docs.sourcemod.net/api/index.php?fastload=show&id=937 OnPlayerRunCmd()]. This forward is fired every time a player uses a movement button. To detect or block a <tt>+command</tt>, you'll first have to find out its proper <tt>IN_</tt> constant (see <tt>[http://docs.sourcemod.net/api/index.php?fastload=file&id=47&file=& entity_prop_stocks.inc]</tt>).

Here's how to use it to block crouching when attacking:

<pawn>public Action:OnPlayerRunCmd(client, &buttons, &impulse, Float:vel[3], Float:angles[3], &weapon)
{
// Check if the player is attacking (+attack)
if (buttons & IN_ATTACK)
{
// If so, block their crouching (+duck)
buttons &= ~IN_DUCK;
}

// We must return Plugin_Continue to let the changes be processed.
// Otherwise, we can return Plugin_Handled to block the commands
return Plugin_Continue;
}</pawn>

=How do I get rid of loose indentation warnings?=
<pre>myplugin.sp(#) : warning 217: loose indentation</pre>

Loose indentation warnings arise when indentation in your code is inconsistent. This usually means using both tabs and spaces as indentation. However, it can also mean a different amount of spaces or tabs are being used. Therefore, to correct it, use just one type of indentation. Because different editors have different settings for the size of tab stops, it is recommended you use 4 spaces to indent.

Good:

<pawn>public OnPluginStart()
{
new myvar = 5;
if (myvar == (2 + 3))
PrintToServer("myvar is %d", myvar);
}</pawn>

Bad:

<pawn>public OnPluginStart()
{
new myvar = 5;
if (myvar == (2 + 3))
PrintToServer("myvar is %d", myvar);
}</pawn>

=How do I get rid of tag mismatch warnings?=
Though every variable in SourcePawn is one cell (4 bytes), with the exception of strings, there are many different ways to interpret what's inside a cell. To signify a cell's contents, tags are used. The most common are <tt>_</tt> (the default tag: a vanilla cell. This tag is implied when no other tag is specified.), <tt>Float</tt>, <tt>bool</tt>, and <tt>String</tt>. See [Introduction to SourcePawn#Variables_2] for more information.

Functions wear these tags on their parameters so you can tell what needs to be passed to the function:
<pawn>native SetEntPropFloat(entity, PropType:type, const String:prop[], Float:value);</pawn>

This function calls for '''<tt>entity</tt>''', a cell with the implied tag '''''<tt>_</tt>'''''; '''<tt>type</tt>''', with the developer-defined tag '''''<tt>PropType</tt>'''''; '''<tt>prop</tt>''', with the built-in tag '''''<tt>String</tt>'''''; and '''<tt>value</tt>''', with the built-in tag '''''<tt>Float</tt>'''''.
To call this function, then, you must pass values with the specified tags. For example:
<pawn>SetEntPropFloat(1234, Prop_Send, "m_fNumber", 1.0);</pawn>

This calls the function correctly: <tt>1234</tt> is a regular cell ('''''<tt>_</tt>'''''), <tt>Prop_Send</tt> is a variable defined in the enum '''''<tt>PropType</tt>''''' in [http://docs.sourcemod.net/api/index.php?fastload=file&id=4&file=& entity.inc], <tt>"m_fNumber"</tt> is a '''''<tt>String</tt>''''', and <tt>1.0</tt> is a '''''<tt>Float</tt>'''''. For a nonexample:
<pawn>SetEntPropFloat(1234.0, 1, "m_fNumber", 1337);</pawn>

This is incorrect! <tt>1234.0</tt> is a '''''<tt>Float</tt>''''' that should be a regular cell ('''''<tt>_</tt>'''''); <tt>1</tt> is a regular cell ('''''<tt>_</tt>''''') that should be a '''''<tt>PropType</tt>'''''; and <tt>1337</tt> is a regular cell ('''''<tt>_</tt>''''') that should be a '''''<tt>Float</tt>'''''. This call will generate a tag mismatch warning. To correct it, simply use a value with the correct tag. Most of the time, tags that are not built-in (such as '''''<tt>PropType</tt>''''') can be found in the same file where a function uses them (you can find '''''<tt>PropType</tt>''''' in [http://docs.sourcemod.net/api/index.php?fastload=file&id=4&file=& entity.inc]).

=How do I add color to my messages?=
Though the actual colors will vary depending on the mod, you can add color to any chat message using the characters <tt>0x01</tt> to <tt>0x08</tt>. For example:
<pawn>PrintToChatAll ("\x01 1 .. \x02 2 .. \x03 3 .. \x04 4 .. \x05 5 .. \x06 6 .. \x07 7 .. \x08 8");</pawn>

Example output from Left 4 Dead:

[[Image:Left_4_Dead_Colors.png]]

With a little experimenting, you can learn the colors for a mod. However, the meaning behind the colors is generally as follows:

* <tt style="color: blue;">0x01</tt> = Normal color
* <tt style="color: blue;">0x02</tt> = Use team color to the end of a player's name. When used, it can be the only color used, and it must be at the start of the message.
* <tt style="color: blue;">0x03</tt> = Team color
* <tt style="color: blue;">0x04</tt> = Location color

This data comes from Counter-Strike: Source.

Unfortunately, to use players' team colors, you must use UserMessages, because there is no way for the current SourceMod functions to know which team color to use. Here's an example:

<pawn>new Handle:hBf;
hBf = StartMessageOne("SayText2", player_to); // To send the message to all players, use StartMessageAll("SayText2");
if (hBf != INVALID_HANDLE)
{
BfWriteByte(hBf, player_from);
BfWriteByte(hBf, 0);
BfWriteString(hBf, "<\x03player_from team color\x01> My message");
EndMessage();
}</pawn>

<tt>player_to</tt> is the client index to send the message to (or use [http://docs.sourcemod.net/api/index.php?fastload=show&id=132& StartMessageAll()] instead of [http://docs.sourcemod.net/api/index.php?fastload=show&id=133& StartMessageOne()] to send the message to all players). <tt>player_from</tt> is the client index of the player whose team color will be utilized in the message. The message will now look like this (assuming <tt>player_from</tt> is on the RED team):

<player_from team color> My message

There's another catch, however: this is only known to work in CS:S and TF2. For other mods, your mileage may vary.

==Color Libraries==
There are a few libraries that can handle colors for you, so you don't have to muck with UserMessages:

===exvel's Colors===
This is a simple include file, allowing easy control over chat coloring. You can grab it [http://forums.alliedmods.net/showthread.php?t=96831 on the forums]. Instead of hex codes, colors are denoted with tags, such as <tt>{default}</tt>, <tt>{green}</tt>, or <tt>{blue}</tt>.

Here's some example usage. Note that this code assumes client 1 is in game and on the BLU team:

<pawn>#include <colors>

public OnPluginStart()
{
CPrintToChatAll("{green}Hello {red}World! {default}Test 1 concluded.");

new client_on_blu_team = 1;
CPrintToChatAllEx(client_on_blu_team, "{teamcolor}BLU team {default}says {green}hi!");
}</pawn>

Hello World! Test 1 concluded.
BLU team says hi!

Note that to use a team color, there needs to be at least one player on that team. Otherwise, it will default to <tt>{green}</tt>.

===SMLib===
[http://forums.alliedmods.net/showthread.php?p=1398699 SMLib] is a huge collection of stock functions to keep plug-in developers from reinventing the wheel. It includes a [http://forums.alliedmods.net/showthread.php?p=1398702#post1398702 colors API] very similar to [[#exvel's Colors|exvel's]]. The benefits of SMLib are it supports shorthand color names, such as <tt>{N}</tt> and <tt>{G}</tt>, and all colors are supported in its <tt>Client_PrintToChat()</tt> function.

Here's how to print the same thing as the above example with SMLib. Note that this code also assumes client 1 is in game and on the BLU team:

<pawn>#include <smlib>

public OnPluginStart()
{
Client_PrintToChatAll("{G}Hello {R}World! {N}Test 1 concluded.");

new client_on_blu_team = 1;
Client_PrintToChatAll(client_on_blu_team, "{T}BLU team {N}says {G}hi!");
}</pawn>

Hello World! Test 1 concluded.
BLU team says hi!

=Why do I get an "unknown symbol" error when using an SDKTools native?=
None of SourceMod's or SDKTools's functions are built into SourcePawn. Therefore, every time you use one of their functions, SourcePawn needs to know how to call the function. Normally, this is done using includes. Just like you would #include <sourcemod> to use SourceMod's functions, you need to:
<pawn>#include <sdktools></pawn>
to use an SDKTools native.

=Why is Source telling me my command is an "Unknown command"?=
This is because you're not returning <tt>Plugin_Handled</tt> in your callback. If you don't, SourceMod believes you didn't want the Source Engine to know the command was registered, and it handles it so.

<pawn>public Action:MyCommand(client, args)
{
// Do something...

return Plugin_Handled;
}</pawn>