AlliedModders Wiki - User contributions [en]

Ru:AMX Mod X 1.8.1 Changes

2009-01-28T10:46:43Z

Simon Logic: Redirecting to Список изменений в AMX Mod X 1.8.1

#REDIRECT [[Список изменений в AMX Mod X 1.8.1]]

Список изменений в AMX Mod X 1.8.1

2009-01-28T10:45:08Z

Simon Logic: New page: Category:Russian AMX Mod X 1.8.1 является, по большому счету, работой над ошибками. *Добавлено {{amb|1762}}: Македонский ...

[[Category:Russian]]

AMX Mod X 1.8.1 является, по большому счету, работой над ошибками.

*Добавлено {{amb|1762}}: Македонский язык (спаисбо z3r0Lev3L).
*Добавлено {{amb|1635}}: Нативная функция ns_remove_upgrade().
*Добавлено {{amb|1604}}: Нативная функция unregister_message().
*Добавлено {{amb|1600}}: Trie natives для ассоциативных хранилищ.
*Добавлено {{amb|1365}}: Словацкий язык (спасибо Centaury).
*Добавлено {{amb|1290}}: Обработчик Invalid_Array в cellarray.inc.
*Добавлено {{amb|1263}}: Новый флаг 'k' в файле users.ini, который указывает, что имена/тэги кланов чувствительны к регистру.
*Добавлено {{amb|1167}}: Нативная функция menu_addtext().
*Исправлено {{amb|1648}}: Опечатка в validate_menu_text.
*Исправлено {{amb|1647}}: Координаты браша неверно читались.
*Исправлено {{amb|1643}}: В TFC stats.amxx была опция, которая не поддерживалась конфигурационным меню статистики.
*Исправлено {{amb|1642}}: RTE в файле stats.sma для TFC.
*Исправлено {{amb|1632}}: Некоторые значения mp_roundtime могли конфликтовать со StatsX.
*Исправлено {{amb|1596}}: CSX выделял недостаточную облать памяти для csstats.amxx.
*Исправлено {{amb|1565}}: CCmdManager::gotAccess() имел неконсистентные эвристики.
*Исправлено {{amb|1564}}: amx_chat по-мелочи не соответствовал cmdaccess.ini (патч от Teyut).
*Исправлено {{amb|1545}}: show_activity игнорировала последнего клиента.
*Исправлено {{amb|1456}}: Неверный языковой ключ в режиме голосования за кик/бан.
*Исправлено {{amb|1452}}: ns_give_item() выдавал неверные объекты.
*Исправлено {{amb|1389}}: Функция client_changeteam() из модуля NS имела перевернутый список аргументов интерфейса.
*Исправлено {{amb|1343}}: show_activity() неверно вызывала vformat().
*Исправлено {{amb|1315}}: fread_blocks() не работала из-за опечатки.
*Исправлено {{amb|1313}}: Hamsandwich имел опечатку для мода Sven Co-op.
*Исправлено {{amb|1293}}: Обход ошибки HLDS при парсинге ключей localinfo.
*Исправлено {{amb|1288}}: amx_banip не показывал время (патч от James).
*Исправлено {{amb|1267}}: FlagManager вызывал сбой если файл cmdaccess.ini не был доступен для записи.
*Исправлено {{amb|1218}}: В файле ns.inc была опечатка.
*Исправлено {{amb|1199}}: Неверный комментарий для Ham_DOD_RoundRespawnEnt.
*Исправлено {{amb|1175}}: Новый модуль и плагин не добавлялись в пакет дополнений.
*Исправлено {{amb|1163}}: Распечатка значений с плавающей запятой была некорректной для больших значений.
*Исправлено {{amb|1143}}: Опечатка в SetClientKeyValue().
*Исправлено {{amb|1139}}: Menufront/plmenu не следовали cmdaccess.ini changes for its additions.
*Исправлено {{amb|1134}}: Удалена неиспользуемая cvar.
*Исправлено {{amb|1126}}: Использование dod_set_model() приводило к сбою.
*Исправлено {{amb|1096}}: Ранжирование игроков по IP приводило сервер к застопорению.
*Исправлено {{amb|1079}}: Потоковые запросы к СУБД сзапросом результатов могли сбоить.
*Исправлено {{amb|1077}}: nVault не загружался на некоторых Linux серверах.
*Исправлено {{amb|1089}}: amx_banip выдавал сообщение дважды.
*Исправлено {{amb|1080}}: Опечатка в немецком языке.
*Исправлено {{amb|1049}}: Небрежно были названы объекты TraceResult.
*CS и NS не содержали plmenu и slapdamage значения в amxx.cfg.
*Меню плагинов теперь игнорирует признак иммунитета, когда действие применяется на самом себе.
*Модули, специфичные для модов, больше не загружаются под модами, которые они не поддреживают.
*AMX Mod X теперь использует Visual Studio 2005 (речь о бинарнике под windows).
*Бинарники под Linux теперь не используют -fPIC (стали меньше, немного быстрее).
*Обновлена база GeoIP на август 2008.

Ru:AMX Mod X 1.8.1 Changes

2009-01-28T10:43:41Z

Simon Logic:

Оптимизация Плагинов (AMX Mod X Scripting)

2008-11-10T08:18:14Z

Simon Logic: /* Perfect Hashing */

[[Category:Ru:Scripting (AMX Mod X)]]
== Введение ==
[[Admin-Mod]] и [[AMX Mod X]] стали очень поплулярными из-за используемого в них скриптового языка, который прост в изучении. Однако, словосочетание "скриптовый язык" обычно ассоциируется со следующими устойчивыми понятиями:
*Невозможно сделать его быстрее
*Он прекомпилируемый, значит уже быстрый в исполнении
*Детали и мелочи не важны, т.к. это всего лишь "скрипт"

В отношении [[Pawn]] (ранее известный как [[Small]]), особенно, ничто из вышеперечисленного верно. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

=== Термины ===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

=== Всегда запоминайте результаты ===
Рассмотрим следующий пример:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
В жизни такой участок кода не слишком ресурсоемкий, однако на его примере вполне эффектно можно рассмотреть метод оптимизации плагина. Когда компилятор генерирует псевдокод для исполнения непосредственно интерпретатором, он будет выглядеть примерно так:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Заметили проблему? Мы вызвали функцию <tt>get_user_team</tt> два лишних раза. Возвращаемый результат этих функций не будет меняться, поэтому нам следует его запомнить однократно. Теперь сравните:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Компилятор в этот раз сгенерирует следующий псевдокод:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
Если бы функция <tt>get_user_team</tt> была ресурсоемкой операцией, мы бы вычисляли результат каждый раз при выполненнии условия <tt>if</tt>.

=== Switch вместо If ===
Если возможно, лучше использовать <tt>switch</tt> вместо <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

=== Сравнение глобальных и локальных переменных, переменные в циклах ===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

=== Сравнение статических переменных и глобальных ===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

=== Константы ===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
=== Таблицы поиска ===
Есть такое правило: все что можно заранее вычислить - вычисляйте и запоминайте. Например, вам необходимо сопоставить индекс оружия его имени (т.е. по номеру найти имя):
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Если не учитывать, что в AMX Mod X есть функция <tt>get_weapon_name</tt>, то такой код считается неэффективным. Мы можем запросто сделать сопоставление индексов именам заранее:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..от 0 до CSW_AK47-1
"weapon_ak47",
//..от CSW_AK47+1 до TOTAL_WEAPONS-1
};</pawn>

=== Идеальное хэширование ===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

Оптимизация Плагинов (AMX Mod X Scripting)

2008-11-10T08:17:30Z

Simon Logic: /* Lookup Tables */

[[Category:Ru:Scripting (AMX Mod X)]]
== Введение ==
[[Admin-Mod]] и [[AMX Mod X]] стали очень поплулярными из-за используемого в них скриптового языка, который прост в изучении. Однако, словосочетание "скриптовый язык" обычно ассоциируется со следующими устойчивыми понятиями:
*Невозможно сделать его быстрее
*Он прекомпилируемый, значит уже быстрый в исполнении
*Детали и мелочи не важны, т.к. это всего лишь "скрипт"

В отношении [[Pawn]] (ранее известный как [[Small]]), особенно, ничто из вышеперечисленного верно. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

=== Термины ===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

=== Всегда запоминайте результаты ===
Рассмотрим следующий пример:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
В жизни такой участок кода не слишком ресурсоемкий, однако на его примере вполне эффектно можно рассмотреть метод оптимизации плагина. Когда компилятор генерирует псевдокод для исполнения непосредственно интерпретатором, он будет выглядеть примерно так:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Заметили проблему? Мы вызвали функцию <tt>get_user_team</tt> два лишних раза. Возвращаемый результат этих функций не будет меняться, поэтому нам следует его запомнить однократно. Теперь сравните:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Компилятор в этот раз сгенерирует следующий псевдокод:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
Если бы функция <tt>get_user_team</tt> была ресурсоемкой операцией, мы бы вычисляли результат каждый раз при выполненнии условия <tt>if</tt>.

=== Switch вместо If ===
Если возможно, лучше использовать <tt>switch</tt> вместо <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

=== Сравнение глобальных и локальных переменных, переменные в циклах ===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

=== Сравнение статических переменных и глобальных ===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

=== Константы ===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
=== Таблицы поиска ===
Есть такое правило: все что можно заранее вычислить - вычисляйте и запоминайте. Например, вам необходимо сопоставить индекс оружия его имени (т.е. по номеру найти имя):
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Если не учитывать, что в AMX Mod X есть функция <tt>get_weapon_name</tt>, то такой код считается неэффективным. Мы можем запросто сделать сопоставление индексов именам заранее:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..от 0 до CSW_AK47-1
"weapon_ak47",
//..от CSW_AK47+1 до TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

Оптимизация Плагинов (AMX Mod X Scripting)

2008-11-10T08:11:12Z

Simon Logic: /* Constant variables */

[[Category:Ru:Scripting (AMX Mod X)]]
== Введение ==
[[Admin-Mod]] и [[AMX Mod X]] стали очень поплулярными из-за используемого в них скриптового языка, который прост в изучении. Однако, словосочетание "скриптовый язык" обычно ассоциируется со следующими устойчивыми понятиями:
*Невозможно сделать его быстрее
*Он прекомпилируемый, значит уже быстрый в исполнении
*Детали и мелочи не важны, т.к. это всего лишь "скрипт"

В отношении [[Pawn]] (ранее известный как [[Small]]), особенно, ничто из вышеперечисленного верно. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

=== Термины ===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

=== Всегда запоминайте результаты ===
Рассмотрим следующий пример:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
В жизни такой участок кода не слишком ресурсоемкий, однако на его примере вполне эффектно можно рассмотреть метод оптимизации плагина. Когда компилятор генерирует псевдокод для исполнения непосредственно интерпретатором, он будет выглядеть примерно так:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Заметили проблему? Мы вызвали функцию <tt>get_user_team</tt> два лишних раза. Возвращаемый результат этих функций не будет меняться, поэтому нам следует его запомнить однократно. Теперь сравните:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Компилятор в этот раз сгенерирует следующий псевдокод:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
Если бы функция <tt>get_user_team</tt> была ресурсоемкой операцией, мы бы вычисляли результат каждый раз при выполненнии условия <tt>if</tt>.

=== Switch вместо If ===
Если возможно, лучше использовать <tt>switch</tt> вместо <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

=== Сравнение глобальных и локальных переменных, переменные в циклах ===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

=== Сравнение статических переменных и глобальных ===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

=== Константы ===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

Оптимизация Плагинов (AMX Mod X Scripting)

2008-11-10T08:10:52Z

Simon Logic: /* Static vs Global */

[[Category:Ru:Scripting (AMX Mod X)]]
== Введение ==
[[Admin-Mod]] и [[AMX Mod X]] стали очень поплулярными из-за используемого в них скриптового языка, который прост в изучении. Однако, словосочетание "скриптовый язык" обычно ассоциируется со следующими устойчивыми понятиями:
*Невозможно сделать его быстрее
*Он прекомпилируемый, значит уже быстрый в исполнении
*Детали и мелочи не важны, т.к. это всего лишь "скрипт"

В отношении [[Pawn]] (ранее известный как [[Small]]), особенно, ничто из вышеперечисленного верно. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

=== Термины ===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

=== Всегда запоминайте результаты ===
Рассмотрим следующий пример:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
В жизни такой участок кода не слишком ресурсоемкий, однако на его примере вполне эффектно можно рассмотреть метод оптимизации плагина. Когда компилятор генерирует псевдокод для исполнения непосредственно интерпретатором, он будет выглядеть примерно так:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Заметили проблему? Мы вызвали функцию <tt>get_user_team</tt> два лишних раза. Возвращаемый результат этих функций не будет меняться, поэтому нам следует его запомнить однократно. Теперь сравните:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Компилятор в этот раз сгенерирует следующий псевдокод:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
Если бы функция <tt>get_user_team</tt> была ресурсоемкой операцией, мы бы вычисляли результат каждый раз при выполненнии условия <tt>if</tt>.

=== Switch вместо If ===
Если возможно, лучше использовать <tt>switch</tt> вместо <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

=== Сравнение глобальных и локальных переменных, переменные в циклах ===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

=== Сравнение статических переменных и глобальных ===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

===Constant variables===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

Оптимизация Плагинов (AMX Mod X Scripting)

2008-11-10T08:10:17Z

Simon Logic: /* Global vs Local and Variables in Loops */

[[Category:Ru:Scripting (AMX Mod X)]]
== Введение ==
[[Admin-Mod]] и [[AMX Mod X]] стали очень поплулярными из-за используемого в них скриптового языка, который прост в изучении. Однако, словосочетание "скриптовый язык" обычно ассоциируется со следующими устойчивыми понятиями:
*Невозможно сделать его быстрее
*Он прекомпилируемый, значит уже быстрый в исполнении
*Детали и мелочи не важны, т.к. это всего лишь "скрипт"

В отношении [[Pawn]] (ранее известный как [[Small]]), особенно, ничто из вышеперечисленного верно. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

=== Термины ===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

=== Всегда запоминайте результаты ===
Рассмотрим следующий пример:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
В жизни такой участок кода не слишком ресурсоемкий, однако на его примере вполне эффектно можно рассмотреть метод оптимизации плагина. Когда компилятор генерирует псевдокод для исполнения непосредственно интерпретатором, он будет выглядеть примерно так:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Заметили проблему? Мы вызвали функцию <tt>get_user_team</tt> два лишних раза. Возвращаемый результат этих функций не будет меняться, поэтому нам следует его запомнить однократно. Теперь сравните:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Компилятор в этот раз сгенерирует следующий псевдокод:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
Если бы функция <tt>get_user_team</tt> была ресурсоемкой операцией, мы бы вычисляли результат каждый раз при выполненнии условия <tt>if</tt>.

=== Switch вместо If ===
Если возможно, лучше использовать <tt>switch</tt> вместо <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

=== Сравнение глобальных и локальных переменных, переменные в циклах ===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

===Static vs Global===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

===Constant variables===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

Оптимизация Плагинов (AMX Mod X Scripting)

2008-11-10T08:00:44Z

Simon Logic: /* Switch instead of If */

[[Category:Ru:Scripting (AMX Mod X)]]
== Введение ==
[[Admin-Mod]] и [[AMX Mod X]] стали очень поплулярными из-за используемого в них скриптового языка, который прост в изучении. Однако, словосочетание "скриптовый язык" обычно ассоциируется со следующими устойчивыми понятиями:
*Невозможно сделать его быстрее
*Он прекомпилируемый, значит уже быстрый в исполнении
*Детали и мелочи не важны, т.к. это всего лишь "скрипт"

В отношении [[Pawn]] (ранее известный как [[Small]]), особенно, ничто из вышеперечисленного верно. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

=== Термины ===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

=== Всегда запоминайте результаты ===
Рассмотрим следующий пример:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
В жизни такой участок кода не слишком ресурсоемкий, однако на его примере вполне эффектно можно рассмотреть метод оптимизации плагина. Когда компилятор генерирует псевдокод для исполнения непосредственно интерпретатором, он будет выглядеть примерно так:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Заметили проблему? Мы вызвали функцию <tt>get_user_team</tt> два лишних раза. Возвращаемый результат этих функций не будет меняться, поэтому нам следует его запомнить однократно. Теперь сравните:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Компилятор в этот раз сгенерирует следующий псевдокод:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
Если бы функция <tt>get_user_team</tt> была ресурсоемкой операцией, мы бы вычисляли результат каждый раз при выполненнии условия <tt>if</tt>.

=== Switch вместо If ===
Если возможно, лучше использовать <tt>switch</tt> вместо <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

===Global vs Local and Variables in Loops===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

===Static vs Global===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

===Constant variables===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

AMX Mod X

2008-11-08T13:17:07Z

Simon Logic: /* Feature List */

:{{owned_project|project=AMX Mod X|website=www.amxmodx.org}}
==Introduction==
AMX Mod X is a [[Metamod]] plugin for [[Half-Life 1]]. It provides comprehensive scripting for the game engine and its mods. Scripts can intercept network messages, log events, commands, client commands, set cvars, modify entities, and more. AMX Mod X also has a system for extending native scripting through [[AMX Mod X Modules|modules]], leading to outside support for things like MySQL and Sockets. The AMX Mod X scripting language is called [[Pawn]] (formerly "Small"), and is officially maintained by [http://www.compuphase.com/ ITB CompuPhase].

==Feature List==
*Creating client and server-side commands and variables
*Default and customizable server administration tools
**Kicking/Banning
**Slot Reservation
**Text file or MySQL enabled admin system
**Voting
**Management Commands (chat, map changing, cvar changing, etc)
**Flood Protection
**Weapon Restriction
**Statistics
*Scriptability through large function library
**Inter-plugin communication
**Event listening
**Network message hooking
**Entity and engine modification
**Gamedll and engine function call hooking
**Sockets
**Mod-specific extra support for:
***Counter-Strike, Condition Zero
***Day of Defeat
***Natural Selection
***Team Fortress Classic
***The Specialists
***Earth's Special Forces
**Regular Expressions
**Menu Creation
**Debugger
*Modularity
**Comprehensive M/DK for interacting with scripts
**Easily attach and use Metamod
**Plug 'n Use - MDK requires almost no modification to compile
**Written in C/C++ - total flexibility
[[Image:Example.jpg]]

==History==
The original AMX Mod project started in 2002 authored by [[OLO|Aleksander "OLO" Naszko]]. While the same scripting language ([[Small]]) was used as its predecessor admin tool, [[Admin-Mod]], the style itself is very different, most likely to correct various confusing or inadequate design decisions. For example:
*Focus was on modifying the game, rather than only providing admin tools
*Easier native syntaxes
*Easier string manipulation
*Greater flexibility for hooking game events and commands
*Greater flexibility for manipulating engine/game
*Module support for developers to extend native language
*Easier syntax in general (for example, dropping semicolon requirement)

AMX Mod was originally coupled with [[dJeyL]]'s "[[MetaSmall]]", although this was eventually dropped and the two combined into one binary.

Around January of 2004, various high-ranking members of the AMX Mod community decided the project was in an inactive and dead state. Neither OLO nor dJeyL could be contacted, and [[SniperBeamer|Felix "SniperBeamer" Geyer]] decided to found a continuation project named [[AMX Mod X]].

==Milestones==
''For a full list of AMX Mod X and AMX Mod changes, see the [[AMX Mod X Changelog]].''
===0.10-alpha===
The first release of AMX Mod X presented the core new features and organization policies of the overall package, native library, and forums.

===0.16-beta===
This was the first and most widely used version of AMX Mod X considered to be stable. It contained cleaned up code, inter-plugin communication, a rewritten internal events system, and more.

===1.00===
Jumped from 0.20, AMX Mod X became a truly different product with a new, advanced module API and many code rewrites, as well as the first Metamod plugin with AMD64 support. AMX Mod X also became the project to port [[Small]] to AMD64. It also gained a very powerful subsystem and module for engine hacking called [[Fakemeta]].

===1.50===
AMX Mod X followed the renaming of [[Small]] to [[Pawn]] by [[CompuPhase]]. It also added dynamic natives and featured a new debugger.

==Development Team==
===Original===
The AMX Mod X development team, founded by SniperBeamer, was:
*[[SniperBeamer|Felix "SniperBeamer" Geyer]] - Manager, Plugins/Documentation Maintainer, Web Dev
*[[PM OnoTo|Pavol "PM OnoTo" Marko]] - Lead Developer, Core/VM/Compiler Maintainer
*[[User:BAILOPAN|David "BAILOPAN" Anderson]] - General Development, Engine Module, Release Technician
*[[Johnny Got His Gun|Johnny "JGHG" Bergström]] - Cstrike module, Fun module
*[[SidLuke|Lukasz "SidLuke" Wlasinski]] - Stats modules and extra mod support (TFC, DoD, TFC, TS) ''note - SidLuke joined Jul 17, 2005

===Current===
After 1.0 (Nov 15, 2004), the AMX Mod X development team informally disbanded. On January 4, 2006, the development team was officially restructured to continue to maintain and improve AMX Mod X.
*[[User:BAILOPAN|David "BAILOPAN" Anderson]] - Manager, Core/VM/Compiler Maintainer, Release Technician
*[[User:Basic-Master|Christian "Basic-Master" Hammacher]] - AMXX Studio, AMXX Installer, GabenMod
*[[User:faluco|Borja "faluco" Ferrer]] - General Maintenance/Development, Multi-Lingual Maintenance
*[[User:Damaged Soul|Scott "Damaged Soul" Ehlert]] - General Maintenance/Development
*[[User:sawce|Steve "sawce" Dudenhoeffer]] - General Maintenance/Development

==Documentation==
For full documentation on AMX Mod X, see [[AMX Mod X Documentation]].

==The Future==
AMX Mod X is, for the most part, a finished product. The future holds maintenance, optimizing, further expanding the community as possible, and bug fixing. Features will also usually be added on request.

==License==
AMX Mod X is licensed under the [[GNU General Public License]], the parent license of [[Metamod]]. AMX Mod X also requires that plugins be licensed under the GPL, unless you are granted an [[AMX Mod X License Exception]].

==External Links==
*[http://www.amxmodx.org/ The AMX Mod X Website]
*[http://www.metamod.org/ The Metamod Website]
*[http://www.amxmod.net/ The Original AMX Mod Website]
*[http://www.amxmodx.org/forums AMX Mod X Forums]

[[Category:AMX Mod X]]

Оптимизация Плагинов (AMX Mod X Scripting)

2008-11-07T16:24:28Z

Simon Logic: /* Always Save Results */

[[Category:Ru:Scripting (AMX Mod X)]]
== Введение ==
[[Admin-Mod]] и [[AMX Mod X]] стали очень поплулярными из-за используемого в них скриптового языка, который прост в изучении. Однако, словосочетание "скриптовый язык" обычно ассоциируется со следующими устойчивыми понятиями:
*Невозможно сделать его быстрее
*Он прекомпилируемый, значит уже быстрый в исполнении
*Детали и мелочи не важны, т.к. это всего лишь "скрипт"

В отношении [[Pawn]] (ранее известный как [[Small]]), особенно, ничто из вышеперечисленного верно. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

=== Термины ===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

=== Всегда запоминайте результаты ===
Рассмотрим следующий пример:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
В жизни такой участок кода не слишком ресурсоемкий, однако на его примере вполне эффектно можно рассмотреть метод оптимизации плагина. Когда компилятор генерирует псевдокод для исполнения непосредственно интерпретатором, он будет выглядеть примерно так:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Заметили проблему? Мы вызвали функцию <tt>get_user_team</tt> два лишних раза. Возвращаемый результат этих функций не будет меняться, поэтому нам следует его запомнить однократно. Теперь сравните:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Компилятор в этот раз сгенерирует следующий псевдокод:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
Если бы функция <tt>get_user_team</tt> была ресурсоемкой операцией, мы бы вычисляли результат каждый раз при выполненнии условия <tt>if</tt>.

===Switch instead of If===
If you can, you should use <tt>switch</tt> cases instead of <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

===Global vs Local and Variables in Loops===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

===Static vs Global===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

===Constant variables===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

Ru:Optimizing Plugins (AMX Mod X Scripting)

2008-11-07T16:13:28Z

Simon Logic: Redirecting to Оптимизация Плагинов (AMX Mod X Scripting)

#REDIRECT [[Оптимизация Плагинов (AMX Mod X Scripting)]]

Optimizing Plugins (AMX Mod X Scripting)

2008-11-07T16:11:57Z

Simon Logic:

{{LanguageSwitch}}

==Introduction==
[[Admin-Mod]] and [[AMX Mod X]] became very popular because of their easy to use scripting language. However, the words "scripting language" come with a lot of loaded preconceptions. Most people assume that because it's scripted:
*You can't possibly make it any faster
*It's pre-compiled, so it's already quite fast
*Details don't matter, as it's only "scripting" anyway

Especially, with [[Pawn]] (formerly Small), none of these are true. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

===Terms===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

===Always Save Results===
Observe the example code snippet below:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
This is a mild example of "cache your results". When the compiler generates assembly for this code, it will (in pseudo code) generate:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Notice the problem? We have called <tt>get_user_team</tt> an extra two times than necessary. The result doesn't change, so we can save it. Observe:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Now, the compiler will only generate this:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
If <tt>get_user_team</tt> were an expensive operation (it's relatively cheap), we would have recalculated the entire result each branch of the <tt>if</tt> case.

===Switch instead of If===
If you can, you should use <tt>switch</tt> cases instead of <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

===Global vs Local and Variables in Loops===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

===Static vs Global===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

===Constant variables===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

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

Optimizing Plugins (AMX Mod X Scripting)

2008-11-07T16:11:29Z

Simon Logic: added langswitch template

{{LanguageSwitch}}
==Introduction==
[[Admin-Mod]] and [[AMX Mod X]] became very popular because of their easy to use scripting language. However, the words "scripting language" come with a lot of loaded preconceptions. Most people assume that because it's scripted:
*You can't possibly make it any faster
*It's pre-compiled, so it's already quite fast
*Details don't matter, as it's only "scripting" anyway

Especially, with [[Pawn]] (formerly Small), none of these are true. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

===Terms===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

===Always Save Results===
Observe the example code snippet below:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
This is a mild example of "cache your results". When the compiler generates assembly for this code, it will (in pseudo code) generate:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Notice the problem? We have called <tt>get_user_team</tt> an extra two times than necessary. The result doesn't change, so we can save it. Observe:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Now, the compiler will only generate this:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
If <tt>get_user_team</tt> were an expensive operation (it's relatively cheap), we would have recalculated the entire result each branch of the <tt>if</tt> case.

===Switch instead of If===
If you can, you should use <tt>switch</tt> cases instead of <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

===Global vs Local and Variables in Loops===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

===Static vs Global===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

===Constant variables===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

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

Ru:Fundamental Basics of AMX Mod X Scripting

2008-11-07T15:59:24Z

Simon Logic: Ru Fundamental Basics of AMX Mod X Scripting moved to Ru:Fundamental Basics of AMX Mod X Scripting: To accompany a langswitch template

[[Category:Russian]]
[[Category:Ru:Scripting (AMX Mod X)]]
=Фундаментальные основы AMX Mod X скриптинга=

Данная статья не дает готовых "рецептов" по [[AMX Mod X]] скриптингу, но раскрывает его фундаментальные основы. Это и типы данных, и прототипы функций и многое другое, без знания чего невозможно писать AMX Mod X плагины.

=Введение=

Прежде чем начинать писать AMX Mod X плагины, в первую очередь необходимо разобраться в основах [[Pawn]].
 Pawn – это скриптовый язык, созданный компанией [http://www.compuphase.com ITB CompuPhase]. Ранее Pawn назывался Small, но с версии 3.0 языку было решено дать более характерное название. Т.к. "pawn" в переводе с английского языка означает "пешка", можно догадаться, что основной характерной чертой данного языка является простота.
 Если вы владеете английским языком, рекомендуется ознакомиться с полным руководством по Pawn - [http://www.compuphase.com/pawn/pawn-lang.pdf Pawn The Language].
 Код плагина представляет собой текст (как правило, заключенный в файл типа *.sma), включающий множество элементов языка: комментарии, переменные, функции и др. Поэтому для оформления кода потребуется текстовый редактор. Из простейших можно выделить, например, Microsoft Notepad. Также существует AMXX-Studio – специализированый редактор для AMX Mod X плагинов, позволяющий максимально эффективно работать в соответствующей среде. Последняя версия данного редактора может быть найдена в секции [http://www.amxmodx.org/downloads.php downloads] официального сайта AMX Mod X.
 Чтобы позволить AMX Mod X выполнять код, файл с кодом необходимо откомпилировать с помощью компилятора AMXXPC (AMX Mod X Pawn Compiler). Операция компилирования преобразовывает набор текстовых инструкций в последовательность инструкций абстрактной машины (от англ. abstract machine), она же AMX, а также интерпретатор (от англ. interpreter).
 Откомпилированый код обычно помещается в файл типа *.amxx, имеющий двоичный формат. Такой файл называют AMX Mod X плагином (от англ. plugin).
 Для ознакомления с инструкциями по компилированию и установке плагинов смотрите [[Ru Compiling Plugins (AMX Mod X)]] и [[Ru Configuring AMX Mod X]].

=Pawn=

==Уровни кода==

В основе любого кода лежит уровневая структура. Причиной этому является нелинейность инструкций.
 Т.н. "нулевой уровень" или "глобальное пространство" является неотъемлемой частью любого кода. Как только вы приступаете к написанию нового кода, вы оказываетесь в его глобальном пространстве. Оно же в свою очередь будет включать в себя пространства с более низкими уровнями.
 Обычно глобальное пространство содержит всю общую информацию, которая может потребоваться в ходе выполнения кода пространствам более низкого уровня. Примером такой информации могут служить общие константы, переменные, списки, макросы.

==Комментарии==

Комментарий – это, как правило, текст информативного характера. Например, чтобы дать описание плагину можно использовать многострочный комментарий:<pawn>/* здесь вы помещаете
необходимую информацию */</pawn>Как видно из примера, многострочный комментарий ограничивается символами /* и */, отмечающими начало и конец комментария соответственно. Недопустимо открывать последующий комментарий, не закрыв при этом предыдущий.
 Примером однострочного комментария может быть:<pawn>/* ваш комментарий */</pawn>Хотя, можно упростить конструкцию:<pawn>// ваш комментарий</pawn>
 Как видно из последнего примера, комментарий начинается с двойного симовола обратного слеша //. Заканчивается такой комментарий вместе с концом текущей строки, поэтому не требует закрывающих символов. Такие комментарии могут быть только однострочными. Не обязательно комментарий должен начинаться с новой строки. Например, /* ... */ комментарий может быть расположен непосредственно в самом коде.
 Т.к. комментарии не считаются кодом, они исключаются из обработки. Данная особенность позволяет при необходимости исключать части кода путем комментирования, что может быть использовано, например, при отладке кода.

==Типы данных==

Технически основой всех типов данных в Pawn является т.н. "cell" – ячейка памяти, состоящая из последовательности определенного количества бит. Количество бит в такой ячейке постоянно для определенной платформы. Так для 32х битной платформы оно будет составлять 32, а для 64х битной – 64.
 Т.к. технически все данные не имеют отличия, для обозначения их типа применяются т.н. "тэги". Если при создании переменной тэг не указан, то переменная является целым числом:<pawn>new ivar // создана целочисленная переменная с именем "ivar"</pawn>
 Если при создании переменной ей не присваивается какое-либо конкретное значение, то переменная будет равна нулю. Таким образом, вышеприведенный пример технически соответствует:<pawn>new ivar = 0</pawn>
 Чтобы создать дробную переменную, необходимо использовать тэг "Float":<pawn>new Float:fvar</pawn>Переменная fvar также будет равна нулю, но ввиду соответствия типу данных это будет 0.0, т.е. технический аналог примера будет:<pawn>new Float:fvar = 0.0</pawn>Таким образом, мы обеспечиваем типовое соответствие "левой" и "правой" части.
 Одним из особых типов данных является т.н. "булевые" переменные, которые технически могут иметь только два значение, логически интерпретируемые как "истина" и "ложь" (true и false). Чтобы создать булевую переменную, необходимо использовать тэг "bool":<pawn>new bool:bvar</pawn>Т.к. численно false является нулем, то технический аналог примера будет выглядеть как:<pawn>new bool:bvar = false</pawn>
 Примечание: чтобы запретить изменение значения переменной, необходимо использовать атрибут const, например:<pawn>new const var = 1</pawn>
 Pawn также позволяет создавать массивы данных, представляющие собой набор значений определенного типа. Так примером простого массива, содержащего два целочисленных значения будет:<pawn>new array[2]</pawn>Технически данный пример выглядит следующим образом:<pawn>new array[2] = {0, 0}</pawn>Технические аналоги для Float и bool массивов выглядят как:<pawn>new Float:farray[2] = {0.0, 0.0}
new bool:barray[2] = {false, false}</pawn>
 Также существует особый тип данных, называемый "строка", технически являющийся массивом целых чисел. Каждое целое число в строковом массиве соответствует числовому ASCII коду символа. Например, код 32 соответствует пробелу. Таким образом,<pawn>new string[3] = {'h', 'i', '^0'}</pawn>является символьным представлением строкового массива<pawn>new string[3] = "hi"</pawn>Обратите внимание на наличие специального символа '^0'. Это обязательный элемент строки, указывающий на ее окончание (численно равен нулю).
 Также Pawn поддерживает многоуровневые массивы, например:<pawn>new multiarray[2][2]</pawn>Технически такой массив равен:<pawn>new multiarray[2][2] = {{0, 0}, {0, 0}}</pawn>Максимальное количество уровней массива равно 3.
 Для любого явно заданного массива его размер может не указываться, например:<pawn>new array[] = {1, 2, 3} // размер массива равен 3
new string[] = "hello" // размер массива равен 6, т.к. помимо 5 символов также включает в себя символ окончания строки '^0'</pawn>
 Чтобы инициализировать все элементы массива каким-либо конкретным значением, можно использовать символ троеточия ..., например:<pawn>new bool:is_active[16] = {true, ...}</pawn>

==Прекомпиляция==

На начальной стадии компилирования Pawn компилятор обрабатывает т.н. "статическую" часть кода. К ней можно отнести директивы, глобальные константы, списки и др.
 Директивы являются специальными инструкциями компилятора. Одна из самых широко используемых директив – это "include". Пример ее использования может быть следующим:<pawn>#include <amxmodx></pawn>Директива как бы "влаживает" содержимое указанного файла в текущую позицию. В данном случае указывается файл amxmodx.inc, который обычно расположен в amxmodx\scripting\include директории, и декларирует основные AMX Mod X функции.
 Другая директива, позволяющая конструировать т.н. "макросы", имеет название "define". Макрос удобен тем, что способен заменять простые блоки кода. Один из простейших макросов – это т.н. "макроконстанта", например:<pawn>#define VALUE 1</pawn>В названиях макросов принято использовать буквы только верхнего регистра.
 Нетехническим аналогом вышеприведенной макроконстанты является т.н. "глобальная константа":<pawn>stock const value = 1</pawn>stock атрибут позволяет не включать константу в плагин, если она не используется в коде.
 Т.н. "список" – это набор нумерованных элементов определенного типа. Например:<pawn>enum {zero, one, two} // соответствует 0, 1, 2
enum {elem1 = 1, elem2, elem3} // соответствует 1, 2, 3
enum steeps {steep1 = 10, steep2 = 20} // соответствует 10, 20</pawn>Тип списка (в вышеприведенном примере типом списка является steeps) – необязательный атрибут, по сути является тэгом, указывающим тип элементов, поэтому следующий пример является верным:<pawn>new steeps:steep = steep2</pawn>

==Функции==

Существует несколько типов функций.
*т.н. "'''обычная'''" – обычно т.н. "вспомогательная" функция; может быть вызвана непосредственно только другими функциями данного плагина; не может быть вызвана непосредственно AMX Mod X либо его модулями.
*'''public''' – обычно функция, вызываемая непосредственно AMX Mod X либо его модулями; может быть также вызвана непосредственно другими функциями данного плагина.
*'''native''' – функция, имеющая т.н. "глобальный" характер; может быть вызвана AMX Mod X плагинами.
*'''forward''' - функция, имеющая т.н. "глобальный" характер; при наличии в плагине public функции с соответствующим именем функция будет вызываться AMX Mod X или его модулями.
*'''stock''' – обычно функция, состоящая в т.н. "библиотеке" функций; не включается в плагин, если не используется в коде.
 В общем виде заголовок, а также прототип любой функции условно выглядит следующим образом (символами треуголных скобок <> ограничены обязательные элементы, символами квадратных скобок [] ограничены необязательные элементы, которые могут быть опущены в определенных случаях):<pawn>[type] [tag]:<name>([[param1], [param2], ..., [paramN]])</pawn>, где
*[type] – соответствует типу функции (для обычной функции тип не указывается)
*[tag] – соответствует типу данных возвращаемого результата функции
*<name> - соответствует имени функции
*([...]) – соответствует набору параметров функции; количество параметров может быть от нуля (параметры отсутствуют) до N, где N – целое положительное число
 За заголовком функции следует т.н. "тело" функции, ограниченное символами фигурных скобок {}. Таким образом, примером простейшей функции является:<pawn>function()
{
// это пустое тело функции, имеющей имя "function"
}</pawn>Технически данная функция не выполняет никаких действий, т.к. в своем теле содержит только комментарий. Обратите внимание, что комментарий как бы сдвинут вправо относительно заголовка функции. В данном случае функция инициализирует новый уровень кода. Каждый уровень кода в целях удобочитаемости принято оформлять с соответствующим отступом. Чем более низкий уровень кода, тем больший отступ он будет иметь. Обычно в качестве отступа принято использовать символ табуляции, т.к. многие редакторы позволяют задавать видимую ширину табулированого отступа.
 Существует два способа передачи параметров функции. Т.н. "основной" способ заключается в том, что при передаче данные дублируются путем создания соответствующих копий в памяти. Т.н. способ передачи параметров "по ссылке" (от англ. by reference) состоит в том, что данные передаются "как есть", т.е. их дублирования не осуществляется, что позволяет функции изменять оригинальные данные непосредственно.
 Для параметров функции все типы массивов, в том числе и строковые, могут передаваться исключительно по ссылке. Передача остальных данных по умолчанию осуществляется основным способом. Чтобы произвести передачу параметра функции по ссылке, в заголовке функции перед параметром необходимо добавлять символ амперсанда &, например:<pawn>function(&Float:fparam)</pawn>
 Параметры функции могут иметь значения по умолчанию, например:<pawn>function(param = 1)</pawn>Таким образом, чтобы вызвать данную функцию с параметром по умолчанию, параметр можно не указывать:<pawn>function()</pawn>Также в таких случаях можно использовать символ подчеркивания _:<pawn>function(_)</pawn>
 Чтобы запретить функции изменение передаваемых данных, необходимо использовать атрибут const, например:<pawn>function(const array[])</pawn>Таким образом, можно утверждать, что в данном случае целью функции не является изменение данных массива, чего нельзя утверждать о следующей функции:<pawn>swaparray(array[2])</pawn>Исходя из названия функции, типа параметра, его размера и отсутствия запрета на изменение, можно сделать предположение о том, что данная функция меняет элементы массива местами.
 Важным свойством функции является способность возвращать результат, значение которого имеет определенный тип, например:<pawn>bool:is_true()
{
return true
}</pawn>
 Чтобы указать допустимые типы параметра функции, в заголовке функции перед параметром необходимо добавлять конструкцию, которая условно выглядит как {tag1, tag2, ..., tagN}:, т.е. представляет собой набор тэгов, количество которых может быть от одного до N, где N – целое положительное число, например:<pawn>get_integer({bool, _}:value)
{
return _:value // возвращается значение типа "целое число"
}</pawn>Смысл вышеприведенной функции заключается в том, что она принимает параметр как типа "целое число", так и булевого типа, в результате возвращая значение параметра в числовой форме.

=AMX Mod X=

==Функции==

При написании AMX Mod X плагинов важно уметь понимать назначение и принцип действия AMX Mod X функций.
 Прототипы функций, а также используемые ими константы и списки заключены в файлы типа *.inc, т.н. "инклуды" (от англ. include), которые обычно расположены в amxmodx\scripting\include директории.
 Иногда одни инклуды включают в себя другие. Так основные AMX Mod X функции (т.н. функции AMX Mod X "ядра") продекларированы в файле amxmodx.inc, который также включает векторные и другие инклуды, декларирующие функции, константы и списки, также имеющие непосредственное отношение к AMX Mod X ядру.
 Одной из основных функций AMX Mod X является forward функция plugin_init. Если в коде плагина имеется public функция plugin_init, она будет вызвана AMX Mod X после загрузки карты на сервере. Обычно в plugin_init регистрируют сам плагин, его команды, переменные и т.п.
 Плагин регистрируют с помощью native функции register_plugin. Т.к. прототип register_plugin соответствует:<pawn>native register_plugin(const plugin_name[], const version[], const author[])</pawn>, можно понять, что в качестве параметров функция принимает три строковых массива, соответствующих названию плагина, номеру его версии и автору плагина.
 Итак, примером простого AMX Mod X плагина является:<pawn>#include <amxmodx>

public plugin_init()
{
register_plugin("Test", "0.1", "VEN")
}</pawn>По сути данный плагин не выполняет каких-либо действий, но регистрирует себя в AMX Mod X с указанными данными.

==Системы функционирования==

AMX Mod X предоставляет большое количество определенных систем функционирования. Так одна из основных систем – это система контроля уровней доступа. Здесь имеют место соответствующие функции, например get_user_flags, а также константы стандартных уровней доступа типа ADMIN_*.
 Система регистрирования и контроля консольных команд также "пересекается" с системой контроля уровней доступа и использует такие функции, как например register_concmd и cmd_access.
 Также существует множество других систем, среди которых имеется система регистрирования и контроля серверных консольных переменных (англ.: Server CVars), клиентских меню и др.
 Как правило, системы регистрирования используют т.н. "handle" (или "hook") функции, которые вызываются системой в необходимый момент.
 Так после регистрирования консольной команды "action":<pawn>register_concmd("action", "action_handler")</pawn>при исполнении данной команды из консоли сервера или клиента система попытается найти и выполнить public функцию action_handler.

==Система строкового форматирования==

Многие AMX Mod X функции используют систему строкового форматирования. Например, это все *_print функции.
 Такие функции принимают практически неограниченное количество параметров, которые используются при форматировании соответствующей строковой конструкции. Для наглядности рассмотрим пример:<pawn>server_print("Formatted string: %d %f %s %c", 1, 1.234567, "hello", '!')</pawn>Функция server_print отформатирует строковую конструкцию "Formatted string: %d %f %s %c", используя переданные параметры, и выведет в серверной консоли строку:<pawn>Formatted string: 1 1.234567 hello !</pawn>Таким образом, %d, %f, %s, %c – специальные элементы, используемые для форматирования целого числа, дробного числа, строки и символа соответственно.
 Опасно при использовании функций, поддерживающих форматирование, передавать строковую переменную непосредственно в параметр строковой конструкции, например:<pawn>server_print(string)</pawn>Безопасный вариант выглядит, следующим образом:<pawn>server_print("%s", string)</pawn>
 Т.к. символ процента % является, т.н. "специальным символом", для его форматирования в строковой конструкции необходимо использовать двойной символ процента %%, например:<pawn>server_print("This is a single symbol of percent: %%")</pawn>выведет в серверной консоли:<pre>This is a single symbol of percent: %</pre>
 Также существует т.н. "контрольный символ" (от англ. control character), позволяющий использовать т.н. "специальные символы форматирования". Контрольным символом по умолчанию является символ ^, который может быть изменен директивой pragma ctrlchar, например:<pre>#pragma ctrlchar '\'</pre>изменит контрольный символ на \.
 Примеры некоторых специальных символов форматирования приведены ниже:
*^t – табуляция
*^n – новая строка
*^xHH – символ, представленный в шестнадцатиричном формате, где HH – двойное число, представленное в шестнадцатиричном формате

Ru Fundamental Basics of AMX Mod X Scripting

2008-11-07T15:59:24Z

Simon Logic: Ru Fundamental Basics of AMX Mod X Scripting moved to Ru:Fundamental Basics of AMX Mod X Scripting: To accompany a langswitch template

#REDIRECT [[Ru:Fundamental Basics of AMX Mod X Scripting]]

Ru:Small

2008-11-07T15:58:06Z

Simon Logic:

[[Category:Ru:Scripting (AMX Mod X)]]
Small - это бывшее название скриптового языка [[Pawn Tutorial|Pawn]], разработанного фирмой [http://www.compuphase.com/ ITB CompuPhase]. Имя было изменено, начиная с версии 3.0 в июле 2005 года, чтобы сделать его более уникальным.

Small

2008-11-07T15:57:30Z

Simon Logic: + LanguageSwitch

[[Category:Scripting (AMX Mod X)]]
{{LanguageSwitch}}
Small was the former name of the [[Pawn Tutorial|Pawn]] scripting language provided by [http://www.compuphase.com/ ITB CompuPhase]. The name was changed with version 3.0 in July, 2005, to make the name more unique.

Ru:Small

2008-11-07T15:56:36Z

Simon Logic: New page: Category:Ru:Scripting (AMX Mod X) Small - это бывшее наимнование скриптового языка Pawn, разработанного фирмой...

[[Category:Ru:Scripting (AMX Mod X)]]
Small - это бывшее наимнование скриптового языка [[Pawn Tutorial|Pawn]], разработанного фирмой [http://www.compuphase.com/ ITB CompuPhase]. Имя было изменено, начиная с версии 3.0 в июле 2005 года, чтобы сделать его более уникальным.

Оптимизация Плагинов (AMX Mod X Scripting)

2008-11-07T15:48:55Z

Simon Logic: /* Introduction */

[[Category:Ru:Scripting (AMX Mod X)]]
== Введение ==
[[Admin-Mod]] и [[AMX Mod X]] стали очень поплулярными из-за используемого в них скриптового языка, который прост в изучении. Однако, словосочетание "скриптовый язык" обычно ассоциируется со следующими устойчивыми понятиями:
*Невозможно сделать его быстрее
*Он прекомпилируемый, значит уже быстрый в исполнении
*Детали и мелочи не важны, т.к. это всего лишь "скрипт"

В отношении [[Pawn]] (ранее известный как [[Small]]), особенно, ничто из вышеперечисленного верно. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

=== Термины ===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

===Always Save Results===
Observe the example code snippet below:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
This is a mild example of "cache your results". When the compiler generates assembly for this code, it will (in pseudo code) generate:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Notice the problem? We have called <tt>get_user_team</tt> an extra two times than necessary. The result doesn't change, so we can save it. Observe:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Now, the compiler will only generate this:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
If <tt>get_user_team</tt> were an expensive operation (it's relatively cheap), we would have recalculated the entire result each branch of the <tt>if</tt> case.

===Switch instead of If===
If you can, you should use <tt>switch</tt> cases instead of <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

===Global vs Local and Variables in Loops===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

===Static vs Global===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

===Constant variables===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

Оптимизация Плагинов (AMX Mod X Scripting)

2008-11-07T15:42:16Z

Simon Logic: fixed category

[[Category:Ru:Scripting (AMX Mod X)]]
==Introduction==
[[Admin-Mod]] and [[AMX Mod X]] became very popular because of their easy to use scripting language. However, the words "scripting language" come with a lot of loaded preconceptions. Most people assume that because it's scripted:
*You can't possibly make it any faster
*It's pre-compiled, so it's already quite fast
*Details don't matter, as it's only "scripting" anyway

Especially, with [[Pawn]] (formerly Small), none of these are true. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

===Terms===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

===Always Save Results===
Observe the example code snippet below:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
This is a mild example of "cache your results". When the compiler generates assembly for this code, it will (in pseudo code) generate:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Notice the problem? We have called <tt>get_user_team</tt> an extra two times than necessary. The result doesn't change, so we can save it. Observe:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Now, the compiler will only generate this:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
If <tt>get_user_team</tt> were an expensive operation (it's relatively cheap), we would have recalculated the entire result each branch of the <tt>if</tt> case.

===Switch instead of If===
If you can, you should use <tt>switch</tt> cases instead of <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

===Global vs Local and Variables in Loops===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

===Static vs Global===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

===Constant variables===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

Ru Compiling Plugins (AMX Mod X)

2008-11-07T15:40:11Z

Simon Logic: redirect

#REDIRECT [[Ru:Compiling Plugins (AMX Mod X)]]

Ru:Compiling Plugins (AMX Mod X)

2008-11-07T15:39:40Z

Simon Logic: New page: Category:Russian Category:Ru:Scripting (AMX Mod X) Просмотреть оригинал статьи (англ.): Compiling Plugins (AMX Mod X) =Компилировани...

[[Category:Russian]]
[[Category:Ru:Scripting (AMX Mod X)]]
Просмотреть оригинал статьи (англ.): [[Compiling Plugins (AMX Mod X)]]

=Компилирование плагинов=

Эта статья описывает, как компилировать [[AMX Mod X]] плагины из [[Ru:source code|исходного кода]] (.sma).

Для всех случаев вы должны поместить .sma файл в директорию addons/amxmodx/scripting.

=Windows=

==Метод перетаскивания==
#Перетащите .sma файл на "compile.exe".
#Откомпилированный .amxx файл будет находиться в директории compiled.

==Компилирование всех плагинов==
#Дважды щелкните на compile.exe, чтобы откомпилировать все плагины и поместить их в директорию compiled.
==Командная строка==
#Зайдите в "Пуск", "Выполнить", введите "cmd", нажмите Ok.
#Используйте cd, чтобы сменить директорию, например: <pre>cd c:\hlserver\cstrike\addons\amxmodx\scripting</pre>
#Используйте amxxpc, чтобы откомпилировать плагин: <pre>amxxpc.exe myplugin.sma</pre>
#Откомпилированный плагин будет в этой же директории.

=Linux=

Сперва перейдите в scripting директорию в вашей оболочке следующим образом: <pre>cd addons/amxmodx/scripting</pre>

==Компилирование всех плагинов==
#Запустите скрипт compile.sh одним из способов: <pre>sh compile.sh</pre> или <pre>chmod +x compile.sh
./compile.sh</pre>

==Компилирование одиночного плагина==
#Запустите amxxpc, например: <pre>./amxxpc myplugin.sma</pre>
#Откомпилированный плагин будет в этой же директории.

Category:Ru:Scripting (AMX Mod X)

2008-11-07T15:32:51Z

Simon Logic:

[[Category:Ru:AMX Mod X]]

[[AMX Mod X]] позволяет расширять функциональность игры плагинами. Ниже приведен список некторых статей, которые помогут вам писать плагины используя [[Pawn]] (ранее называвшийся [[Small]]).

Ru:Main Page

2008-11-06T10:34:38Z

Simon Logic: /* Руководство по Subversion */

[[Category:Russian]]
__NOTOC__
Добро пожаловать в AMWiki, единый и совместный проект документаций AlliedModders, который объединяет такие проекты, как [[AMX Mod X]], [[Metamod:Source]], и [[SourceMod]].

С чего вам начать? Смотрите ниже, для получения общего представления. Зайдите в [[Help:Contents|Справка]] и ознакомтесь с основными принципами и правилами wiki. Или, если вы что-то ищите, просто используйте поиск в левом меню сайта!

=Основные Статьи=

==Разработка SourceMod==
[[:Category:SourceMod Development|SourceMod]] вышел! Хотите узнать подробнее о разработке плагинов и расширений? Посетите [[:Category:SourceMod Development|Категорию Разработки SourceMod]] исчерпывающих статей о SourceMod, мощи C++ и Pawn API.

==Изменения AMX Mod X: 1.8.0==
Выпуск [[AMX Mod X]] 1.8.0 состоялся и содержит ряд интересных изменений, таких как динамическое количество администраторов, сущности функций перехвата и динамические массивы. Каждый, кто используюет AMX Mod X, должен свериться с новой статьей, [[AMX_Mod_X_1.8.0_Changes|AMX Mod X 1.8.0]].

==Руководство по Subversion==
AlliedModders перешел от CVS к Subversion, которое лучше организует исходный код. Заинтерисованы его работой и хотите скачать с SVN репозитория? Просмотрите [[Subversion Tutorial|Руководство по Subversion]]!

{| cellspacing="0" style="border:0px;"
|- valign="top"
|
{| width="100%"
|-
|

=Проекты=
{| width="100%" cellpadding="5"
|- class="t2th"
| '''SourceMod'''
|- class="t2td"
|[[Image:Sm_small.gif|left]] [[SourceMod]] - оптимизированая и широко расширяемая скриптами среда для [[Half-Life 2]].
* [[:Category:SourceMod Documentation|Документация]]
* [[:Category:SourceMod Development|Разработка]]
|}
{| width="100%" cellpadding="5"
|- class="t2th"
| '''AMX Mod X'''
|- class="t2td"
|[[Image:Amxxsmall.gif|left]] [[AMX Mod X]] - мощная, расширяемая скриптами среда для [[Half-Life 1]].
* [[:Category:Documentation (AMX Mod X)|Документация]]
* [[:Category:Scripting (AMX Mod X)|Скриптинг]]
|}
{| width="100%" cellpadding="5"
|- class="t2th"
| '''Metamod:Source'''
|- class="t2td"
|[[Image:Mms.jpg|left]][[Metamod:Source]], мощный API плагин для [[Half-Life 2]], функции перехвата интерфейсов и универсальный API плагин.
* [[:Category:Metamod:Source Documentation|Документация]]
* [[:Category:Metamod:Source Development|Разработка]]
|}
|}
|
{| width="100%"
|-
|

=Новости=
{| cellpadding="6"
|- class="t2th"
| AMX Mod X 1.8.1
|- class="t2td"
| ''2008-08-16'': Выпущена новая версия [[AMX Mod X]], отличается в основном отсутствием большого количества ошибок. Смотрите [[Ru:AMX Mod X 1.8.1 Changes|Изменения AMX Mod X: 1.8.1]].
|}

{| cellpadding="6"
|- class="t2th"
| Metamod:Source 1.4.1
|- class="t2td"
| ''2007-05-16'': Новая версия [[Metamod:Source|SourceMM]] была выпущена как большой патч исправляющий ошибки в 1.4 версиях. Посетите [http://www.sourcemm.net/ домашнюю страницу] для более подробной информации.
|}

{|
{| cellpadding="6"
|- class="t2th"
| Сборки SourceMod
|- class="t2td"
| ''2007-03-17'': [[SourceMod]] теперь публично доступна ночными сборками. Заинтерисованы в разработке? Смотрите [[SourceMod SDK]] и [http://www.sourcemod.net/ сайт SourceMod].
|}

|}

|}

{{LanguageSwitch}}

Ru:Main Page

2008-11-06T10:33:17Z

Simon Logic: /* Изменения AMX Mod X: 1.8.0 */

[[Category:Russian]]
__NOTOC__
Добро пожаловать в AMWiki, единый и совместный проект документаций AlliedModders, который объединяет такие проекты, как [[AMX Mod X]], [[Metamod:Source]], и [[SourceMod]].

С чего вам начать? Смотрите ниже, для получения общего представления. Зайдите в [[Help:Contents|Справка]] и ознакомтесь с основными принципами и правилами wiki. Или, если вы что-то ищите, просто используйте поиск в левом меню сайта!

=Основные Статьи=

==Разработка SourceMod==
[[:Category:SourceMod Development|SourceMod]] вышел! Хотите узнать подробнее о разработке плагинов и расширений? Посетите [[:Category:SourceMod Development|Категорию Разработки SourceMod]] исчерпывающих статей о SourceMod, мощи C++ и Pawn API.

==Изменения AMX Mod X: 1.8.0==
Выпуск [[AMX Mod X]] 1.8.0 состоялся и содержит ряд интересных изменений, таких как динамическое количество администраторов, сущности функций перехвата и динамические массивы. Каждый, кто используюет AMX Mod X, должен свериться с новой статьей, [[AMX_Mod_X_1.8.0_Changes|AMX Mod X 1.8.0]].

==Руководство по Subversion==
AlliedModders перешел от CVS к Subversion, которые лучше организуют исходный код. Заинтерисованы работой, и хотите скачать с SVN репозитория? Просмотрите [[Subversion Tutorial|Руководство по Subversion]]!

{| cellspacing="0" style="border:0px;"
|- valign="top"
|
{| width="100%"
|-
|
=Проекты=
{| width="100%" cellpadding="5"
|- class="t2th"
| '''SourceMod'''
|- class="t2td"
|[[Image:Sm_small.gif|left]] [[SourceMod]] - оптимизированая и широко расширяемая скриптами среда для [[Half-Life 2]].
* [[:Category:SourceMod Documentation|Документация]]
* [[:Category:SourceMod Development|Разработка]]
|}
{| width="100%" cellpadding="5"
|- class="t2th"
| '''AMX Mod X'''
|- class="t2td"
|[[Image:Amxxsmall.gif|left]] [[AMX Mod X]] - мощная, расширяемая скриптами среда для [[Half-Life 1]].
* [[:Category:Documentation (AMX Mod X)|Документация]]
* [[:Category:Scripting (AMX Mod X)|Скриптинг]]
|}
{| width="100%" cellpadding="5"
|- class="t2th"
| '''Metamod:Source'''
|- class="t2td"
|[[Image:Mms.jpg|left]][[Metamod:Source]], мощный API плагин для [[Half-Life 2]], функции перехвата интерфейсов и универсальный API плагин.
* [[:Category:Metamod:Source Documentation|Документация]]
* [[:Category:Metamod:Source Development|Разработка]]
|}
|}
|
{| width="100%"
|-
|

=Новости=
{| cellpadding="6"
|- class="t2th"
| AMX Mod X 1.8.1
|- class="t2td"
| ''2008-08-16'': Выпущена новая версия [[AMX Mod X]], отличается в основном отсутствием большого количества ошибок. Смотрите [[Ru:AMX Mod X 1.8.1 Changes|Изменения AMX Mod X: 1.8.1]].
|}

{| cellpadding="6"
|- class="t2th"
| Metamod:Source 1.4.1
|- class="t2td"
| ''2007-05-16'': Новая версия [[Metamod:Source|SourceMM]] была выпущена как большой патч исправляющий ошибки в 1.4 версиях. Посетите [http://www.sourcemm.net/ домашнюю страницу] для более подробной информации.
|}

{|
{| cellpadding="6"
|- class="t2th"
| Сборки SourceMod
|- class="t2td"
| ''2007-03-17'': [[SourceMod]] теперь публично доступна ночными сборками. Заинтерисованы в разработке? Смотрите [[SourceMod SDK]] и [http://www.sourcemod.net/ сайт SourceMod].
|}

|}

|}

{{LanguageSwitch}}

Ru Using New Menu System

2008-11-06T10:31:00Z

Simon Logic: redirect

#REDIRECT [[Ru:Using_New_Menu_System]]

Ru:Using New Menu System

2008-11-06T10:30:21Z

Simon Logic: New page: Category:Russian Category:Ru:Scripting (AMX Mod X) = Введение = Это статья поможет вам разобраться в новой системе меню. = ...

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

= Введение =
Это статья поможет вам разобраться в новой системе меню.

= Урок по созданию меню =
Давайте попробуем воспользоваться новой системмой меню. Мы пройдем через этоу простую инструкцию и создадим простое голосование смены карты.

=== Заголовочные файлы ===
Как обычно мы начинаем с добавления необходимых заголовочных файлов
<pawn>
#include <amxmodx>
</pawn>

=== Глобальные переменные ===
<pawn>
new g_Menu; // Переменная обработки главного меню
new g_Votes[3]; // Сохраняем голосования Да как 1, No как 2
</pawn>

Здесь мы создали 2 глобальные переменные. Одна будет содержать указатель на ваше меню, другая будет хранить результаты голосования. Голоса 'За' будут сохранены в g_Votes[1], а 'Против' - в g_Votes[2]. g_Votes[0] - не используется(?).

=== Регистрируем Плагин и Меню ===
<pawn>
public plugin_init()
{
// Регистрируем ваш плагин
register_plugin("Vote Menu","1.0","Freecode");

// Регистрируем меню смены карты
g_Menu = menu_create("Change Level?","menu_handle");

register_clcmd("amx_startvote","startvote",ADMIN_CFG,"Gaben");

// Теперь нам надо создать наше меню
build_menu();
}
</pawn>

Lets break this down.

*Регистрирует ваш плагин
<pawn>register_plugin("Vote Menu","1.0","Freecode");</pawn>

*g_Menu - Указатель на ваше меню. Это будет установлено после вызова menu_create.
<pawn>g_Menu = menu_create("Change Level?","menu_handle");

//menu_create ( title[], handler[], ml=0 )
//title[] - Заголовок меню
//handler[] - Эта функция будет вызвана когда будет нажата клавиша в вашем меню.
</pawn>

* Мы добавили эту команду. Она начинает ваше голосование.
<pawn>register_clcmd("amx_startvote","startvote",ADMIN_CFG,"Gaben");
</pawn>

* Это вызов функции. build_menu() функция создает ваше меню.
<pawn>build_menu();</pawn>

=== Создение меню ===
Конструирование заключается в добавлении пунктов в ваше меню. Прежде чем начали добавлять пункты, мы должны взглянуть на
menu_additem .
<pawn>menu_additem ( menu, const name[], const command[], paccess=0, callback=-1 )</pawn>
* menu - указатель на меню. Это указывает menu_additem меню к которому нужно добавить пункты.
* const name[] - имя пункта меню. Это то что будет показано в меню.
* const command[] - информация пункта меню.

Теперь давайте приступим к созданию нашего меню. Как уже говорилось, это простое голосование смены карты. Так что нам надо всего 2 пункта меню. А именно "Да" и "Нет".
<pawn>build_menu()
{
menu_additem(g_Menu, "Yes", "1");
menu_additem(g_Menu, "No", "2");

menu_setprop(g_Menu, MPROP_PERPAGE, 0);
}</pawn>
*<tt>Примечание</tt>
** Как вы можете видеть вместо command[] я указал числа. Это необходимо для более простой идентификации пунктов меню.
** Я так-же добавил menu_setprop. Это говорит нашему меню что оно не имеет страниц. Для дополнительной информации смотрите в amxconst.inc

=== Показывает меню голосования ===
Для того что-бы показать меню мы должны использовать menu_display.
<pawn>menu_display ( id, menu, page )</pawn>
* id - id пользователя которому надо показать это меню.
* menu - тут указываем хэндл меню которое показываем пользователю.
* page - какая страница (номер страницы меню) с которой начинаем. Страницы меню начинаются с 0.

Ok теперь посмотрим на наш код.
<pawn>public startvote(id)
{
for(new i = 0; i < 33; i++)
{
if( is_user_alive(i) )
{
menu_display(i, g_Menu, 0);
}
}

return PLUGIN_HANDLED;
}</pawn>
*<tt>Примечание:</tt>
** Используем цыкл для прохождения по всем игрокам и показываем меню тем кто живой.

=== Обработка выборов меню ===
Последний этап заключается в обработке выбора меню. Это делается через функцию обработки.
Она вызывается каждый раз когда пользователь сделал выбор.
Вот 3 переменные которые передаются в функцию.
* id - id пользователя
* menu - открытое меню у пользователя
* item - тут выбор пункта меню пользователем

Далее мы объявляем несколько специальных переменных таких как меню выхода.
<pawn>#define MENU_EXIT -3
#define MENU_BACK -2
#define MENU_MORE -1</pawn>

Теперь нам надо проверить если пункт меню выбран и он не является специальной переменной
<pawn>if( item < 0 ) return PLUGIN_CONTINUE;</pawn>

Следующим шагом мы получаем информацию о выбранном пункте меню. Все что мы ищем это номер пункта меню. (Да = 1, Нет = 2).
Для этого надо использовать menu_item_getinfo.
<pawn>menu_item_getinfo ( menu, item, &access, command[], cmdlen, name[]="", namelen=0, &callback )</pawn>
* menu - меню в котором находится пункт меню.
* item - the item itself
* &access - (edit)
* command[] - (edit)(это то где сохраняются идентификационные номера меню)
* cmdlen - размер command[]
* name[] - имя пункта меню
* namelen - размер name[]
* &callback - (edit)

После того как мы получили информацию о пуектах меню, надо взять из command[] номера выбранных меню(это должно быть 1 или 2).
Теперь надо добавить в g_Votes теми голосами что были сделаны.
Вот как завершонная функция должна выглядеть:
<pawn>public menu_handle(id, menu, item)
{
if( item < 0 ) return PLUGIN_CONTINUE;

// Get item info
new cmd[3];
new access, callback;

menu_item_getinfo(menu, item, access, cmd,2,_,_, callback);

new iChoice = str_to_num(cmd);

g_Votes[iChoice]++;

return PLUGIN_HANDLED;
}
</pawn>

=== Завершение ===
Ну вот и все. Вы завершили Урок по созданию меню. Используя новую систему меню, можно создать более удобное управление. В следующем уроке вы увидите более сложную систему меню, которая будет использовать callbacks, уничтожение меню и его создание. Вот итоговый код, который должен получиться у вас после выполнения всех действий урока.
<pawn>#include <amxmodx>

new g_Menu; // Переменная обработки главного меню
new g_Votes[3]; // Сохраняем голосования Да как 1, No как 2

public plugin_init()
{
// Регистрируем ваш плагин
register_plugin("Vote Menu","1.0","Freecode");

// Регистрируем меню смены карты
g_Menu = menu_create("Change Level?","menu_handle");

register_clcmd("amx_startvote","startvote",ADMIN_CFG,"Gaben");

// Теперь нам надо создать наше меню
build_menu();
}

build_menu()
{
menu_additem(g_Menu, "Yes", "1");
menu_additem(g_Menu, "No", "2");

menu_setprop(g_Menu, MPROP_PERPAGE, 0);
}

public startvote(id)
{
for(new i = 0; i < 33; i++)
{
if( is_user_alive(i) )
{
menu_display(i, g_Menu, 0);
}
}

return PLUGIN_HANDLED;
}

public menu_handle(id, menu, item)
{
if( item < 0 ) return PLUGIN_CONTINUE;

// Получаем информацию о пункте
new cmd[3];
new access, callback;

menu_item_getinfo(menu, item, access, cmd,2,_,_, callback);

new iChoice = str_to_num(cmd);

g_Votes[iChoice]++;

return PLUGIN_HANDLED;
}</pawn>

Ru Button constants (AMX Mod X)

2008-11-06T10:25:41Z

Simon Logic: redirect

#REDIRECT [[Ru:Button_constants_(AMX_Mod_X)]]

Ru:Button constants (AMX Mod X)

2008-11-06T10:24:48Z

Simon Logic: New page: Category:Russian Category:Ru:Scripting (AMX Mod X) =Кнопочные константы= Просмотреть оригинал статьи (англ.): [[Button constants (AM...

[[Category:Russian]]
[[Category:Ru:Scripting (AMX Mod X)]]
=Кнопочные константы=

Просмотреть оригинал статьи (англ.): [[Button constants (AMX Mod X)]]

=Использование=

Кнопочные константы обычно используются для того, чтобы "поймать" момент, когда игрок пытается совершить какое-либо действие, нажимая на кнопки, "привязанные" к таким командам, как +attack, +use и так далее с помощью команды [[cmd_bind|bind]]. Метод используется потому, что HL "движок" не может "поймать" +/-команды стандартным регистрированием, если их реализация выполнена в самом движке.

Например, это будет работать:
<pawn>register_concmd("+explode","explode");</pawn>
А это - нет:
<pawn>register_concmd("+attack","hook_attack");</pawn>

=Константы=

Полный список всех констант вы можете найти [http://amxmodx.org/funcwiki.php?go=module&id=3#const_buttons здесь].

=Реализация=

Вот, например, один из вариантов, как определить, нажимает ли игрок кнопку атаки или нет:<pawn>#include <amxmodx>
#include <engine>

public plugin_init()
{
register_plugin("Attack Test","1.0","Hawk552");
}

public client_PreThink(id)
{
if(entity_get_int(id, EV_INT_BUTTON) & IN_ATTACK)
{
// do something
}
}</pawn>

Обратите внимание, что используется битовый оператор &, в отличии от логического оператора &&. Оператор & проверяет, содержится ли бит после оператора в бите до него, т.е. в данном случае проверяется, есть ли среди нажатых кнопок игрока кнопка IN_ATTACK.

Чтобы заставить игрока эмулировать нажатие кнопки, можно поступить следующим образом:<pawn>#include <amxmodx>
#include <engine>

public plugin_init()
{
register_plugin("Attack Test","1.0","Hawk552");
}

public client_PreThink(id)
{
entity_set_int(id,EV_INT_button,entity_get_int(id,EV_INT_button) | IN_ATTACK);
}</pawn>

Этот пример будет выставлять флаг кнопки "атака" в положение "ВКЛ" каждый раз, когда рендерится entity игрока. Т.е. мы получаем все кнопки, нажатые в данный момент, и как бы прибавляем кнопку атаки.

Чтобы "поймать" кнопки игрока, а потом "вычесть" какую либо кнопку, можно использовать следующий метод:<pawn>#include <amxmodx>
#include <engine>

public plugin_init()
{
register_plugin("Attack Test","1.0","Hawk552");
}

public client_PreThink(id)
{
entity_set_int(id,EV_INT_button,entity_get_int(id,EV_INT_button) & ~IN_ATTACK);
}</pawn>

Например, клиент прыгает (IN_JUMP) и атакует (IN_ATTACK) одновременно, функция entity_get_int(id,EV_INT_button) будет возвращать бит сумму IN_ATTACK и IN_JUMP. Используя конструкцию & ~БИТ мы как бы удаляем конкретное значение бита, в данном случае IN_ATTACK. Таким образом, в итоге получим только IN_JUMP.

=Замечания=

Важно понимать, что нажатие какой-либо кнопки не всегда означает, что в это время происходит конкретное действие. Например, если выстрелить из пистолета и не отпускать кнопку атаки - пуля вылетит, атака закончится и не возобновится, т.к. пистолет не является автоматическим оружием, но, т.к. кнопка все еще будет нажата, то, используя вышеприведенный метод, мы получим активное состояние кнопки IN_ATTACK, хотя атаки как таковой в данный момент не осуществляется.

Более наглядный пример с прыжком. Представьте, что вы прыгнули и, не отпуская кнопки прыжка, опустились на землю. Второго прыжка не произойдет, т.к. для этого нужно отпустить кнопку и нажать ее снова. Таким образом, нажатая кнопка прыжка не говорит о том, что в данный момент вы находитесь в состоянии прыжка. Как уже было отмечено, это относится и к другим кнопкам. Поэтому, в подавляющем большинстве случаев вы не должны делать проверку на наличие нажатой кнопки, если хотите определить, совершает ли игрок соответствующее действие или нет, для этого существуют другие методы.

По большому счету метод, описанный в данной статье, может быть эффективен только для блокировки или эмуляции атаки, хотя для этого есть еще более эффективные методы. Описанный метод не может быть применим к блокировке подавляющего большинства кнопок: для этого существуют другие методы ''(TODO: указать здесь ссылку на эти методы)''.

Ru:Scripting (AMX Mod X)

2008-11-06T10:18:18Z

Simon Logic:

[[Category:Russian]]
[[AMX Mod X]] позволяет расширить функциональность игры с помощью плагинов. Перейдите в категорию [http://wiki.amxmodx.org/index.php/Category:Ru:Scripting_%28AMX_Mod_X%29 Ru:Scripting (AMX Mod X)], чтобы просмотреть список некторых статей, которые помогут вам разработать свои (или доработать чужие) плагины, используя язык [[Pawn]] (известный ранее как [[Small]]).

Ru:Scripting (AMX Mod X)

2008-11-06T10:18:08Z

Simon Logic:

[[Category:Russian]]
{{LanguageSwitch}}
[[AMX Mod X]] позволяет расширить функциональность игры с помощью плагинов. Перейдите в категорию [http://wiki.amxmodx.org/index.php/Category:Ru:Scripting_%28AMX_Mod_X%29 Ru:Scripting (AMX Mod X)], чтобы просмотреть список некторых статей, которые помогут вам разработать свои (или доработать чужие) плагины, используя язык [[Pawn]] (известный ранее как [[Small]]).

Ru Scripting (AMX Mod X)

2008-11-06T10:17:28Z

Simon Logic: Redirecting to Ru:Scripting (AMX Mod X)

#REDIRECT [[Ru:Scripting (AMX Mod X)]]

Ru:Scripting (AMX Mod X)

2008-11-06T10:16:42Z

Simon Logic: New page: Category:Russian AMX Mod X позволяет расширить функциональность игры с помощью плагинов. Перейдите в категор...

Ru:Main Page

2008-10-09T21:55:28Z

Simon Logic: /* Новости */ 1.8.1

[[Category:Russian]]
__NOTOC__
Добро пожаловать в AMWiki, единый и совместный проект документаций AlliedModders, который объединяет такие проекты, как [[AMX Mod X]], [[Metamod:Source]], и [[SourceMod]].

С чего вам начать? Смотрите ниже, для получения общего представления. Зайдите в [[Help:Contents|Справка]] и ознакомтесь с основными принципами и правилами wiki. Или, если вы что-то ищите, просто используйте поиск в левом меню сайта!

=Основные Статьи=

==Разработка SourceMod==
[[:Category:SourceMod Development|SourceMod]] вышел! Хотите узнать подробнее о разработке плагинов и расширений? Посетите [[:Category:SourceMod Development|Категорию Разработки SourceMod]] исчерпывающих статей о SourceMod, мощи C++ и Pawn API.

==Изменения AMX Mod X: 1.8.0==
[[AMX Mod X]] 1.8.0 состоялся и содержит ряд интересных изменений, таких как динмаические администраторы, сущности функций перехвата, и динамические массивы. Каждый, использующий AMX Mod X должен свериться с новой статьей, [[AMX_Mod_X_1.8.0_Changes|AMX Mod X 1.8.0]].

==Руководство по Subversion==
AlliedModders перешел от CVS к Subversion, которые лучше организуют исходный код. Заинтерисованы работой, и хотите скачать с SVN репозитория? Просмотрите [[Subversion Tutorial|Руководство по Subversion]]!

{| cellspacing="0" style="border:0px;"
|- valign="top"
|
{| width="100%"
|-
|
=Проекты=
{| width="100%" cellpadding="5"
|- class="t2th"
| '''SourceMod'''
|- class="t2td"
|[[Image:Sm_small.gif|left]] [[SourceMod]] - оптимизированая и широко расширяемая скриптами среда для [[Half-Life 2]].
* [[:Category:SourceMod Documentation|Документация]]
* [[:Category:SourceMod Development|Разработка]]
|}
{| width="100%" cellpadding="5"
|- class="t2th"
| '''AMX Mod X'''
|- class="t2td"
|[[Image:Amxxsmall.gif|left]] [[AMX Mod X]] - мощная, расширяемая скриптами среда для [[Half-Life 1]].
* [[:Category:Documentation (AMX Mod X)|Документация]]
* [[:Category:Scripting (AMX Mod X)|Скриптинг]]
|}
{| width="100%" cellpadding="5"
|- class="t2th"
| '''Metamod:Source'''
|- class="t2td"
|[[Image:Mms.jpg|left]][[Metamod:Source]], мощный API плагин для [[Half-Life 2]], функции перехвата интерфейсов и универсальный API плагин.
* [[:Category:Metamod:Source Documentation|Документация]]
* [[:Category:Metamod:Source Development|Разработка]]
|}
|}
|
{| width="100%"
|-
|

=Новости=
{| cellpadding="6"
|- class="t2th"
| AMX Mod X 1.8.1
|- class="t2td"
| ''2008-08-16'': Выпущена новая версия [[AMX Mod X]], отличается в основном отсутствием большого количества ошибок. Смотрите [[Ru:AMX Mod X 1.8.1 Changes|Изменения AMX Mod X: 1.8.1]].
|}

{| cellpadding="6"
|- class="t2th"
| Metamod:Source 1.4.1
|- class="t2td"
| ''2007-05-16'': Новая версия [[Metamod:Source|SourceMM]] была выпущена как большой патч исправляющий ошибки в 1.4 версиях. Посетите [http://www.sourcemm.net/ домашнюю страницу] для более подробной информации.
|}

{|
{| cellpadding="6"
|- class="t2th"
| Сборки SourceMod
|- class="t2td"
| ''2007-03-17'': [[SourceMod]] теперь публично доступна ночными сборками. Заинтерисованы в разработке? Смотрите [[SourceMod SDK]] и [http://www.sourcemod.net/ сайт SourceMod].
|}

|}

|}

{{LanguageSwitch}}

Ru:AMX Mod X 1.8.1 Changes

2008-10-09T21:31:19Z

Simon Logic:

[[Category:Russian]]

AMX Mod X 1.8.1 является по большому счету работой над ошибками.

*Добавлено {{amb|1762}}: Македонский язык (спаисбо z3r0Lev3L).
*Добавлено {{amb|1635}}: Нативная функция ns_remove_upgrade().
*Добавлено {{amb|1604}}: Нативная функция unregister_message().
*Добавлено {{amb|1600}}: Trie natives для ассоциативных хранилищ.
*Добавлено {{amb|1365}}: Словацкий язык (спасибо Centaury).
*Добавлено {{amb|1290}}: Обработчик Invalid_Array в cellarray.inc.
*Добавлено {{amb|1263}}: Новый флаг 'k' в файле users.ini, который указывает, что имена/тэги кланов чувствительны к регистру.
*Добавлено {{amb|1167}}: Нативная функция menu_addtext().
*Исправлено {{amb|1648}}: Опечатка в validate_menu_text.
*Исправлено {{amb|1647}}: Координаты браша неверно читались.
*Исправлено {{amb|1643}}: В TFC stats.amxx была опция, которая не поддерживалась конфигурационным меню статистики.
*Исправлено {{amb|1642}}: RTE в файле stats.sma для TFC.
*Исправлено {{amb|1632}}: Некоторые значения mp_roundtime могли конфликтовать со StatsX.
*Исправлено {{amb|1596}}: CSX выделял недостаточную облать памяти для csstats.amxx.
*Исправлено {{amb|1565}}: CCmdManager::gotAccess() имел неконсистентные эвристики.
*Исправлено {{amb|1564}}: amx_chat по-мелочи не соответствовал cmdaccess.ini (патч от Teyut).
*Исправлено {{amb|1545}}: show_activity игнорировала последнего клиента.
*Исправлено {{amb|1456}}: Неверный языковой ключ в режиме голосования за кик/бан.
*Исправлено {{amb|1452}}: ns_give_item() выдавал неверные объекты.
*Исправлено {{amb|1389}}: Функция client_changeteam() из модуля NS имела перевернутый список аргументов интерфейса.
*Исправлено {{amb|1343}}: show_activity() неверно вызывала vformat().
*Исправлено {{amb|1315}}: fread_blocks() не работала из-за опечатки.
*Исправлено {{amb|1313}}: Hamsandwich имел опечатку для мода Sven Co-op.
*Исправлено {{amb|1293}}: Обход ошибки HLDS при парсинге ключей localinfo.
*Исправлено {{amb|1288}}: amx_banip не показывал время (патч от James).
*Исправлено {{amb|1267}}: FlagManager вызывал сбой если файл cmdaccess.ini не был доступен для записи.
*Исправлено {{amb|1218}}: В файле ns.inc была опечатка.
*Исправлено {{amb|1199}}: Неверный комментарий для Ham_DOD_RoundRespawnEnt.
*Исправлено {{amb|1175}}: Новый модуль и плагин не добавлялись в пакет дополнений.
*Исправлено {{amb|1163}}: Распечатка значений с плавающей запятой была некорректной для больших значений.
*Исправлено {{amb|1143}}: Опечатка в SetClientKeyValue().
*Исправлено {{amb|1139}}: Menufront/plmenu не следовали cmdaccess.ini changes for its additions.
*Исправлено {{amb|1134}}: Удалена неиспользуемая cvar.
*Исправлено {{amb|1126}}: Использование dod_set_model() приводило к сбою.
*Исправлено {{amb|1096}}: Ранжирование игроков по IP приводило сервер к застопорению.
*Исправлено {{amb|1079}}: Потоковые запросы к СУБД сзапросом результатов могли сбоить.
*Исправлено {{amb|1077}}: nVault не загружался на некоторых Linux серверах.
*Исправлено {{amb|1089}}: amx_banip выдавал сообщение дважды.
*Исправлено {{amb|1080}}: Опечатка в немецком языке.
*Исправлено {{amb|1049}}: Небрежно были названы объекты TraceResult.
*CS и NS не содержали plmenu и slapdamage значения в amxx.cfg.
*Меню плагинов теперь игнорирует признак иммунитета, когда действие применяется на самом себе.
*Модули, специфичные для модов, больше не загружаются под модами, которые они не поддреживают.
*AMX Mod X теперь использует Visual Studio 2005 (речь о бинарнике под windows).
*Бинарники под Linux теперь не используют -fPIC (стали меньше, немного быстрее).
*Обновлена база GeoIP на август 2008.

Ru:AMX Mod X 1.8.1 Changes

2008-10-09T21:28:53Z

Simon Logic:

[[Category:Russian]]

AMX Mod X 1.8.1 является по большому счету работой над ошибками.

*Добавлено {{amb|1762}}: Македонский язык (спаисбо z3r0Lev3L).
*Добавлено {{amb|1635}}: Нативная функция ns_remove_upgrade().
*Добавлено {{amb|1604}}: Нативная функция unregister_message().
*Добавлено {{amb|1600}}: Trie natives для ассоциативных хранилищ.
*Добавлено {{amb|1365}}: Словацкий язык (спасибо Centaury).
*Добавлено {{amb|1290}}: Обработчик Invalid_Array в cellarray.inc.
*Добавлено {{amb|1263}}: Новый флаг 'k' в файле users.ini, который указывает, что имена/тэги кланов чувствительны к регистру.
*Добавлено {{amb|1167}}: Нативная функция menu_addtext().
*Исправлено {{amb|1648}}: Опечатка в validate_menu_text.
*Исправлено {{amb|1647}}: Координаты браша неверно читались.
*Исправлено {{amb|1643}}: В TFC stats.amxx была опция, которая не поддерживалась конфигурационным меню статистики.
*Исправлено {{amb|1642}}: RTE в файле stats.sma для TFC.
*Исправлено {{amb|1632}}: Некоторые значения mp_roundtime могли конфликтовать со StatsX.
*Исправлено {{amb|1596}}: CSX выделял недостаточную облать памяти для csstats.amxx.
*Исправлено {{amb|1565}}: CCmdManager::gotAccess() имел неконсистентные эвристики.
*Исправлено {{amb|1564}}: amx_chat по-мелочи не соответствовал cmdaccess.ini (патч от Teyut).
*Исправлено {{amb|1545}}: show_activity игнорировала последнего клиента.
*Исправлено {{amb|1456}}: Неверный языковой ключ в режиме голосования за кик/бан.
*Исправлено {{amb|1452}}: ns_give_item() выдавал неверные объекты.
*Исправлено {{amb|1389}}: Функция client_changeteam() из модуля NS имела перевернутый список аргументов интерфейса.
*Исправлено {{amb|1343}}: show_activity() неверно вызывала vformat().
*Исправлено {{amb|1315}}: fread_blocks() не работала из-за опечатки.
*Исправлено {{amb|1313}}: Hamsandwich имел опечатку для мода Sven Co-op.
*Исправлено {{amb|1293}}: Обход ошибки HLDS при парсинге ключей localinfo.
*Исправлено {{amb|1288}}: amx_banip не показывал время (патч от James).
*Исправлено {{amb|1267}}: FlagManager вызывал сбой если файл cmdaccess.ini не был доступен для записи.
*Исправлено {{amb|1218}}: В файле ns.inc была опечатка.
*Исправлено {{amb|1199}}: Неверный комментарий для Ham_DOD_RoundRespawnEnt.
*Исправлено {{amb|1175}}: Новый модуль и плагин не добавлялись в пакет дополнений.
*Исправлено {{amb|1163}}: Распечатка значений с плавающей запятой была некорректной для больших значений.
*Исправлено {{amb|1143}}: Опечатка в SetClientKeyValue().
*Исправлено {{amb|1139}}: Menufront/plmenu не следовали cmdaccess.ini changes for its additions.
*Исправлено {{amb|1134}}: Удалена неиспользуемая cvar.
*Исправлено {{amb|1126}}: Использование dod_set_model() приводило к сбою.
*Исправлено {{amb|1096}}: Ранжирование игроков по IP приводило сервер к застопорению.
*Исправлено {{amb|1079}}: Потоковые запросы к СУБД сзапросом результатов могли сбоить.
*Исправлено {{amb|1077}}: nVault не загружался на некоторых Linux серверах.
*Исправлено {{amb|1089}}: amx_banip message printed twice.
*Исправлено {{amb|1080}}: Опечатка в немецком языке.
*Исправлено {{amb|1049}}: Небрежно были названы объекты TraceResult.
*CS и NS не содержали plmenu и slapdamage значения в amxx.cfg.
*Меню плагинов теперь игнорирует признак иммунитета, когда действие применяется на самом себе.
*Модули, специфичные для модов, больше не загружаются под модами, которые они не поддреживают.
*AMX Mod X теперь использует Visual Studio 2005 (речь о бинарнике под windows).
*Бинарники под Linux теперь не используют -fPIC (стали меньше, немного быстрее).
*Обновлена база GeoIP на август 2008.

Ru:Alternative Language

2008-10-09T20:59:05Z

Simon Logic:

[[Category:Russian]]
[[Category:Translations]]

Если вы желаете составить документацию на языке отличном от английского, пожалуйста, начните отсюда. Приветствуется содержимое на любом языке.

Другие языки не обязательно должны быть "зеркалом" английской документации.
Приветствуется не только перевод документации с английского языка, но и дополнения к ней.

= Выбор языка =

Переключение осуществляется подстановкой префикс-кода языка.

* [[Alternative_Language|English]]
* [[ru:Alternative_Language|Russian]]

Быстрый и эффективный способ добавления переключателя нового языка - это использование шаблона
<nowiki>{{LanguageSwitch}}</nowiki>
где-либо в статье (рекомендуется добавлять вверху, либо в самом низу). Данный код добавит маленькое меню, которое выглядит следующим образом:
{{LanguageSwitch}}

После того, как новый язык добавлен в wiki, данный темплейт будет изменен автоматически. Таким образом, все страницы, которые его используют, будут также автоматически обновлены.

= Как перевести страницу =

# Перейдите на страницу, которую вы желаете перевести.
# Вверху страницы выберите "edit"(править), затем сверху добавьте переключатель языка, если такового не существует.
# Скопируйте весь текст темплейта страницы.
# Сохраните (чтобы сохранился переключатель языка).
# Теперь вверху страницы должен появиться переключатель языка, как на этой странице.
# Выберите нажатием язык, на который вы желаете осуществить перевод.
# Вставьте текст, который вы скопировали, в текстовую область.
# Осуществите перевод, после чего сохраните его.

Вышеприведенные инструкции позволят создать версию текущего документа на вашем языке. Существует возможность перевода любых страниц.

= Ресурсы =

* Список 2х-буквенных кодов языков можно найти тут: http://www.w3.org/WAI/ER/IG/ert/iso639.htm

Ru:Alternative Language

2008-10-09T20:57:36Z

Simon Logic:

[[Category:Russian]]
[[Category:Translations]]

Если вы желаете составить документацию на языке отличном от английского, пожалуйста, начните отсюда. Приветствуется содержимое на любом языке.

Другие языки не обязательно должны быть "зеркалом" английской документации.
Приветствуется не только перевод документации с английского языка, но и дополнения к ней.

= Выбор языка =

Переключение осуществляется подстановкой префикс-кода языка.

* [[Alternative_Language|English]]
* [[ru:Alternative_Language|Russian]]

Быстрый и эффективный способ добавления переключателя нового языка - это использование шаблона
<nowiki>{{LanguageSwitch}}</nowiki>
где-либо в статье (рекомендуется добавлять вверху, либо в самом низу). Данный код добавит маленькое меню, которое выглядит следующим образом:
{{LanguageSwitch}}

После того, как новый язык добавлен в wiki, данный темплейт будет изменен автоматически. Таким образом, все страницы, которые его используют, будут также автоматически обновлены.

= Как перевести страницу =

1) Перейдите на страницу, которую вы желаете перевести.

2) Вверху страницы выберите "edit"(править), затем сверху добавьте переключатель языка, если такового не существует.

3) Скопируйте весь текст темплейта страницы.

4) Сохраните (чтобы сохранился переключатель языка).

5) Теперь вверху страницы должен появиться переключатель языка, как на этой странице.

6) Выберите нажатием язык, на который вы желаете осуществить перевод.

7) Вставьте текст, который вы скопировали, в текстовую область.

8) Осуществите перевод, после чего сохраните его.

Вышеприведенные инструкции позволят создать версию текущего документа на вашем языке. Существует возможность перевода любых страниц.

'''Ресурсы:'''

* Список 2х-буквенных кодов языков можно найти тут: http://www.w3.org/WAI/ER/IG/ert/iso639.htm

Ru:AMX Mod X 1.8.1 Changes

2008-10-09T20:55:40Z

Simon Logic:

AMX Mod X 1.8.1 является по большому счету работой над ошибками.

*Добавлено {{amb|1762}}: Macedonian translation (thanks z3r0Lev3L).
*Добавлено {{amb|1635}}: ns_remove_upgrade() native.
*Добавлено {{amb|1604}}: unregister_message() native.
*Добавлено {{amb|1600}}: Trie natives for associative storage.
*Добавлено {{amb|1365}}: Slovak translation (thanks Centaury).
*Добавлено {{amb|1290}}: Invalid_Array handle in cellarray.inc.
*Добавлено {{amb|1263}}: A new flag in users.ini, 'k' implies name/tags are case sensitive.
*Добавлено {{amb|1167}}: menu_addtext() native.
*Исправлено {{amb|1648}}: Typo in validate_menu_text.
*Исправлено {{amb|1647}}: Brush origin retrieval was wrong.
*Исправлено {{amb|1643}}: TFC's stats.amxx added an option it did not support to the stats config menu.
*Исправлено {{amb|1642}}: RTE in tfc stats.sma.
*Исправлено {{amb|1632}}: Certain mp_roundtime values could conflict with statsx.
*Исправлено {{amb|1596}}: CSX was allocating a buffer too small for csstats.amxx.
*Исправлено {{amb|1565}}: CCmdManager::gotAccess() had inconsistent heuristics.
*Исправлено {{amb|1564}}: amx_chat sundry details did not obey cmdaccess.ini (patch from Teyut).
*Исправлено {{amb|1545}}: show_activity was ignoring the last client.
*Исправлено {{amb|1456}}: Wrong language key in vote kick/ban.
*Исправлено {{amb|1452}}: ns_give_item() was giving wrong items.
*Исправлено {{amb|1389}}: NS module's client_changeteam() had a reversed syntax.
*Исправлено {{amb|1343}}: show_activity() had a messed up vformat() call.
*Исправлено {{amb|1315}}: fread_blocks() broken due to typo.
*Исправлено {{amb|1313}}: Hamsandwich had a typo for Sven Co-op.
*Исправлено {{amb|1293}}: Workaround for a bug with HLDS's parsing of localinfo keys.
*Исправлено {{amb|1288}}: amx_banip did not show time (patch from "James").
*Исправлено {{amb|1267}}: FlagManager caused a crash if the cmdaccess.ini was not writable.
*Исправлено {{amb|1218}}: ns.inc had a typo.
*Исправлено {{amb|1199}}: Incorrect comment for Ham_DOD_RoundRespawnEnt.
*Исправлено {{amb|1175}}: New module and plugin did not get added to addon packages.
*Исправлено {{amb|1163}}: float printing broke on large values.
*Исправлено {{amb|1143}}: Typo in SetClientKeyValue().
*Исправлено {{amb|1139}}: Menufront/plmenu now follows cmdaccess.ini changes for its additions.
*Исправлено {{amb|1134}}: Removed unused cvar.
*Исправлено {{amb|1126}}: dod_set_model() crashed.
*Исправлено {{amb|1096}}: Ranking by IP caused the server to freeze.
*Исправлено {{amb|1079}}: Threaded queries with results would crash.
*Исправлено {{amb|1077}}: nVault wouldn't load on some Linux servers.
*Исправлено {{amb|1089}}: amx_banip message printed twice.
*Исправлено {{amb|1080}}: German translation typo.
*Исправлено {{amb|1049}}: Sloppy TraceResult namings.
*CS и NS не содержали plmenu и slapdamage значения в amxx.cfg.
*Меню плагинов теперь игнорирует признак иммунитета, когда действие применяется на самом себе.
*Модули, специфичные для модов, больше не загружаются под модами, которые они не поддреживают.
*AMX Mod X теперь использует Visual Studio 2005 (речь о бинарнике под windows).
*Бинарники под Linux теперь не используют -fPIC (стали меньше, немного быстрее).
*Обновлена база GeoIP на август 2008.

[[Category:Russian]]

AMX Mod X 1.8.1 Changes

2008-10-09T20:54:44Z

Simon Logic:

{{LanguageSwitch}}

AMX Mod X 1.8.1 is a bug-fix release.

*Added {{amb|1762}}: Macedonian translation (thanks z3r0Lev3L).
*Added {{amb|1635}}: ns_remove_upgrade() native.
*Added {{amb|1604}}: unregister_message() native.
*Added {{amb|1600}}: Trie natives for associative storage.
*Added {{amb|1365}}: Slovak translation (thanks Centaury).
*Added {{amb|1290}}: Invalid_Array handle in cellarray.inc.
*Added {{amb|1263}}: A new flag in users.ini, 'k' implies name/tags are case sensitive.
*Added {{amb|1167}}: menu_addtext() native.
*Fixed {{amb|1648}}: Typo in validate_menu_text.
*Fixed {{amb|1647}}: Brush origin retrieval was wrong.
*Fixed {{amb|1643}}: TFC's stats.amxx added an option it did not support to the stats config menu.
*Fixed {{amb|1642}}: RTE in tfc stats.sma.
*Fixed {{amb|1632}}: Certain mp_roundtime values could conflict with statsx.
*Fixed {{amb|1596}}: CSX was allocating a buffer too small for csstats.amxx.
*Fixed {{amb|1565}}: CCmdManager::gotAccess() had inconsistent heuristics.
*Fixed {{amb|1564}}: amx_chat sundry details did not obey cmdaccess.ini (patch from Teyut).
*Fixed {{amb|1545}}: show_activity was ignoring the last client.
*Fixed {{amb|1456}}: Wrong language key in vote kick/ban.
*Fixed {{amb|1452}}: ns_give_item() was giving wrong items.
*Fixed {{amb|1389}}: NS module's client_changeteam() had a reversed syntax.
*Fixed {{amb|1343}}: show_activity() had a messed up vformat() call.
*Fixed {{amb|1315}}: fread_blocks() broken due to typo.
*Fixed {{amb|1313}}: Hamsandwich had a typo for Sven Co-op.
*Fixed {{amb|1293}}: Workaround for a bug with HLDS's parsing of localinfo keys.
*Fixed {{amb|1288}}: amx_banip did not show time (patch from "James").
*Fixed {{amb|1267}}: FlagManager caused a crash if the cmdaccess.ini was not writable.
*Fixed {{amb|1218}}: ns.inc had a typo.
*Fixed {{amb|1199}}: Incorrect comment for Ham_DOD_RoundRespawnEnt.
*Fixed {{amb|1175}}: New module and plugin did not get added to addon packages.
*Fixed {{amb|1163}}: float printing broke on large values.
*Fixed {{amb|1143}}: Typo in SetClientKeyValue().
*Fixed {{amb|1139}}: Menufront/plmenu now follows cmdaccess.ini changes for its additions.
*Fixed {{amb|1134}}: Removed unused cvar.
*Fixed {{amb|1126}}: dod_set_model() crashed.
*Fixed {{amb|1096}}: Ranking by IP caused the server to freeze.
*Fixed {{amb|1079}}: Threaded queries with results would crash.
*Fixed {{amb|1077}}: nVault wouldn't load on some Linux servers.
*Fixed {{amb|1089}}: amx_banip message printed twice.
*Fixed {{amb|1080}}: German translation typo.
*Fixed {{amb|1049}}: Sloppy TraceResult namings.
*CS and NS did not have plmenu and slapdamage amounts in their amxx.cfg.
*Plugin menu now ignores immunity if executed on self.
*Mod-specific modules no longer load on mods they don't support.
*AMX Mod X now uses Visual Studio 2005.
*Linux builds no longer use -fPIC (smaller, slightly faster binaries).
*Updated GeoIP database to August 2008.

Ru:AMX Mod X 1.8.1

2008-10-09T20:53:50Z

Simon Logic: Removing all content from page

Ru:AMX Mod X 1.8.1 Changes

2008-10-09T20:53:46Z

Simon Logic: New page: AMX Mod X 1.8.1 является по большому счету работой над ошибками. *Добавлено {{amb|1762}}: Macedonian translation (thanks z3r0Lev3L). *Д...

Ru:AMX Mod X 1.8.1

2008-10-09T20:51:20Z

Ru AMX Mod X FAQ

2008-08-02T10:34:40Z

Simon Logic: /* Почему клиент не получает права админа по IP? */

[[Category:Russian]]
[[Category:Ru:AMX Mod X]]

= Общие положения, термины, сокращения и условные обозначения =
:* HL или HL1 - аббревиатура от [[Half-Life 1|Half-Life]] (часть первая);
:* Mod - "мод", модификация - дополнение к чему-либо, как правило, расширяющее/изменяющее функциональность;
:* HL Engine - "движок" Half-Life - "центральный модуль", осуществляющий выполнение базовых "общемодовых" задач;
:* MM - [[Metamod]] - сторонний мод особого типа, является промежуточным звеном в системе "HL движок - HL мод";
:* AMXX - аббревиатура от [[AMX Mod X]] - Metamod plugin ("плагин"), своего рода Metamod мод;
:* Map - "карта" - определяет внешний вид территории, на которой происходит игровое действие;
:* World - "мир" - все пространство, которое занимает карта, а также область, находящаяся за картой;
:* Spawn - "спавн" - момент, когда игрок появляется в мире, обретая физическое тело;
:* SinglePlayer - "синглплеер" - игровой тип, когда одновременно в игре может участвовать только один игрок;
:* MultiPlayer - "мультиплеер" - игровой тип, когда одновременно в игре может участвовать несколько игроков;
:* DM - аббревиатура от Death Match - динамичный мультиплеер тип игры, когда после "смерти" игрока происходит его скорый спавн ("респавн");
:* HLDM - аббревиатура от Half-Life Death Match - оригинальный HL мод DM типа;
:* CS - аббревиатура от [[Counter-Stirke]] - наиболее популярный HL мод;
:* VALVE - [[VALVe Software|корпорация, разработчик HL и CS]], также редко используется как синоним HLDM, подчеркивая название директории мода ("valve");
:* $MODDIR - способ условного обозначения корневой директории мода, например: ''cstrike'', ''valve'';
:* $MMDIR - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории Metamod, по-умолчанию: ''addons/metamod'';
:* $AMXMODX - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории AMX Mod X, по-умолчанию: ''addons/amxmodx''.

= Общие вопросы =
=== Где скачать последнюю версию AMX Mod X? ===
: Последнюю версию всегда можно скачать на официальном сайте AMX Mod X в [http://www.amxmodx.org/downloads.php разделе закачек].

=== А что именно качать? ===
: Качайте либо инсталлятор (AMX Mod X Full Installer), который включает базовый AMX Mod X пакет, все AMX Mod X дополнения для HL модов, а также AMXX-Studio (специализированный редактор AMX Mod X плагинов), либо, если готовы произвести установку AMX Mod X вручную, а также не желаете закачивать все существующие AMX Mod X дополнения для HL модов, качайте базовый архив (AMX Mod X Base), а затем дополнение для интересующего вас HL мода. Сама по себе базовая поставка практически во всех случаях будет достаточна только для HLDM мода.

=== Чем отличается AMX Mod X от AMX Mod? ===
: Буквой X ;). На самом деле отличий очень много:
:* AMXX поддерживается до сих пор, а поддержка AMX Mod была завершена примерно в 2006 году;
:* функциональность AMXX значительно превосходит AMX Mod, это также касается и расширенной поддержки других модов, в то время как AMX Mod поддерживал только HLDM, CS и CZ;
:* AMXX принято считать быстрее AMX Mod;
:* плагины AMXX не совместимы с плагинами AMX Mod;
:* плагины AMX Mod 0.9.9 совместимы с AMXX, если последний работает в режиме совместимости(?);
:* плагины для AMX Mod имеют расширение .amx, а плагины AMXX - .amxx;
:* ''TODO: дополнить список''

=== Как запустить два различных сервера AMX Mod X? ===
: К примеру, вы хотите запустить два различных сервера из одной ''cstrike'' директории на базе различных AMX Mod X/Metamod плагинов, настроек и прочего. Это решаемо. Один из примеров для win32 системы приведен ниже:
:* Создать отдельную AMX Mod X директорию с необходимыми файлами, например: ''addons/amxmodx2''
:* В ''addons/amxmodx2/configs/core.ini'' везде изменить "amxmodx" на "amxmodx2"
:* Создать отдельный файл загрузки Metamod плагинов, например: ''addons/metamod/plugins2.ini''
:* В созданный ''plugins2.ini'' файл вписать: ''win32 addons\amxmodx2\dlls\amxmodx_mm.dll''
:* Создать в директории ''cstrike'' файл, например, с именем ''amxmodx2.cfg'', его содержимое должно быть следующим:
<pre>localinfo mm_pluginsfile "addons/metamod/plugins2.ini"
localinfo amxx_basedir "addons/amxmodx2"
localinfo amxx_cfg "addons/amxmodx2/configs/core.ini"
localinfo amxx_configsdir "addons/amxmodx2/configs"
localinfo amxx_customdir "addons/amxmodx2/custom"
localinfo amxx_datadir "addons/amxmodx2/data"
localinfo amxx_logdir "addons/amxmodx2/logs"
localinfo amxx_logs "addons/amxmodx2/logs"
localinfo amxx_modules "addons/amxmodx2/configs/modules.ini"
localinfo amxx_modulesdir "addons/amxmodx2/modules"
localinfo amxx_plugins "addons/amxmodx2/configs/plugins.ini"
localinfo amxx_pluginsdir "addons/amxmodx2/plugins"
localinfo amxx_vault "addons/amxmodx2/data/vault.ini"
localinfo csstats "addons/amxmodx2/data/csstats.dat"
localinfo csstats_score "addons/amxmodx2/data/csstats.amxx"
localinfo amx_basedir "addons/amxmodx2"
localinfo amx_configdir "addons/amxmodx2/configs"
localinfo amx_langdir "addons/amxmodx2/data/amxmod-lang"
localinfo amx_logdir "addons/amxmodx2/logs"
localinfo amx_modulesdir "addons/amxmodx2/modules"
localinfo amx_pluginsdir "addons/amxmodx2/plugins"</pre>
:* Теперь второй сервер необходимо будет запускать с параметром командной строки: ''+exec amxmodx2.cfg''

= Вопросы по плагинам =
== Общие вопросы ==
=== Где и как искать плагины? ===
: Предварительно отметим, что условно AMX Mod X плагины можно разделить на следующие категории: стандартные, официально одобренные, официально отклоненные и неофициальные. Одобренные плагины можно искать [http://www.amxmodx.org/compiler.php здесь], или, используя [http://forums.alliedmods.net/search.php поисковую систему официального форума]. В поле '''Search in Forum(s)''' отметьте '''Approved Plugins''', также, зажав клавишу Ctrl, можно отметить интересующие вас секции из подраздела '''High-Traffic Plugins'''. Чтобы искать неофициальные плагины, следует также воспользоваться [http://forums.alliedmods.net/search.php поисковой системой официального форума], правда, в поле '''Search in Forum(s)''' необходимо выбрать '''Unapproved/Old Plugins'''. Если для вас не имеет значения статус плагина, и вы склонны к экспериментам, осуществляйте поиск по категории '''Plugins''', которая включает в себя одобренные, отклоненные, недавно опубликованные, вполне возможно, "сырые" плагины, а также темы-запросы, в которых могут быть "быстро написанные" плагины. Особенность поиска на официальных форумах еще состоит в том, что при вводе слова система ищет именно слова (без учета регистра), т.е. фрагменты, разделенные слева и справа пробелами. Т.о., к примеру, набрав для поиска слово ''FCOS'' вы не найдете нужного вам плагина, хотя есть тема, в которой присутствует текст ''[fcos]''. Для этого надо использовать в поиске строку ''*FCOS*''. Немного поработав с поисковой формой форума, вы легко освоите эту систему. Единственное возможное для некоторых неудобство - практически все описания плагинов написаны на английcком языке. Неофициальные плагины также можно попробовать искать с помощью общеизвестных поисковых систем: Google, Yandex, Rambler и др.

=== Сколько плагинов сейчас выпущено под AMX Mod X? ===
: "Тонны" плагинов. Но, к сожалению, качеством и надежностью б'''о'''льшая половина из них не белещет. К тому же некоторые плагины, "заброшены" авторами и не обновляются, что приводит даже к несовместимости с новыми версиями AMX Mod X.

=== Как устанавливать плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Как удалять плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Что такое стандартные плагины? ===
: Это плагины, которые входят в стандартную поставку AMX Mod X. Они находятся в папке $AMXMODX\scripting.

=== Как узнать, в каком плагине зарегистрирована та или иная переменная? ===
: В серверной консоли наберите команду ''amxx cvars''. Выделите текст, скопируйте в файл, там сделайте поиск искомой переменной. В правой колонке будет стоять имя плагина, в котором она и зарегистрирована.

=== Я перевел на русский языковой файл плагина, а текст в игре отображается криво ===
: Скорее всего вы не сохранили файл в UTF-8 кодировке. Даже если вы это сделали, проверьте что в начале файле нет маркера кодировки, потому что некоторые редакторы его вставляют без предупреждения. Для этого надо использовать редактор или режим, который НЕ понимает UTF-8, потому что unicode редактор не отображает такой маркер.
: Имейте в виду, что в консоли сервера, работающего в режиме ''-console'', переведенный текст не будет отображаться по-русски.

=== Как называется статистика, встроенная в AMXX? ===
: Называется "StatsX", реализована в виде плагинов ''statsx.amxx'', ''statscfg.amxx'', ''stats_logging.amxx'', а также в модуле ''csx''. О последнем многие забывают, полагая, что можно просто изменить алгоритм учета статистики на уровне плагинов AMXX.

== Вопросы по стандартным плагинам ==
=== Как увеличить число карт в стандартном голосовании? ===
: Откройте файл $AMXMODX\scripting\mapchooser.sma, замените число 3 в строке
#define SELECTMAPS 3
: на требуемое, затем [[#Как компилировать плагины?|откомпилируйте]] плагин и замените исходный.

=== Как увеличить число администраторов? ===
: В файле ''admin.sma'' замените число 64 на требуемое значение в строке:
#define MAX_ADMINS 64
: Не ставьте слишком большие значения. Не забудьте [[#Как компилировать плагины?|перекомпилировать]] плагин и заменить исходный новым.
: В AMXX 1.8.X и выше такая проблема не стоит, т.к. там реализован динамический список админов.

=== Почему клиент не получает права админа по IP? ===
:Данная проблема возникает на публичных Non-Steam (патченных) интернет-серверах c sv_lan = 0 при подключении Steam/Non-Steam клиентов.
: Сначала убедитесь, что у вас нединамический внешний IP. Динамический IP означает, что каждый раз, подключась к Интернету, вам назначается новый внешний IP (обычно из какого-то фиксированного диапазона). Для этого обратитесь к вашему провайдеру. Далее необходимо сверить, правильно ли вы прописали доступ в файле users.ini. Для этого проверьте свой внешний IP на страничке [http://myip.ru/ myip.ru]. Запомните его. Откройте файл user.ini и убедитесь что там есть такая запись:
"<ваш_ip>" "<ваш_пароль>" "<ваши_флаги>" "d<другие_модификаторы>"
:В поле ''<ваш_ip>'' должен быть вбит запомненный ранее IP. Обратите внимание на модификатор '''d'''. Без него проверка на IP проводиться НЕ будет. При указании IP старайтесь не использовать номер порта (знак двоеточия и то, что справа от него).
: Если все правильно, а вы все равно не становитесь администратором на сервере, то, скорее всего, проблема в том, что вы не прошли авторизацию на сервере. Для этого выполните команду ''users'' или ''stat'' в консоли сервера и обратите внимание на значение в колонке ''userid''. Если напротив потенциального админа стоит '''STEAM_ID_PENDING''', то это означает, что сервер криво заломан, и он не авторизовал данного игрока. В свою очередь это значит, что функция ''client_authorized(id)'' не была вызвана для всех(!) активных AMXX плагинов. Если открыть файл ''admin.sma'', то можно увидеть следующее:
public client_authorized(id)
return get_cvar_num("amx_mode") ? accessUser(id) : PLUGIN_CONTINUE
: Это и есть проверка клиента на админа. Чтобы эта функция вызывалась всегда, ''client_authorized'' надо переименовать в ''client_putinserver'', а существующую функцию ''client_putinserver'' либо удалить, либо [[Ru_Fundamental_Basics_of_AMX_Mod_X_Scripting#Комментарии|закомментировать]].

=== Как заставить команду amx_who выводить IP вместо ID? ===
: В файле ''admincmd.sma'' в указанном ниже месте
public cmdWho(id, level, cid)
{
...
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
for (new a = 0; a < inum; ++a)
{
get_user_authid(players[a], authid, 31)
...
}
...
}
:замените
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
: на
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "ip", "userid", lImm, lRes, lAccess)
: а также
get_user_authid(players[a], authid, 31)
: на
get_user_ip(players[a], authid, 31, 1)
: Сохраните файл и [[#Как компилировать плагины?|перекомпилируйте]] плагин.

=== А как дать всем доступ к команде amx_who? ===
: По умолчанию, команда доступна только игрокам с правами '''y''' (т.е. это признак админа). Чтобы разрешить пользоваться ею всем игрокам, надо открыть файл ''admincmd.sma'', и в строке
register_concmd("amx_who", "cmdWho", ADMIN_ADMIN, "- displays who is on server")
: заменить ''ADMIN_ADMIN'' на ''ADMIN_ALL'' и [[#Как компилировать плагины?|перекомпилировать]] плагин.
: В AMX 1.8.X и выше доступны стандартные средства переопределения прав доступа к командам без исправления самих плагинов (''TODO: ссылка?'').

=== Как очистить статистику StatsX? ===
: Удалите файл ''$AMXMODX/data/csstats.dat''.

= Вопросы по компилированию =
=== Что такое компиляция? ===
: Это процесс, который переводит текстовые файлы (*.sma), содержащие исходный код (т.е. инструкции для AMX Mod X, который их исполняет), в формат, более пригодный для исполнения. За счет этого скорость выполнения плагинов возрастает многократно, упрощается разработка "движка", который эти плагины исполняет, а также в некотором смысле защищается авторский код. Почему в "некотором смысле"? Потому что все AMX Mod X плагины должны публиковаться под лицензией GNU General Public License. В случае публикации плагина лицензия обязывает также публиковать и его исходный код. Откомпилированные плагины имеют расширение .amxx. Именно файлы этого типа, а не .sma, должны указываться в файле plugins.ini для последующей корректной загрузки плагина.

=== Как компилировать плагины? ===
: Базовую информацию вы можете найти на [[Ru Compiling Plugins (AMX Mod X)|этой]] странице.

=== Как упростить процесс компилирования? ===
: Можно написать стороннюю программу или скрипт, например такой, как пакетный batch файл. Например, создайте файл make.bat со следующим содержимым:
@amxxpc.exe %1 -i.\include -o.\compiled\%1
: Чтобы с помощью него откомпилировать плагин, необходимо выполнить следующую команду:
make.bat my_plugin.sma
: В итоге откомпилированный файл будет помещен в каталог ''compiled'' текущей директории. Если его там нет, значит в процессе компилирования возникли фатальные ошибки, которые выводятся на экран.
: Если вам необходимо (например, в случае ошибок) отправить кому-нибудь результат компиляции, можете перенаправить вывод информации о процессе компилирования в файл, например таким образом:
make.bat my_plugin.sma > my_plugin.log

=== Компилятор выводит "max. usage is unknown, due to recursion" ===
: Ничего страшного - просто компилятор не может вычислить предполагаемый объем памяти, используемый вашим плагином.

= Вопросы по скриптингу =
=== С чего начать? ===
: С со статьи [[Ru Fundamental Basics of AMX Mod X Scripting|Фундаментальные основы AMX Mod X скриптинга]].

=== А стоит ли вообще начинать? ===
: В зависимости от того, какую цель вы преследуете, а также от вашего желания и потенциала. Знание английского языка (чтение) будет огромным плюсом во время обучения, иначе постигать азы будет очень сложно. CS является закрытым проектом без исходных кодов, поэтому могие новые (неизученные) элементы приходится постигать через проведение экспериментов.

Ru AMX Mod X FAQ

2008-08-02T10:23:37Z

Simon Logic: + Как очистить статистику StatsX?

[[Category:Russian]]
[[Category:Ru:AMX Mod X]]

= Общие положения, термины, сокращения и условные обозначения =
:* HL или HL1 - аббревиатура от [[Half-Life 1|Half-Life]] (часть первая);
:* Mod - "мод", модификация - дополнение к чему-либо, как правило, расширяющее/изменяющее функциональность;
:* HL Engine - "движок" Half-Life - "центральный модуль", осуществляющий выполнение базовых "общемодовых" задач;
:* MM - [[Metamod]] - сторонний мод особого типа, является промежуточным звеном в системе "HL движок - HL мод";
:* AMXX - аббревиатура от [[AMX Mod X]] - Metamod plugin ("плагин"), своего рода Metamod мод;
:* Map - "карта" - определяет внешний вид территории, на которой происходит игровое действие;
:* World - "мир" - все пространство, которое занимает карта, а также область, находящаяся за картой;
:* Spawn - "спавн" - момент, когда игрок появляется в мире, обретая физическое тело;
:* SinglePlayer - "синглплеер" - игровой тип, когда одновременно в игре может участвовать только один игрок;
:* MultiPlayer - "мультиплеер" - игровой тип, когда одновременно в игре может участвовать несколько игроков;
:* DM - аббревиатура от Death Match - динамичный мультиплеер тип игры, когда после "смерти" игрока происходит его скорый спавн ("респавн");
:* HLDM - аббревиатура от Half-Life Death Match - оригинальный HL мод DM типа;
:* CS - аббревиатура от [[Counter-Stirke]] - наиболее популярный HL мод;
:* VALVE - [[VALVe Software|корпорация, разработчик HL и CS]], также редко используется как синоним HLDM, подчеркивая название директории мода ("valve");
:* $MODDIR - способ условного обозначения корневой директории мода, например: ''cstrike'', ''valve'';
:* $MMDIR - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории Metamod, по-умолчанию: ''addons/metamod'';
:* $AMXMODX - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории AMX Mod X, по-умолчанию: ''addons/amxmodx''.

= Общие вопросы =
=== Где скачать последнюю версию AMX Mod X? ===
: Последнюю версию всегда можно скачать на официальном сайте AMX Mod X в [http://www.amxmodx.org/downloads.php разделе закачек].

=== А что именно качать? ===
: Качайте либо инсталлятор (AMX Mod X Full Installer), который включает базовый AMX Mod X пакет, все AMX Mod X дополнения для HL модов, а также AMXX-Studio (специализированный редактор AMX Mod X плагинов), либо, если готовы произвести установку AMX Mod X вручную, а также не желаете закачивать все существующие AMX Mod X дополнения для HL модов, качайте базовый архив (AMX Mod X Base), а затем дополнение для интересующего вас HL мода. Сама по себе базовая поставка практически во всех случаях будет достаточна только для HLDM мода.

=== Чем отличается AMX Mod X от AMX Mod? ===
: Буквой X ;). На самом деле отличий очень много:
:* AMXX поддерживается до сих пор, а поддержка AMX Mod была завершена примерно в 2006 году;
:* функциональность AMXX значительно превосходит AMX Mod, это также касается и расширенной поддержки других модов, в то время как AMX Mod поддерживал только HLDM, CS и CZ;
:* AMXX принято считать быстрее AMX Mod;
:* плагины AMXX не совместимы с плагинами AMX Mod;
:* плагины AMX Mod 0.9.9 совместимы с AMXX, если последний работает в режиме совместимости(?);
:* плагины для AMX Mod имеют расширение .amx, а плагины AMXX - .amxx;
:* ''TODO: дополнить список''

=== Как запустить два различных сервера AMX Mod X? ===
: К примеру, вы хотите запустить два различных сервера из одной ''cstrike'' директории на базе различных AMX Mod X/Metamod плагинов, настроек и прочего. Это решаемо. Один из примеров для win32 системы приведен ниже:
:* Создать отдельную AMX Mod X директорию с необходимыми файлами, например: ''addons/amxmodx2''
:* В ''addons/amxmodx2/configs/core.ini'' везде изменить "amxmodx" на "amxmodx2"
:* Создать отдельный файл загрузки Metamod плагинов, например: ''addons/metamod/plugins2.ini''
:* В созданный ''plugins2.ini'' файл вписать: ''win32 addons\amxmodx2\dlls\amxmodx_mm.dll''
:* Создать в директории ''cstrike'' файл, например, с именем ''amxmodx2.cfg'', его содержимое должно быть следующим:
<pre>localinfo mm_pluginsfile "addons/metamod/plugins2.ini"
localinfo amxx_basedir "addons/amxmodx2"
localinfo amxx_cfg "addons/amxmodx2/configs/core.ini"
localinfo amxx_configsdir "addons/amxmodx2/configs"
localinfo amxx_customdir "addons/amxmodx2/custom"
localinfo amxx_datadir "addons/amxmodx2/data"
localinfo amxx_logdir "addons/amxmodx2/logs"
localinfo amxx_logs "addons/amxmodx2/logs"
localinfo amxx_modules "addons/amxmodx2/configs/modules.ini"
localinfo amxx_modulesdir "addons/amxmodx2/modules"
localinfo amxx_plugins "addons/amxmodx2/configs/plugins.ini"
localinfo amxx_pluginsdir "addons/amxmodx2/plugins"
localinfo amxx_vault "addons/amxmodx2/data/vault.ini"
localinfo csstats "addons/amxmodx2/data/csstats.dat"
localinfo csstats_score "addons/amxmodx2/data/csstats.amxx"
localinfo amx_basedir "addons/amxmodx2"
localinfo amx_configdir "addons/amxmodx2/configs"
localinfo amx_langdir "addons/amxmodx2/data/amxmod-lang"
localinfo amx_logdir "addons/amxmodx2/logs"
localinfo amx_modulesdir "addons/amxmodx2/modules"
localinfo amx_pluginsdir "addons/amxmodx2/plugins"</pre>
:* Теперь второй сервер необходимо будет запускать с параметром командной строки: ''+exec amxmodx2.cfg''

= Вопросы по плагинам =
== Общие вопросы ==
=== Где и как искать плагины? ===
: Предварительно отметим, что условно AMX Mod X плагины можно разделить на следующие категории: стандартные, официально одобренные, официально отклоненные и неофициальные. Одобренные плагины можно искать [http://www.amxmodx.org/compiler.php здесь], или, используя [http://forums.alliedmods.net/search.php поисковую систему официального форума]. В поле '''Search in Forum(s)''' отметьте '''Approved Plugins''', также, зажав клавишу Ctrl, можно отметить интересующие вас секции из подраздела '''High-Traffic Plugins'''. Чтобы искать неофициальные плагины, следует также воспользоваться [http://forums.alliedmods.net/search.php поисковой системой официального форума], правда, в поле '''Search in Forum(s)''' необходимо выбрать '''Unapproved/Old Plugins'''. Если для вас не имеет значения статус плагина, и вы склонны к экспериментам, осуществляйте поиск по категории '''Plugins''', которая включает в себя одобренные, отклоненные, недавно опубликованные, вполне возможно, "сырые" плагины, а также темы-запросы, в которых могут быть "быстро написанные" плагины. Особенность поиска на официальных форумах еще состоит в том, что при вводе слова система ищет именно слова (без учета регистра), т.е. фрагменты, разделенные слева и справа пробелами. Т.о., к примеру, набрав для поиска слово ''FCOS'' вы не найдете нужного вам плагина, хотя есть тема, в которой присутствует текст ''[fcos]''. Для этого надо использовать в поиске строку ''*FCOS*''. Немного поработав с поисковой формой форума, вы легко освоите эту систему. Единственное возможное для некоторых неудобство - практически все описания плагинов написаны на английcком языке. Неофициальные плагины также можно попробовать искать с помощью общеизвестных поисковых систем: Google, Yandex, Rambler и др.

=== Сколько плагинов сейчас выпущено под AMX Mod X? ===
: "Тонны" плагинов. Но, к сожалению, качеством и надежностью б'''о'''льшая половина из них не белещет. К тому же некоторые плагины, "заброшены" авторами и не обновляются, что приводит даже к несовместимости с новыми версиями AMX Mod X.

=== Как устанавливать плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Как удалять плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Что такое стандартные плагины? ===
: Это плагины, которые входят в стандартную поставку AMX Mod X. Они находятся в папке $AMXMODX\scripting.

=== Как узнать, в каком плагине зарегистрирована та или иная переменная? ===
: В серверной консоли наберите команду ''amxx cvars''. Выделите текст, скопируйте в файл, там сделайте поиск искомой переменной. В правой колонке будет стоять имя плагина, в котором она и зарегистрирована.

=== Я перевел на русский языковой файл плагина, а текст в игре отображается криво ===
: Скорее всего вы не сохранили файл в UTF-8 кодировке. Даже если вы это сделали, проверьте что в начале файле нет маркера кодировки, потому что некоторые редакторы его вставляют без предупреждения. Для этого надо использовать редактор или режим, который НЕ понимает UTF-8, потому что unicode редактор не отображает такой маркер.
: Имейте в виду, что в консоли сервера, работающего в режиме ''-console'', переведенный текст не будет отображаться по-русски.

=== Как называется статистика, встроенная в AMXX? ===
: Называется "StatsX", реализована в виде плагинов ''statsx.amxx'', ''statscfg.amxx'', ''stats_logging.amxx'', а также в модуле ''csx''. О последнем многие забывают, полагая, что можно просто изменить алгоритм учета статистики на уровне плагинов AMXX.

== Вопросы по стандартным плагинам ==
=== Как увеличить число карт в стандартном голосовании? ===
: Откройте файл $AMXMODX\scripting\mapchooser.sma, замените число 3 в строке
#define SELECTMAPS 3
: на требуемое, затем [[#Как компилировать плагины?|откомпилируйте]] плагин и замените исходный.

=== Как увеличить число администраторов? ===
: В файле ''admin.sma'' замените число 64 на требуемое значение в строке:
#define MAX_ADMINS 64
: Не ставьте слишком большие значения. Не забудьте [[#Как компилировать плагины?|перекомпилировать]] плагин и заменить исходный новым.
: В AMXX 1.8.X и выше такая проблема не стоит, т.к. там реализован динамический список админов.

=== Почему клиент не получает права админа по IP? ===
:Данная проблема возникает на публичных Non-Steam (патченных) интернет-серверах c sv_lan = 0 при подключении Steam/Non-Steam клиентов.
: Сначала убедитесь, что у вас нединамический внешний IP. Динамический IP означает, что каждый раз, подключась к Интернету, вам назначается новый внешний IP (обычно из какого-то фиксированного диапазона). Для этого обратитесь к вашему провайдеру. Далее необходимо сверить, правильно ли вы прописали доступ в файле users.ini. Для этого проверьте свой внешний IP на страничке [http://myip.ru/ myip.ru]. Запомните его. Откройте файл user.ini и убедитесь что там есть такая запись:
"<ваш_ip>" "<ваш_пароль>" "<ваши_флаги>" "d<другие_модификаторы>"
:В поле ''<ваш_ip>'' должен быть вбит запомненный ранее IP. Обратите внимание на модификатор '''d'''. Без него проверка на IP проводиться НЕ будет. При указании IP старайтесь не использовать номер порта (знак двоеточия и то, что справа от него).
: Если все правильно, а вы все равно не становитесь администратором на сервере, то, скорее всего, проблема в том, что вы не прошли авторизацию на сервере. Для этого выполните команду ''users'' или ''stat'' в консоли сервера и обратите внимание на значение в колонке ''userid''. Если напротив потенциального админа стоит '''VALVE_ID_PENDING''', то это означает, что сервер криво заломан, и он не авторизовал данного игрока. В свою очередь это значит, что функция ''client_authorized(id)'' не была вызвана для всех(!) активных AMXX плагинов. Если открыть файл ''admin.sma'', то можно увидеть следующее:
public client_authorized(id)
return get_cvar_num("amx_mode") ? accessUser(id) : PLUGIN_CONTINUE
: Это и есть проверка клиента на админа. Чтобы эта функция вызывалась всегда, ''client_authorized'' надо переименовать в ''client_putinserver'', а существующую функцию ''client_putinserver'' либо удалить, либо [[Ru_Fundamental_Basics_of_AMX_Mod_X_Scripting#Комментарии|закомментировать]].

=== Как заставить команду amx_who выводить IP вместо ID? ===
: В файле ''admincmd.sma'' в указанном ниже месте
public cmdWho(id, level, cid)
{
...
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
for (new a = 0; a < inum; ++a)
{
get_user_authid(players[a], authid, 31)
...
}
...
}
:замените
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
: на
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "ip", "userid", lImm, lRes, lAccess)
: а также
get_user_authid(players[a], authid, 31)
: на
get_user_ip(players[a], authid, 31, 1)
: Сохраните файл и [[#Как компилировать плагины?|перекомпилируйте]] плагин.

=== А как дать всем доступ к команде amx_who? ===
: По умолчанию, команда доступна только игрокам с правами '''y''' (т.е. это признак админа). Чтобы разрешить пользоваться ею всем игрокам, надо открыть файл ''admincmd.sma'', и в строке
register_concmd("amx_who", "cmdWho", ADMIN_ADMIN, "- displays who is on server")
: заменить ''ADMIN_ADMIN'' на ''ADMIN_ALL'' и [[#Как компилировать плагины?|перекомпилировать]] плагин.
: В AMX 1.8.X и выше доступны стандартные средства переопределения прав доступа к командам без исправления самих плагинов (''TODO: ссылка?'').

=== Как очистить статистику StatsX? ===
: Удалите файл ''$AMXMODX/data/csstats.dat''.

= Вопросы по компилированию =
=== Что такое компиляция? ===
: Это процесс, который переводит текстовые файлы (*.sma), содержащие исходный код (т.е. инструкции для AMX Mod X, который их исполняет), в формат, более пригодный для исполнения. За счет этого скорость выполнения плагинов возрастает многократно, упрощается разработка "движка", который эти плагины исполняет, а также в некотором смысле защищается авторский код. Почему в "некотором смысле"? Потому что все AMX Mod X плагины должны публиковаться под лицензией GNU General Public License. В случае публикации плагина лицензия обязывает также публиковать и его исходный код. Откомпилированные плагины имеют расширение .amxx. Именно файлы этого типа, а не .sma, должны указываться в файле plugins.ini для последующей корректной загрузки плагина.

=== Как компилировать плагины? ===
: Базовую информацию вы можете найти на [[Ru Compiling Plugins (AMX Mod X)|этой]] странице.

=== Как упростить процесс компилирования? ===
: Можно написать стороннюю программу или скрипт, например такой, как пакетный batch файл. Например, создайте файл make.bat со следующим содержимым:
@amxxpc.exe %1 -i.\include -o.\compiled\%1
: Чтобы с помощью него откомпилировать плагин, необходимо выполнить следующую команду:
make.bat my_plugin.sma
: В итоге откомпилированный файл будет помещен в каталог ''compiled'' текущей директории. Если его там нет, значит в процессе компилирования возникли фатальные ошибки, которые выводятся на экран.
: Если вам необходимо (например, в случае ошибок) отправить кому-нибудь результат компиляции, можете перенаправить вывод информации о процессе компилирования в файл, например таким образом:
make.bat my_plugin.sma > my_plugin.log

=== Компилятор выводит "max. usage is unknown, due to recursion" ===
: Ничего страшного - просто компилятор не может вычислить предполагаемый объем памяти, используемый вашим плагином.

= Вопросы по скриптингу =
=== С чего начать? ===
: С со статьи [[Ru Fundamental Basics of AMX Mod X Scripting|Фундаментальные основы AMX Mod X скриптинга]].

=== А стоит ли вообще начинать? ===
: В зависимости от того, какую цель вы преследуете, а также от вашего желания и потенциала. Знание английского языка (чтение) будет огромным плюсом во время обучения, иначе постигать азы будет очень сложно. CS является закрытым проектом без исходных кодов, поэтому могие новые (неизученные) элементы приходится постигать через проведение экспериментов.

Ru AMX Mod X FAQ

2008-08-02T10:17:35Z

Simon Logic: + Как называется статистика, встроенная в AMXX?

[[Category:Russian]]
[[Category:Ru:AMX Mod X]]

= Общие положения, термины, сокращения и условные обозначения =
:* HL или HL1 - аббревиатура от [[Half-Life 1|Half-Life]] (часть первая);
:* Mod - "мод", модификация - дополнение к чему-либо, как правило, расширяющее/изменяющее функциональность;
:* HL Engine - "движок" Half-Life - "центральный модуль", осуществляющий выполнение базовых "общемодовых" задач;
:* MM - [[Metamod]] - сторонний мод особого типа, является промежуточным звеном в системе "HL движок - HL мод";
:* AMXX - аббревиатура от [[AMX Mod X]] - Metamod plugin ("плагин"), своего рода Metamod мод;
:* Map - "карта" - определяет внешний вид территории, на которой происходит игровое действие;
:* World - "мир" - все пространство, которое занимает карта, а также область, находящаяся за картой;
:* Spawn - "спавн" - момент, когда игрок появляется в мире, обретая физическое тело;
:* SinglePlayer - "синглплеер" - игровой тип, когда одновременно в игре может участвовать только один игрок;
:* MultiPlayer - "мультиплеер" - игровой тип, когда одновременно в игре может участвовать несколько игроков;
:* DM - аббревиатура от Death Match - динамичный мультиплеер тип игры, когда после "смерти" игрока происходит его скорый спавн ("респавн");
:* HLDM - аббревиатура от Half-Life Death Match - оригинальный HL мод DM типа;
:* CS - аббревиатура от [[Counter-Stirke]] - наиболее популярный HL мод;
:* VALVE - [[VALVe Software|корпорация, разработчик HL и CS]], также редко используется как синоним HLDM, подчеркивая название директории мода ("valve");
:* $MODDIR - способ условного обозначения корневой директории мода, например: ''cstrike'', ''valve'';
:* $MMDIR - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории Metamod, по-умолчанию: ''addons/metamod'';
:* $AMXMODX - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории AMX Mod X, по-умолчанию: ''addons/amxmodx''.

= Общие вопросы =
=== Где скачать последнюю версию AMX Mod X? ===
: Последнюю версию всегда можно скачать на официальном сайте AMX Mod X в [http://www.amxmodx.org/downloads.php разделе закачек].

=== А что именно качать? ===
: Качайте либо инсталлятор (AMX Mod X Full Installer), который включает базовый AMX Mod X пакет, все AMX Mod X дополнения для HL модов, а также AMXX-Studio (специализированный редактор AMX Mod X плагинов), либо, если готовы произвести установку AMX Mod X вручную, а также не желаете закачивать все существующие AMX Mod X дополнения для HL модов, качайте базовый архив (AMX Mod X Base), а затем дополнение для интересующего вас HL мода. Сама по себе базовая поставка практически во всех случаях будет достаточна только для HLDM мода.

=== Чем отличается AMX Mod X от AMX Mod? ===
: Буквой X ;). На самом деле отличий очень много:
:* AMXX поддерживается до сих пор, а поддержка AMX Mod была завершена примерно в 2006 году;
:* функциональность AMXX значительно превосходит AMX Mod, это также касается и расширенной поддержки других модов, в то время как AMX Mod поддерживал только HLDM, CS и CZ;
:* AMXX принято считать быстрее AMX Mod;
:* плагины AMXX не совместимы с плагинами AMX Mod;
:* плагины AMX Mod 0.9.9 совместимы с AMXX, если последний работает в режиме совместимости(?);
:* плагины для AMX Mod имеют расширение .amx, а плагины AMXX - .amxx;
:* ''TODO: дополнить список''

=== Как запустить два различных сервера AMX Mod X? ===
: К примеру, вы хотите запустить два различных сервера из одной ''cstrike'' директории на базе различных AMX Mod X/Metamod плагинов, настроек и прочего. Это решаемо. Один из примеров для win32 системы приведен ниже:
:* Создать отдельную AMX Mod X директорию с необходимыми файлами, например: ''addons/amxmodx2''
:* В ''addons/amxmodx2/configs/core.ini'' везде изменить "amxmodx" на "amxmodx2"
:* Создать отдельный файл загрузки Metamod плагинов, например: ''addons/metamod/plugins2.ini''
:* В созданный ''plugins2.ini'' файл вписать: ''win32 addons\amxmodx2\dlls\amxmodx_mm.dll''
:* Создать в директории ''cstrike'' файл, например, с именем ''amxmodx2.cfg'', его содержимое должно быть следующим:
<pre>localinfo mm_pluginsfile "addons/metamod/plugins2.ini"
localinfo amxx_basedir "addons/amxmodx2"
localinfo amxx_cfg "addons/amxmodx2/configs/core.ini"
localinfo amxx_configsdir "addons/amxmodx2/configs"
localinfo amxx_customdir "addons/amxmodx2/custom"
localinfo amxx_datadir "addons/amxmodx2/data"
localinfo amxx_logdir "addons/amxmodx2/logs"
localinfo amxx_logs "addons/amxmodx2/logs"
localinfo amxx_modules "addons/amxmodx2/configs/modules.ini"
localinfo amxx_modulesdir "addons/amxmodx2/modules"
localinfo amxx_plugins "addons/amxmodx2/configs/plugins.ini"
localinfo amxx_pluginsdir "addons/amxmodx2/plugins"
localinfo amxx_vault "addons/amxmodx2/data/vault.ini"
localinfo csstats "addons/amxmodx2/data/csstats.dat"
localinfo csstats_score "addons/amxmodx2/data/csstats.amxx"
localinfo amx_basedir "addons/amxmodx2"
localinfo amx_configdir "addons/amxmodx2/configs"
localinfo amx_langdir "addons/amxmodx2/data/amxmod-lang"
localinfo amx_logdir "addons/amxmodx2/logs"
localinfo amx_modulesdir "addons/amxmodx2/modules"
localinfo amx_pluginsdir "addons/amxmodx2/plugins"</pre>
:* Теперь второй сервер необходимо будет запускать с параметром командной строки: ''+exec amxmodx2.cfg''

= Вопросы по плагинам =
== Общие вопросы ==
=== Где и как искать плагины? ===
: Предварительно отметим, что условно AMX Mod X плагины можно разделить на следующие категории: стандартные, официально одобренные, официально отклоненные и неофициальные. Одобренные плагины можно искать [http://www.amxmodx.org/compiler.php здесь], или, используя [http://forums.alliedmods.net/search.php поисковую систему официального форума]. В поле '''Search in Forum(s)''' отметьте '''Approved Plugins''', также, зажав клавишу Ctrl, можно отметить интересующие вас секции из подраздела '''High-Traffic Plugins'''. Чтобы искать неофициальные плагины, следует также воспользоваться [http://forums.alliedmods.net/search.php поисковой системой официального форума], правда, в поле '''Search in Forum(s)''' необходимо выбрать '''Unapproved/Old Plugins'''. Если для вас не имеет значения статус плагина, и вы склонны к экспериментам, осуществляйте поиск по категории '''Plugins''', которая включает в себя одобренные, отклоненные, недавно опубликованные, вполне возможно, "сырые" плагины, а также темы-запросы, в которых могут быть "быстро написанные" плагины. Особенность поиска на официальных форумах еще состоит в том, что при вводе слова система ищет именно слова (без учета регистра), т.е. фрагменты, разделенные слева и справа пробелами. Т.о., к примеру, набрав для поиска слово ''FCOS'' вы не найдете нужного вам плагина, хотя есть тема, в которой присутствует текст ''[fcos]''. Для этого надо использовать в поиске строку ''*FCOS*''. Немного поработав с поисковой формой форума, вы легко освоите эту систему. Единственное возможное для некоторых неудобство - практически все описания плагинов написаны на английcком языке. Неофициальные плагины также можно попробовать искать с помощью общеизвестных поисковых систем: Google, Yandex, Rambler и др.

=== Сколько плагинов сейчас выпущено под AMX Mod X? ===
: "Тонны" плагинов. Но, к сожалению, качеством и надежностью б'''о'''льшая половина из них не белещет. К тому же некоторые плагины, "заброшены" авторами и не обновляются, что приводит даже к несовместимости с новыми версиями AMX Mod X.

=== Как устанавливать плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Как удалять плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Что такое стандартные плагины? ===
: Это плагины, которые входят в стандартную поставку AMX Mod X. Они находятся в папке $AMXMODX\scripting.

=== Как узнать, в каком плагине зарегистрирована та или иная переменная? ===
: В серверной консоли наберите команду ''amxx cvars''. Выделите текст, скопируйте в файл, там сделайте поиск искомой переменной. В правой колонке будет стоять имя плагина, в котором она и зарегистрирована.

=== Я перевел на русский языковой файл плагина, а текст в игре отображается криво ===
: Скорее всего вы не сохранили файл в UTF-8 кодировке. Даже если вы это сделали, проверьте что в начале файле нет маркера кодировки, потому что некоторые редакторы его вставляют без предупреждения. Для этого надо использовать редактор или режим, который НЕ понимает UTF-8, потому что unicode редактор не отображает такой маркер.
: Имейте в виду, что в консоли сервера, работающего в режиме ''-console'', переведенный текст не будет отображаться по-русски.

=== Как называется статистика, встроенная в AMXX? ===
: Называется "StatsX", реализована в виде плагинов ''statsx.amxx'', ''statscfg.amxx'', ''stats_logging.amxx'', а также в модуле ''csx''. О последнем многие забывают, полагая, что можно просто изменить алгоритм учета статистики на уровне плагинов AMXX.

== Вопросы по стандартным плагинам ==
=== Как увеличить число карт в стандартном голосовании? ===
: Откройте файл $AMXMODX\scripting\mapchooser.sma, замените число 3 в строке
#define SELECTMAPS 3
: на требуемое, затем [[#Как компилировать плагины?|откомпилируйте]] плагин и замените исходный.

=== Как увеличить число администраторов? ===
: В файле ''admin.sma'' замените число 64 на требуемое значение в строке:
#define MAX_ADMINS 64
: Не ставьте слишком большие значения. Не забудьте [[#Как компилировать плагины?|перекомпилировать]] плагин и заменить исходный новым.
: В AMXX 1.8.X и выше такая проблема не стоит, т.к. там реализован динамический список админов.

=== Почему клиент не получает права админа по IP? ===
:Данная проблема возникает на публичных Non-Steam (патченных) интернет-серверах c sv_lan = 0 при подключении Steam/Non-Steam клиентов.
: Сначала убедитесь, что у вас нединамический внешний IP. Динамический IP означает, что каждый раз, подключась к Интернету, вам назначается новый внешний IP (обычно из какого-то фиксированного диапазона). Для этого обратитесь к вашему провайдеру. Далее необходимо сверить, правильно ли вы прописали доступ в файле users.ini. Для этого проверьте свой внешний IP на страничке [http://myip.ru/ myip.ru]. Запомните его. Откройте файл user.ini и убедитесь что там есть такая запись:
"<ваш_ip>" "<ваш_пароль>" "<ваши_флаги>" "d<другие_модификаторы>"
:В поле ''<ваш_ip>'' должен быть вбит запомненный ранее IP. Обратите внимание на модификатор '''d'''. Без него проверка на IP проводиться НЕ будет. При указании IP старайтесь не использовать номер порта (знак двоеточия и то, что справа от него).
: Если все правильно, а вы все равно не становитесь администратором на сервере, то, скорее всего, проблема в том, что вы не прошли авторизацию на сервере. Для этого выполните команду ''users'' или ''stat'' в консоли сервера и обратите внимание на значение в колонке ''userid''. Если напротив потенциального админа стоит '''VALVE_ID_PENDING''', то это означает, что сервер криво заломан, и он не авторизовал данного игрока. В свою очередь это значит, что функция ''client_authorized(id)'' не была вызвана для всех(!) активных AMXX плагинов. Если открыть файл ''admin.sma'', то можно увидеть следующее:
public client_authorized(id)
return get_cvar_num("amx_mode") ? accessUser(id) : PLUGIN_CONTINUE
: Это и есть проверка клиента на админа. Чтобы эта функция вызывалась всегда, ''client_authorized'' надо переименовать в ''client_putinserver'', а существующую функцию ''client_putinserver'' либо удалить, либо [[Ru_Fundamental_Basics_of_AMX_Mod_X_Scripting#Комментарии|закомментировать]].

=== Как заставить команду amx_who выводить IP вместо ID? ===
: В файле ''admincmd.sma'' в указанном ниже месте
public cmdWho(id, level, cid)
{
...
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
for (new a = 0; a < inum; ++a)
{
get_user_authid(players[a], authid, 31)
...
}
...
}
:замените
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
: на
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "ip", "userid", lImm, lRes, lAccess)
: а также
get_user_authid(players[a], authid, 31)
: на
get_user_ip(players[a], authid, 31, 1)
: Сохраните файл и [[#Как компилировать плагины?|перекомпилируйте]] плагин.

=== А как дать всем доступ к команде amx_who? ===
: По умолчанию, команда доступна только игрокам с правами '''y''' (т.е. это признак админа). Чтобы разрешить пользоваться ею всем игрокам, надо открыть файл ''admincmd.sma'', и в строке
register_concmd("amx_who", "cmdWho", ADMIN_ADMIN, "- displays who is on server")
: заменить ''ADMIN_ADMIN'' на ''ADMIN_ALL'' и [[#Как компилировать плагины?|перекомпилировать]] плагин.
: В AMX 1.8.X и выше доступны стандартные средства переопределения прав доступа к командам без исправления самих плагинов (''TODO: ссылка?'').

= Вопросы по компилированию =
=== Что такое компиляция? ===
: Это процесс, который переводит текстовые файлы (*.sma), содержащие исходный код (т.е. инструкции для AMX Mod X, который их исполняет), в формат, более пригодный для исполнения. За счет этого скорость выполнения плагинов возрастает многократно, упрощается разработка "движка", который эти плагины исполняет, а также в некотором смысле защищается авторский код. Почему в "некотором смысле"? Потому что все AMX Mod X плагины должны публиковаться под лицензией GNU General Public License. В случае публикации плагина лицензия обязывает также публиковать и его исходный код. Откомпилированные плагины имеют расширение .amxx. Именно файлы этого типа, а не .sma, должны указываться в файле plugins.ini для последующей корректной загрузки плагина.

=== Как компилировать плагины? ===
: Базовую информацию вы можете найти на [[Ru Compiling Plugins (AMX Mod X)|этой]] странице.

=== Как упростить процесс компилирования? ===
: Можно написать стороннюю программу или скрипт, например такой, как пакетный batch файл. Например, создайте файл make.bat со следующим содержимым:
@amxxpc.exe %1 -i.\include -o.\compiled\%1
: Чтобы с помощью него откомпилировать плагин, необходимо выполнить следующую команду:
make.bat my_plugin.sma
: В итоге откомпилированный файл будет помещен в каталог ''compiled'' текущей директории. Если его там нет, значит в процессе компилирования возникли фатальные ошибки, которые выводятся на экран.
: Если вам необходимо (например, в случае ошибок) отправить кому-нибудь результат компиляции, можете перенаправить вывод информации о процессе компилирования в файл, например таким образом:
make.bat my_plugin.sma > my_plugin.log

=== Компилятор выводит "max. usage is unknown, due to recursion" ===
: Ничего страшного - просто компилятор не может вычислить предполагаемый объем памяти, используемый вашим плагином.

= Вопросы по скриптингу =
=== С чего начать? ===
: С со статьи [[Ru Fundamental Basics of AMX Mod X Scripting|Фундаментальные основы AMX Mod X скриптинга]].

=== А стоит ли вообще начинать? ===
: В зависимости от того, какую цель вы преследуете, а также от вашего желания и потенциала. Знание английского языка (чтение) будет огромным плюсом во время обучения, иначе постигать азы будет очень сложно. CS является закрытым проектом без исходных кодов, поэтому могие новые (неизученные) элементы приходится постигать через проведение экспериментов.

Ru AMX Mod X FAQ

2008-08-02T09:40:04Z

Simon Logic: /* Как узнать, в каком плагине зарегистрирована та или иная переменная? */

[[Category:Russian]]
[[Category:Ru:AMX Mod X]]

= Общие положения, термины, сокращения и условные обозначения =
:* HL или HL1 - аббревиатура от [[Half-Life 1|Half-Life]] (часть первая);
:* Mod - "мод", модификация - дополнение к чему-либо, как правило, расширяющее/изменяющее функциональность;
:* HL Engine - "движок" Half-Life - "центральный модуль", осуществляющий выполнение базовых "общемодовых" задач;
:* MM - [[Metamod]] - сторонний мод особого типа, является промежуточным звеном в системе "HL движок - HL мод";
:* AMXX - аббревиатура от [[AMX Mod X]] - Metamod plugin ("плагин"), своего рода Metamod мод;
:* Map - "карта" - определяет внешний вид территории, на которой происходит игровое действие;
:* World - "мир" - все пространство, которое занимает карта, а также область, находящаяся за картой;
:* Spawn - "спавн" - момент, когда игрок появляется в мире, обретая физическое тело;
:* SinglePlayer - "синглплеер" - игровой тип, когда одновременно в игре может участвовать только один игрок;
:* MultiPlayer - "мультиплеер" - игровой тип, когда одновременно в игре может участвовать несколько игроков;
:* DM - аббревиатура от Death Match - динамичный мультиплеер тип игры, когда после "смерти" игрока происходит его скорый спавн ("респавн");
:* HLDM - аббревиатура от Half-Life Death Match - оригинальный HL мод DM типа;
:* CS - аббревиатура от [[Counter-Stirke]] - наиболее популярный HL мод;
:* VALVE - [[VALVe Software|корпорация, разработчик HL и CS]], также редко используется как синоним HLDM, подчеркивая название директории мода ("valve");
:* $MODDIR - способ условного обозначения корневой директории мода, например: ''cstrike'', ''valve'';
:* $MMDIR - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории Metamod, по-умолчанию: ''addons/metamod'';
:* $AMXMODX - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории AMX Mod X, по-умолчанию: ''addons/amxmodx''.

= Общие вопросы =
=== Где скачать последнюю версию AMX Mod X? ===
: Последнюю версию всегда можно скачать на официальном сайте AMX Mod X в [http://www.amxmodx.org/downloads.php разделе закачек].

=== А что именно качать? ===
: Качайте либо инсталлятор (AMX Mod X Full Installer), который включает базовый AMX Mod X пакет, все AMX Mod X дополнения для HL модов, а также AMXX-Studio (специализированный редактор AMX Mod X плагинов), либо, если готовы произвести установку AMX Mod X вручную, а также не желаете закачивать все существующие AMX Mod X дополнения для HL модов, качайте базовый архив (AMX Mod X Base), а затем дополнение для интересующего вас HL мода. Сама по себе базовая поставка практически во всех случаях будет достаточна только для HLDM мода.

=== Чем отличается AMX Mod X от AMX Mod? ===
: Буквой X ;). На самом деле отличий очень много:
:* AMXX поддерживается до сих пор, а поддержка AMX Mod была завершена примерно в 2006 году;
:* функциональность AMXX значительно превосходит AMX Mod, это также касается и расширенной поддержки других модов, в то время как AMX Mod поддерживал только HLDM, CS и CZ;
:* AMXX принято считать быстрее AMX Mod;
:* плагины AMXX не совместимы с плагинами AMX Mod;
:* плагины AMX Mod 0.9.9 совместимы с AMXX, если последний работает в режиме совместимости(?);
:* плагины для AMX Mod имеют расширение .amx, а плагины AMXX - .amxx;
:* ''TODO: дополнить список''

=== Как запустить два различных сервера AMX Mod X? ===
: К примеру, вы хотите запустить два различных сервера из одной ''cstrike'' директории на базе различных AMX Mod X/Metamod плагинов, настроек и прочего. Это решаемо. Один из примеров для win32 системы приведен ниже:
:* Создать отдельную AMX Mod X директорию с необходимыми файлами, например: ''addons/amxmodx2''
:* В ''addons/amxmodx2/configs/core.ini'' везде изменить "amxmodx" на "amxmodx2"
:* Создать отдельный файл загрузки Metamod плагинов, например: ''addons/metamod/plugins2.ini''
:* В созданный ''plugins2.ini'' файл вписать: ''win32 addons\amxmodx2\dlls\amxmodx_mm.dll''
:* Создать в директории ''cstrike'' файл, например, с именем ''amxmodx2.cfg'', его содержимое должно быть следующим:
<pre>localinfo mm_pluginsfile "addons/metamod/plugins2.ini"
localinfo amxx_basedir "addons/amxmodx2"
localinfo amxx_cfg "addons/amxmodx2/configs/core.ini"
localinfo amxx_configsdir "addons/amxmodx2/configs"
localinfo amxx_customdir "addons/amxmodx2/custom"
localinfo amxx_datadir "addons/amxmodx2/data"
localinfo amxx_logdir "addons/amxmodx2/logs"
localinfo amxx_logs "addons/amxmodx2/logs"
localinfo amxx_modules "addons/amxmodx2/configs/modules.ini"
localinfo amxx_modulesdir "addons/amxmodx2/modules"
localinfo amxx_plugins "addons/amxmodx2/configs/plugins.ini"
localinfo amxx_pluginsdir "addons/amxmodx2/plugins"
localinfo amxx_vault "addons/amxmodx2/data/vault.ini"
localinfo csstats "addons/amxmodx2/data/csstats.dat"
localinfo csstats_score "addons/amxmodx2/data/csstats.amxx"
localinfo amx_basedir "addons/amxmodx2"
localinfo amx_configdir "addons/amxmodx2/configs"
localinfo amx_langdir "addons/amxmodx2/data/amxmod-lang"
localinfo amx_logdir "addons/amxmodx2/logs"
localinfo amx_modulesdir "addons/amxmodx2/modules"
localinfo amx_pluginsdir "addons/amxmodx2/plugins"</pre>
:* Теперь второй сервер необходимо будет запускать с параметром командной строки: ''+exec amxmodx2.cfg''

= Вопросы по плагинам =
== Общие вопросы ==
=== Где и как искать плагины? ===
: Предварительно отметим, что условно AMX Mod X плагины можно разделить на следующие категории: стандартные, официально одобренные, официально отклоненные и неофициальные. Одобренные плагины можно искать [http://www.amxmodx.org/compiler.php здесь], или, используя [http://forums.alliedmods.net/search.php поисковую систему официального форума]. В поле '''Search in Forum(s)''' отметьте '''Approved Plugins''', также, зажав клавишу Ctrl, можно отметить интересующие вас секции из подраздела '''High-Traffic Plugins'''. Чтобы искать неофициальные плагины, следует также воспользоваться [http://forums.alliedmods.net/search.php поисковой системой официального форума], правда, в поле '''Search in Forum(s)''' необходимо выбрать '''Unapproved/Old Plugins'''. Если для вас не имеет значения статус плагина, и вы склонны к экспериментам, осуществляйте поиск по категории '''Plugins''', которая включает в себя одобренные, отклоненные, недавно опубликованные, вполне возможно, "сырые" плагины, а также темы-запросы, в которых могут быть "быстро написанные" плагины. Особенность поиска на официальных форумах еще состоит в том, что при вводе слова система ищет именно слова (без учета регистра), т.е. фрагменты, разделенные слева и справа пробелами. Т.о., к примеру, набрав для поиска слово ''FCOS'' вы не найдете нужного вам плагина, хотя есть тема, в которой присутствует текст ''[fcos]''. Для этого надо использовать в поиске строку ''*FCOS*''. Немного поработав с поисковой формой форума, вы легко освоите эту систему. Единственное возможное для некоторых неудобство - практически все описания плагинов написаны на английcком языке. Неофициальные плагины также можно попробовать искать с помощью общеизвестных поисковых систем: Google, Yandex, Rambler и др.

=== Сколько плагинов сейчас выпущено под AMX Mod X? ===
: "Тонны" плагинов. Но, к сожалению, качеством и надежностью б'''о'''льшая половина из них не белещет. К тому же некоторые плагины, "заброшены" авторами и не обновляются, что приводит даже к несовместимости с новыми версиями AMX Mod X.

=== Как устанавливать плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Как удалять плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Что такое стандартные плагины? ===
: Это плагины, которые входят в стандартную поставку AMX Mod X. Они находятся в папке $AMXMODX\scripting.

=== Как узнать, в каком плагине зарегистрирована та или иная переменная? ===
: В серверной консоли наберите команду ''amxx cvars''. Выделите текст, скопируйте в файл, там сделайте поиск искомой переменной. В правой колонке будет стоять имя плагина, в котором она и зарегистрирована.

=== Я перевел на русский языковой файл плагина, а текст в игре отображается криво ===
: Скорее всего вы не сохранили файл в UTF-8 кодировке. Даже если вы это сделали, проверьте что в начале файле нет маркера кодировки, потому что некоторые редакторы его вставляют без предупреждения. Для этого надо использовать редактор или режим, который НЕ понимает UTF-8, потому что unicode редактор не отображает такой маркер.
: Имейте в виду, что в консоли сервера, работающего в режиме ''-console'', переведенный текст не будет отображаться по-русски.

== Вопросы по стандартным плагинам ==
=== Как увеличить число карт в стандартном голосовании? ===
: Откройте файл $AMXMODX\scripting\mapchooser.sma, замените число 3 в строке
#define SELECTMAPS 3
: на требуемое, затем [[#Как компилировать плагины?|откомпилируйте]] плагин и замените исходный.

=== Как увеличить число администраторов? ===
: В файле ''admin.sma'' замените число 64 на требуемое значение в строке:
#define MAX_ADMINS 64
: Не ставьте слишком большие значения. Не забудьте [[#Как компилировать плагины?|перекомпилировать]] плагин и заменить исходный новым.
: В AMXX 1.8.X и выше такая проблема не стоит, т.к. там реализован динамический список админов.

=== Почему клиент не получает права админа по IP? ===
:Данная проблема возникает на публичных Non-Steam (патченных) интернет-серверах c sv_lan = 0 при подключении Steam/Non-Steam клиентов.
: Сначала убедитесь, что у вас нединамический внешний IP. Динамический IP означает, что каждый раз, подключась к Интернету, вам назначается новый внешний IP (обычно из какого-то фиксированного диапазона). Для этого обратитесь к вашему провайдеру. Далее необходимо сверить, правильно ли вы прописали доступ в файле users.ini. Для этого проверьте свой внешний IP на страничке [http://myip.ru/ myip.ru]. Запомните его. Откройте файл user.ini и убедитесь что там есть такая запись:
"<ваш_ip>" "<ваш_пароль>" "<ваши_флаги>" "d<другие_модификаторы>"
:В поле ''<ваш_ip>'' должен быть вбит запомненный ранее IP. Обратите внимание на модификатор '''d'''. Без него проверка на IP проводиться НЕ будет. При указании IP старайтесь не использовать номер порта (знак двоеточия и то, что справа от него).
: Если все правильно, а вы все равно не становитесь администратором на сервере, то, скорее всего, проблема в том, что вы не прошли авторизацию на сервере. Для этого выполните команду ''users'' или ''stat'' в консоли сервера и обратите внимание на значение в колонке ''userid''. Если напротив потенциального админа стоит '''VALVE_ID_PENDING''', то это означает, что сервер криво заломан, и он не авторизовал данного игрока. В свою очередь это значит, что функция ''client_authorized(id)'' не была вызвана для всех(!) активных AMXX плагинов. Если открыть файл ''admin.sma'', то можно увидеть следующее:
public client_authorized(id)
return get_cvar_num("amx_mode") ? accessUser(id) : PLUGIN_CONTINUE
: Это и есть проверка клиента на админа. Чтобы эта функция вызывалась всегда, ''client_authorized'' надо переименовать в ''client_putinserver'', а существующую функцию ''client_putinserver'' либо удалить, либо [[Ru_Fundamental_Basics_of_AMX_Mod_X_Scripting#Комментарии|закомментировать]].

=== Как заставить команду amx_who выводить IP вместо ID? ===
: В файле ''admincmd.sma'' в указанном ниже месте
public cmdWho(id, level, cid)
{
...
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
for (new a = 0; a < inum; ++a)
{
get_user_authid(players[a], authid, 31)
...
}
...
}
:замените
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
: на
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "ip", "userid", lImm, lRes, lAccess)
: а также
get_user_authid(players[a], authid, 31)
: на
get_user_ip(players[a], authid, 31, 1)
: Сохраните файл и [[#Как компилировать плагины?|перекомпилируйте]] плагин.

=== А как дать всем доступ к команде amx_who? ===
: По умолчанию, команда доступна только игрокам с правами '''y''' (т.е. это признак админа). Чтобы разрешить пользоваться ею всем игрокам, надо открыть файл ''admincmd.sma'', и в строке
register_concmd("amx_who", "cmdWho", ADMIN_ADMIN, "- displays who is on server")
: заменить ''ADMIN_ADMIN'' на ''ADMIN_ALL'' и [[#Как компилировать плагины?|перекомпилировать]] плагин.
: В AMX 1.8.X и выше доступны стандартные средства переопределения прав доступа к командам без исправления самих плагинов (''TODO: ссылка?'').

= Вопросы по компилированию =
=== Что такое компиляция? ===
: Это процесс, который переводит текстовые файлы (*.sma), содержащие исходный код (т.е. инструкции для AMX Mod X, который их исполняет), в формат, более пригодный для исполнения. За счет этого скорость выполнения плагинов возрастает многократно, упрощается разработка "движка", который эти плагины исполняет, а также в некотором смысле защищается авторский код. Почему в "некотором смысле"? Потому что все AMX Mod X плагины должны публиковаться под лицензией GNU General Public License. В случае публикации плагина лицензия обязывает также публиковать и его исходный код. Откомпилированные плагины имеют расширение .amxx. Именно файлы этого типа, а не .sma, должны указываться в файле plugins.ini для последующей корректной загрузки плагина.

=== Как компилировать плагины? ===
: Базовую информацию вы можете найти на [[Ru Compiling Plugins (AMX Mod X)|этой]] странице.

=== Как упростить процесс компилирования? ===
: Можно написать стороннюю программу или скрипт, например такой, как пакетный batch файл. Например, создайте файл make.bat со следующим содержимым:
@amxxpc.exe %1 -i.\include -o.\compiled\%1
: Чтобы с помощью него откомпилировать плагин, необходимо выполнить следующую команду:
make.bat my_plugin.sma
: В итоге откомпилированный файл будет помещен в каталог ''compiled'' текущей директории. Если его там нет, значит в процессе компилирования возникли фатальные ошибки, которые выводятся на экран.
: Если вам необходимо (например, в случае ошибок) отправить кому-нибудь результат компиляции, можете перенаправить вывод информации о процессе компилирования в файл, например таким образом:
make.bat my_plugin.sma > my_plugin.log

=== Компилятор выводит "max. usage is unknown, due to recursion" ===
: Ничего страшного - просто компилятор не может вычислить предполагаемый объем памяти, используемый вашим плагином.

= Вопросы по скриптингу =
=== С чего начать? ===
: С со статьи [[Ru Fundamental Basics of AMX Mod X Scripting|Фундаментальные основы AMX Mod X скриптинга]].

=== А стоит ли вообще начинать? ===
: В зависимости от того, какую цель вы преследуете, а также от вашего желания и потенциала. Знание английского языка (чтение) будет огромным плюсом во время обучения, иначе постигать азы будет очень сложно. CS является закрытым проектом без исходных кодов, поэтому могие новые (неизученные) элементы приходится постигать через проведение экспериментов.

Ru AMX Mod X FAQ

2008-08-02T09:32:17Z

Simon Logic: /* Почему клиент не получает права админа по IP? */

[[Category:Russian]]
[[Category:Ru:AMX Mod X]]

= Общие положения, термины, сокращения и условные обозначения =
:* HL или HL1 - аббревиатура от [[Half-Life 1|Half-Life]] (часть первая);
:* Mod - "мод", модификация - дополнение к чему-либо, как правило, расширяющее/изменяющее функциональность;
:* HL Engine - "движок" Half-Life - "центральный модуль", осуществляющий выполнение базовых "общемодовых" задач;
:* MM - [[Metamod]] - сторонний мод особого типа, является промежуточным звеном в системе "HL движок - HL мод";
:* AMXX - аббревиатура от [[AMX Mod X]] - Metamod plugin ("плагин"), своего рода Metamod мод;
:* Map - "карта" - определяет внешний вид территории, на которой происходит игровое действие;
:* World - "мир" - все пространство, которое занимает карта, а также область, находящаяся за картой;
:* Spawn - "спавн" - момент, когда игрок появляется в мире, обретая физическое тело;
:* SinglePlayer - "синглплеер" - игровой тип, когда одновременно в игре может участвовать только один игрок;
:* MultiPlayer - "мультиплеер" - игровой тип, когда одновременно в игре может участвовать несколько игроков;
:* DM - аббревиатура от Death Match - динамичный мультиплеер тип игры, когда после "смерти" игрока происходит его скорый спавн ("респавн");
:* HLDM - аббревиатура от Half-Life Death Match - оригинальный HL мод DM типа;
:* CS - аббревиатура от [[Counter-Stirke]] - наиболее популярный HL мод;
:* VALVE - [[VALVe Software|корпорация, разработчик HL и CS]], также редко используется как синоним HLDM, подчеркивая название директории мода ("valve");
:* $MODDIR - способ условного обозначения корневой директории мода, например: ''cstrike'', ''valve'';
:* $MMDIR - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории Metamod, по-умолчанию: ''addons/metamod'';
:* $AMXMODX - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории AMX Mod X, по-умолчанию: ''addons/amxmodx''.

= Общие вопросы =
=== Где скачать последнюю версию AMX Mod X? ===
: Последнюю версию всегда можно скачать на официальном сайте AMX Mod X в [http://www.amxmodx.org/downloads.php разделе закачек].

=== А что именно качать? ===
: Качайте либо инсталлятор (AMX Mod X Full Installer), который включает базовый AMX Mod X пакет, все AMX Mod X дополнения для HL модов, а также AMXX-Studio (специализированный редактор AMX Mod X плагинов), либо, если готовы произвести установку AMX Mod X вручную, а также не желаете закачивать все существующие AMX Mod X дополнения для HL модов, качайте базовый архив (AMX Mod X Base), а затем дополнение для интересующего вас HL мода. Сама по себе базовая поставка практически во всех случаях будет достаточна только для HLDM мода.

=== Чем отличается AMX Mod X от AMX Mod? ===
: Буквой X ;). На самом деле отличий очень много:
:* AMXX поддерживается до сих пор, а поддержка AMX Mod была завершена примерно в 2006 году;
:* функциональность AMXX значительно превосходит AMX Mod, это также касается и расширенной поддержки других модов, в то время как AMX Mod поддерживал только HLDM, CS и CZ;
:* AMXX принято считать быстрее AMX Mod;
:* плагины AMXX не совместимы с плагинами AMX Mod;
:* плагины AMX Mod 0.9.9 совместимы с AMXX, если последний работает в режиме совместимости(?);
:* плагины для AMX Mod имеют расширение .amx, а плагины AMXX - .amxx;
:* ''TODO: дополнить список''

=== Как запустить два различных сервера AMX Mod X? ===
: К примеру, вы хотите запустить два различных сервера из одной ''cstrike'' директории на базе различных AMX Mod X/Metamod плагинов, настроек и прочего. Это решаемо. Один из примеров для win32 системы приведен ниже:
:* Создать отдельную AMX Mod X директорию с необходимыми файлами, например: ''addons/amxmodx2''
:* В ''addons/amxmodx2/configs/core.ini'' везде изменить "amxmodx" на "amxmodx2"
:* Создать отдельный файл загрузки Metamod плагинов, например: ''addons/metamod/plugins2.ini''
:* В созданный ''plugins2.ini'' файл вписать: ''win32 addons\amxmodx2\dlls\amxmodx_mm.dll''
:* Создать в директории ''cstrike'' файл, например, с именем ''amxmodx2.cfg'', его содержимое должно быть следующим:
<pre>localinfo mm_pluginsfile "addons/metamod/plugins2.ini"
localinfo amxx_basedir "addons/amxmodx2"
localinfo amxx_cfg "addons/amxmodx2/configs/core.ini"
localinfo amxx_configsdir "addons/amxmodx2/configs"
localinfo amxx_customdir "addons/amxmodx2/custom"
localinfo amxx_datadir "addons/amxmodx2/data"
localinfo amxx_logdir "addons/amxmodx2/logs"
localinfo amxx_logs "addons/amxmodx2/logs"
localinfo amxx_modules "addons/amxmodx2/configs/modules.ini"
localinfo amxx_modulesdir "addons/amxmodx2/modules"
localinfo amxx_plugins "addons/amxmodx2/configs/plugins.ini"
localinfo amxx_pluginsdir "addons/amxmodx2/plugins"
localinfo amxx_vault "addons/amxmodx2/data/vault.ini"
localinfo csstats "addons/amxmodx2/data/csstats.dat"
localinfo csstats_score "addons/amxmodx2/data/csstats.amxx"
localinfo amx_basedir "addons/amxmodx2"
localinfo amx_configdir "addons/amxmodx2/configs"
localinfo amx_langdir "addons/amxmodx2/data/amxmod-lang"
localinfo amx_logdir "addons/amxmodx2/logs"
localinfo amx_modulesdir "addons/amxmodx2/modules"
localinfo amx_pluginsdir "addons/amxmodx2/plugins"</pre>
:* Теперь второй сервер необходимо будет запускать с параметром командной строки: ''+exec amxmodx2.cfg''

= Вопросы по плагинам =
== Общие вопросы ==
=== Где и как искать плагины? ===
: Предварительно отметим, что условно AMX Mod X плагины можно разделить на следующие категории: стандартные, официально одобренные, официально отклоненные и неофициальные. Одобренные плагины можно искать [http://www.amxmodx.org/compiler.php здесь], или, используя [http://forums.alliedmods.net/search.php поисковую систему официального форума]. В поле '''Search in Forum(s)''' отметьте '''Approved Plugins''', также, зажав клавишу Ctrl, можно отметить интересующие вас секции из подраздела '''High-Traffic Plugins'''. Чтобы искать неофициальные плагины, следует также воспользоваться [http://forums.alliedmods.net/search.php поисковой системой официального форума], правда, в поле '''Search in Forum(s)''' необходимо выбрать '''Unapproved/Old Plugins'''. Если для вас не имеет значения статус плагина, и вы склонны к экспериментам, осуществляйте поиск по категории '''Plugins''', которая включает в себя одобренные, отклоненные, недавно опубликованные, вполне возможно, "сырые" плагины, а также темы-запросы, в которых могут быть "быстро написанные" плагины. Особенность поиска на официальных форумах еще состоит в том, что при вводе слова система ищет именно слова (без учета регистра), т.е. фрагменты, разделенные слева и справа пробелами. Т.о., к примеру, набрав для поиска слово ''FCOS'' вы не найдете нужного вам плагина, хотя есть тема, в которой присутствует текст ''[fcos]''. Для этого надо использовать в поиске строку ''*FCOS*''. Немного поработав с поисковой формой форума, вы легко освоите эту систему. Единственное возможное для некоторых неудобство - практически все описания плагинов написаны на английcком языке. Неофициальные плагины также можно попробовать искать с помощью общеизвестных поисковых систем: Google, Yandex, Rambler и др.

=== Сколько плагинов сейчас выпущено под AMX Mod X? ===
: "Тонны" плагинов. Но, к сожалению, качеством и надежностью б'''о'''льшая половина из них не белещет. К тому же некоторые плагины, "заброшены" авторами и не обновляются, что приводит даже к несовместимости с новыми версиями AMX Mod X.

=== Как устанавливать плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Как удалять плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Что такое стандартные плагины? ===
: Это плагины, которые входят в стандартную поставку AMX Mod X. Они находятся в папке $AMXMODX\scripting.

=== Как узнать, в каком плагине зарегистрирована та или иная переменная? ===
: В серверной консоли наберите команду ''amxx cvars''. Выделите текст, скопируйте в файл, там сделайте поиск искомой переменной. В правой колонке будет стоять имя плагина, в котором она и зарегистрирована.

== Вопросы по стандартным плагинам ==
=== Как увеличить число карт в стандартном голосовании? ===
: Откройте файл $AMXMODX\scripting\mapchooser.sma, замените число 3 в строке
#define SELECTMAPS 3
: на требуемое, затем [[#Как компилировать плагины?|откомпилируйте]] плагин и замените исходный.

=== Как увеличить число администраторов? ===
: В файле ''admin.sma'' замените число 64 на требуемое значение в строке:
#define MAX_ADMINS 64
: Не ставьте слишком большие значения. Не забудьте [[#Как компилировать плагины?|перекомпилировать]] плагин и заменить исходный новым.
: В AMXX 1.8.X и выше такая проблема не стоит, т.к. там реализован динамический список админов.

=== Почему клиент не получает права админа по IP? ===
:Данная проблема возникает на публичных Non-Steam (патченных) интернет-серверах c sv_lan = 0 при подключении Steam/Non-Steam клиентов.
: Сначала убедитесь, что у вас нединамический внешний IP. Динамический IP означает, что каждый раз, подключась к Интернету, вам назначается новый внешний IP (обычно из какого-то фиксированного диапазона). Для этого обратитесь к вашему провайдеру. Далее необходимо сверить, правильно ли вы прописали доступ в файле users.ini. Для этого проверьте свой внешний IP на страничке [http://myip.ru/ myip.ru]. Запомните его. Откройте файл user.ini и убедитесь что там есть такая запись:
"<ваш_ip>" "<ваш_пароль>" "<ваши_флаги>" "d<другие_модификаторы>"
:В поле ''<ваш_ip>'' должен быть вбит запомненный ранее IP. Обратите внимание на модификатор '''d'''. Без него проверка на IP проводиться НЕ будет. При указании IP старайтесь не использовать номер порта (знак двоеточия и то, что справа от него).
: Если все правильно, а вы все равно не становитесь администратором на сервере, то, скорее всего, проблема в том, что вы не прошли авторизацию на сервере. Для этого выполните команду ''users'' или ''stat'' в консоли сервера и обратите внимание на значение в колонке ''userid''. Если напротив потенциального админа стоит '''VALVE_ID_PENDING''', то это означает, что сервер криво заломан, и он не авторизовал данного игрока. В свою очередь это значит, что функция ''client_authorized(id)'' не была вызвана для всех(!) активных AMXX плагинов. Если открыть файл ''admin.sma'', то можно увидеть следующее:
public client_authorized(id)
return get_cvar_num("amx_mode") ? accessUser(id) : PLUGIN_CONTINUE
: Это и есть проверка клиента на админа. Чтобы эта функция вызывалась всегда, ''client_authorized'' надо переименовать в ''client_putinserver'', а существующую функцию ''client_putinserver'' либо удалить, либо [[Ru_Fundamental_Basics_of_AMX_Mod_X_Scripting#Комментарии|закомментировать]].

=== Как заставить команду amx_who выводить IP вместо ID? ===
: В файле ''admincmd.sma'' в указанном ниже месте
public cmdWho(id, level, cid)
{
...
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
for (new a = 0; a < inum; ++a)
{
get_user_authid(players[a], authid, 31)
...
}
...
}
:замените
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
: на
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "ip", "userid", lImm, lRes, lAccess)
: а также
get_user_authid(players[a], authid, 31)
: на
get_user_ip(players[a], authid, 31, 1)
: Сохраните файл и [[#Как компилировать плагины?|перекомпилируйте]] плагин.

=== А как дать всем доступ к команде amx_who? ===
: По умолчанию, команда доступна только игрокам с правами '''y''' (т.е. это признак админа). Чтобы разрешить пользоваться ею всем игрокам, надо открыть файл ''admincmd.sma'', и в строке
register_concmd("amx_who", "cmdWho", ADMIN_ADMIN, "- displays who is on server")
: заменить ''ADMIN_ADMIN'' на ''ADMIN_ALL'' и [[#Как компилировать плагины?|перекомпилировать]] плагин.
: В AMX 1.8.X и выше доступны стандартные средства переопределения прав доступа к командам без исправления самих плагинов (''TODO: ссылка?'').

= Вопросы по компилированию =
=== Что такое компиляция? ===
: Это процесс, который переводит текстовые файлы (*.sma), содержащие исходный код (т.е. инструкции для AMX Mod X, который их исполняет), в формат, более пригодный для исполнения. За счет этого скорость выполнения плагинов возрастает многократно, упрощается разработка "движка", который эти плагины исполняет, а также в некотором смысле защищается авторский код. Почему в "некотором смысле"? Потому что все AMX Mod X плагины должны публиковаться под лицензией GNU General Public License. В случае публикации плагина лицензия обязывает также публиковать и его исходный код. Откомпилированные плагины имеют расширение .amxx. Именно файлы этого типа, а не .sma, должны указываться в файле plugins.ini для последующей корректной загрузки плагина.

=== Как компилировать плагины? ===
: Базовую информацию вы можете найти на [[Ru Compiling Plugins (AMX Mod X)|этой]] странице.

=== Как упростить процесс компилирования? ===
: Можно написать стороннюю программу или скрипт, например такой, как пакетный batch файл. Например, создайте файл make.bat со следующим содержимым:
@amxxpc.exe %1 -i.\include -o.\compiled\%1
: Чтобы с помощью него откомпилировать плагин, необходимо выполнить следующую команду:
make.bat my_plugin.sma
: В итоге откомпилированный файл будет помещен в каталог ''compiled'' текущей директории. Если его там нет, значит в процессе компилирования возникли фатальные ошибки, которые выводятся на экран.
: Если вам необходимо (например, в случае ошибок) отправить кому-нибудь результат компиляции, можете перенаправить вывод информации о процессе компилирования в файл, например таким образом:
make.bat my_plugin.sma > my_plugin.log

=== Компилятор выводит "max. usage is unknown, due to recursion" ===
: Ничего страшного - просто компилятор не может вычислить предполагаемый объем памяти, используемый вашим плагином.

= Вопросы по скриптингу =
=== С чего начать? ===
: С со статьи [[Ru Fundamental Basics of AMX Mod X Scripting|Фундаментальные основы AMX Mod X скриптинга]].

=== А стоит ли вообще начинать? ===
: В зависимости от того, какую цель вы преследуете, а также от вашего желания и потенциала. Знание английского языка (чтение) будет огромным плюсом во время обучения, иначе постигать азы будет очень сложно. CS является закрытым проектом без исходных кодов, поэтому могие новые (неизученные) элементы приходится постигать через проведение экспериментов.

Ru AMX Mod X FAQ

2008-08-02T09:31:41Z

Simon Logic: /* Почему клиент не получает права админа по IP? */

[[Category:Russian]]
[[Category:Ru:AMX Mod X]]

= Общие положения, термины, сокращения и условные обозначения =
:* HL или HL1 - аббревиатура от [[Half-Life 1|Half-Life]] (часть первая);
:* Mod - "мод", модификация - дополнение к чему-либо, как правило, расширяющее/изменяющее функциональность;
:* HL Engine - "движок" Half-Life - "центральный модуль", осуществляющий выполнение базовых "общемодовых" задач;
:* MM - [[Metamod]] - сторонний мод особого типа, является промежуточным звеном в системе "HL движок - HL мод";
:* AMXX - аббревиатура от [[AMX Mod X]] - Metamod plugin ("плагин"), своего рода Metamod мод;
:* Map - "карта" - определяет внешний вид территории, на которой происходит игровое действие;
:* World - "мир" - все пространство, которое занимает карта, а также область, находящаяся за картой;
:* Spawn - "спавн" - момент, когда игрок появляется в мире, обретая физическое тело;
:* SinglePlayer - "синглплеер" - игровой тип, когда одновременно в игре может участвовать только один игрок;
:* MultiPlayer - "мультиплеер" - игровой тип, когда одновременно в игре может участвовать несколько игроков;
:* DM - аббревиатура от Death Match - динамичный мультиплеер тип игры, когда после "смерти" игрока происходит его скорый спавн ("респавн");
:* HLDM - аббревиатура от Half-Life Death Match - оригинальный HL мод DM типа;
:* CS - аббревиатура от [[Counter-Stirke]] - наиболее популярный HL мод;
:* VALVE - [[VALVe Software|корпорация, разработчик HL и CS]], также редко используется как синоним HLDM, подчеркивая название директории мода ("valve");
:* $MODDIR - способ условного обозначения корневой директории мода, например: ''cstrike'', ''valve'';
:* $MMDIR - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории Metamod, по-умолчанию: ''addons/metamod'';
:* $AMXMODX - способ условного обозначения относительного пути (относительно пути к $MODDIR) к корневой директории AMX Mod X, по-умолчанию: ''addons/amxmodx''.

= Общие вопросы =
=== Где скачать последнюю версию AMX Mod X? ===
: Последнюю версию всегда можно скачать на официальном сайте AMX Mod X в [http://www.amxmodx.org/downloads.php разделе закачек].

=== А что именно качать? ===
: Качайте либо инсталлятор (AMX Mod X Full Installer), который включает базовый AMX Mod X пакет, все AMX Mod X дополнения для HL модов, а также AMXX-Studio (специализированный редактор AMX Mod X плагинов), либо, если готовы произвести установку AMX Mod X вручную, а также не желаете закачивать все существующие AMX Mod X дополнения для HL модов, качайте базовый архив (AMX Mod X Base), а затем дополнение для интересующего вас HL мода. Сама по себе базовая поставка практически во всех случаях будет достаточна только для HLDM мода.

=== Чем отличается AMX Mod X от AMX Mod? ===
: Буквой X ;). На самом деле отличий очень много:
:* AMXX поддерживается до сих пор, а поддержка AMX Mod была завершена примерно в 2006 году;
:* функциональность AMXX значительно превосходит AMX Mod, это также касается и расширенной поддержки других модов, в то время как AMX Mod поддерживал только HLDM, CS и CZ;
:* AMXX принято считать быстрее AMX Mod;
:* плагины AMXX не совместимы с плагинами AMX Mod;
:* плагины AMX Mod 0.9.9 совместимы с AMXX, если последний работает в режиме совместимости(?);
:* плагины для AMX Mod имеют расширение .amx, а плагины AMXX - .amxx;
:* ''TODO: дополнить список''

=== Как запустить два различных сервера AMX Mod X? ===
: К примеру, вы хотите запустить два различных сервера из одной ''cstrike'' директории на базе различных AMX Mod X/Metamod плагинов, настроек и прочего. Это решаемо. Один из примеров для win32 системы приведен ниже:
:* Создать отдельную AMX Mod X директорию с необходимыми файлами, например: ''addons/amxmodx2''
:* В ''addons/amxmodx2/configs/core.ini'' везде изменить "amxmodx" на "amxmodx2"
:* Создать отдельный файл загрузки Metamod плагинов, например: ''addons/metamod/plugins2.ini''
:* В созданный ''plugins2.ini'' файл вписать: ''win32 addons\amxmodx2\dlls\amxmodx_mm.dll''
:* Создать в директории ''cstrike'' файл, например, с именем ''amxmodx2.cfg'', его содержимое должно быть следующим:
<pre>localinfo mm_pluginsfile "addons/metamod/plugins2.ini"
localinfo amxx_basedir "addons/amxmodx2"
localinfo amxx_cfg "addons/amxmodx2/configs/core.ini"
localinfo amxx_configsdir "addons/amxmodx2/configs"
localinfo amxx_customdir "addons/amxmodx2/custom"
localinfo amxx_datadir "addons/amxmodx2/data"
localinfo amxx_logdir "addons/amxmodx2/logs"
localinfo amxx_logs "addons/amxmodx2/logs"
localinfo amxx_modules "addons/amxmodx2/configs/modules.ini"
localinfo amxx_modulesdir "addons/amxmodx2/modules"
localinfo amxx_plugins "addons/amxmodx2/configs/plugins.ini"
localinfo amxx_pluginsdir "addons/amxmodx2/plugins"
localinfo amxx_vault "addons/amxmodx2/data/vault.ini"
localinfo csstats "addons/amxmodx2/data/csstats.dat"
localinfo csstats_score "addons/amxmodx2/data/csstats.amxx"
localinfo amx_basedir "addons/amxmodx2"
localinfo amx_configdir "addons/amxmodx2/configs"
localinfo amx_langdir "addons/amxmodx2/data/amxmod-lang"
localinfo amx_logdir "addons/amxmodx2/logs"
localinfo amx_modulesdir "addons/amxmodx2/modules"
localinfo amx_pluginsdir "addons/amxmodx2/plugins"</pre>
:* Теперь второй сервер необходимо будет запускать с параметром командной строки: ''+exec amxmodx2.cfg''

= Вопросы по плагинам =
== Общие вопросы ==
=== Где и как искать плагины? ===
: Предварительно отметим, что условно AMX Mod X плагины можно разделить на следующие категории: стандартные, официально одобренные, официально отклоненные и неофициальные. Одобренные плагины можно искать [http://www.amxmodx.org/compiler.php здесь], или, используя [http://forums.alliedmods.net/search.php поисковую систему официального форума]. В поле '''Search in Forum(s)''' отметьте '''Approved Plugins''', также, зажав клавишу Ctrl, можно отметить интересующие вас секции из подраздела '''High-Traffic Plugins'''. Чтобы искать неофициальные плагины, следует также воспользоваться [http://forums.alliedmods.net/search.php поисковой системой официального форума], правда, в поле '''Search in Forum(s)''' необходимо выбрать '''Unapproved/Old Plugins'''. Если для вас не имеет значения статус плагина, и вы склонны к экспериментам, осуществляйте поиск по категории '''Plugins''', которая включает в себя одобренные, отклоненные, недавно опубликованные, вполне возможно, "сырые" плагины, а также темы-запросы, в которых могут быть "быстро написанные" плагины. Особенность поиска на официальных форумах еще состоит в том, что при вводе слова система ищет именно слова (без учета регистра), т.е. фрагменты, разделенные слева и справа пробелами. Т.о., к примеру, набрав для поиска слово ''FCOS'' вы не найдете нужного вам плагина, хотя есть тема, в которой присутствует текст ''[fcos]''. Для этого надо использовать в поиске строку ''*FCOS*''. Немного поработав с поисковой формой форума, вы легко освоите эту систему. Единственное возможное для некоторых неудобство - практически все описания плагинов написаны на английcком языке. Неофициальные плагины также можно попробовать искать с помощью общеизвестных поисковых систем: Google, Yandex, Rambler и др.

=== Сколько плагинов сейчас выпущено под AMX Mod X? ===
: "Тонны" плагинов. Но, к сожалению, качеством и надежностью б'''о'''льшая половина из них не белещет. К тому же некоторые плагины, "заброшены" авторами и не обновляются, что приводит даже к несовместимости с новыми версиями AMX Mod X.

=== Как устанавливать плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Как удалять плагины? ===
: Обратитесь к [[Ru Configuring AMX Mod X|этой]] статье.

=== Что такое стандартные плагины? ===
: Это плагины, которые входят в стандартную поставку AMX Mod X. Они находятся в папке $AMXMODX\scripting.

=== Как узнать, в каком плагине зарегистрирована та или иная переменная? ===
: В серверной консоли наберите команду ''amxx cvars''. Выделите текст, скопируйте в файл, там сделайте поиск искомой переменной. В правой колонке будет стоять имя плагина, в котором она и зарегистрирована.

== Вопросы по стандартным плагинам ==
=== Как увеличить число карт в стандартном голосовании? ===
: Откройте файл $AMXMODX\scripting\mapchooser.sma, замените число 3 в строке
#define SELECTMAPS 3
: на требуемое, затем [[#Как компилировать плагины?|откомпилируйте]] плагин и замените исходный.

=== Как увеличить число администраторов? ===
: В файле ''admin.sma'' замените число 64 на требуемое значение в строке:
#define MAX_ADMINS 64
: Не ставьте слишком большие значения. Не забудьте [[#Как компилировать плагины?|перекомпилировать]] плагин и заменить исходный новым.
: В AMXX 1.8.X и выше такая проблема не стоит, т.к. там реализован динамический список админов.

=== Почему клиент не получает права админа по IP? ===
:Данная проблема возникает на публичных Non-Steam (патченных) интернет-серверах c sv_lan = 0 при подключении Steam/Non-Steam клиентов.
: Сначала убедитесь, что у вас нединамический внешний IP. Динамический IP означает, что каждый раз, подключась к Интернету, вам назначается новый внешний IP (обычно из какого-то фиксированного диапазона). Для этого обратитесь к вашему провайдеру. Далее необходимо сверить, правильно ли вы прописали доступ в файле users.ini. Для этого проверьте свой внешний IP на страничке [http://myip.ru/ myip.ru]. Запомните его. Откройте файл user.ini и убедитесь что там есть такая запись:
"<ваш_ip>" "<ваш_пароль>" "<ваши_флаги>" "d<другие_модификаторы>"
:В поле ''<ваш_ip>'' должен быть вбит запомненный ранее IP. Обратите внимание на модификатор '''d'''. Без него проверка на IP проводиться НЕ будет. При указании IP старайтесь не использовать номер порта (знак двоеточия и то, что справа от него).
: Если все правильно, а вы все равно не становитесь администратором на сервере, то, скорее всего, проблема в том, что вы не прошли авторизацию на сервере. Для этого выполните команду ''users'' или ''stat'' в консоли сервера и обратите внимание на значение в колонке ''userid''. Если напротив потенциального админа стоит '''VALVE_ID_PENDING''', то это означает, что сервер криво заломан, и он не авторизовал данного игрока. В свою очередь это значит, что функция ''client_authorized(id)'' не была вызвана из всех AMXX активных плагинов. Если открыть файл ''admin.sma'', то можно увидеть следующее:
public client_authorized(id)
return get_cvar_num("amx_mode") ? accessUser(id) : PLUGIN_CONTINUE
: Это и есть проверка клиента на админа. Чтобы эта функция вызывалась всегда, ''client_authorized'' надо переименовать в ''client_putinserver'', а существующую функцию ''client_putinserver'' либо удалить, либо [[Ru_Fundamental_Basics_of_AMX_Mod_X_Scripting#Комментарии|закомментировать]].

=== Как заставить команду amx_who выводить IP вместо ID? ===
: В файле ''admincmd.sma'' в указанном ниже месте
public cmdWho(id, level, cid)
{
...
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
for (new a = 0; a < inum; ++a)
{
get_user_authid(players[a], authid, 31)
...
}
...
}
:замените
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "authid", "userid", lImm, lRes, lAccess)
: на
console_print(id, "^n%s:^n # %-16.15s %-20s %-8s %-4.3s %-4.3s %s", cl_on_server, "nick", "ip", "userid", lImm, lRes, lAccess)
: а также
get_user_authid(players[a], authid, 31)
: на
get_user_ip(players[a], authid, 31, 1)
: Сохраните файл и [[#Как компилировать плагины?|перекомпилируйте]] плагин.

=== А как дать всем доступ к команде amx_who? ===
: По умолчанию, команда доступна только игрокам с правами '''y''' (т.е. это признак админа). Чтобы разрешить пользоваться ею всем игрокам, надо открыть файл ''admincmd.sma'', и в строке
register_concmd("amx_who", "cmdWho", ADMIN_ADMIN, "- displays who is on server")
: заменить ''ADMIN_ADMIN'' на ''ADMIN_ALL'' и [[#Как компилировать плагины?|перекомпилировать]] плагин.
: В AMX 1.8.X и выше доступны стандартные средства переопределения прав доступа к командам без исправления самих плагинов (''TODO: ссылка?'').

= Вопросы по компилированию =
=== Что такое компиляция? ===
: Это процесс, который переводит текстовые файлы (*.sma), содержащие исходный код (т.е. инструкции для AMX Mod X, который их исполняет), в формат, более пригодный для исполнения. За счет этого скорость выполнения плагинов возрастает многократно, упрощается разработка "движка", который эти плагины исполняет, а также в некотором смысле защищается авторский код. Почему в "некотором смысле"? Потому что все AMX Mod X плагины должны публиковаться под лицензией GNU General Public License. В случае публикации плагина лицензия обязывает также публиковать и его исходный код. Откомпилированные плагины имеют расширение .amxx. Именно файлы этого типа, а не .sma, должны указываться в файле plugins.ini для последующей корректной загрузки плагина.

=== Как компилировать плагины? ===
: Базовую информацию вы можете найти на [[Ru Compiling Plugins (AMX Mod X)|этой]] странице.

=== Как упростить процесс компилирования? ===
: Можно написать стороннюю программу или скрипт, например такой, как пакетный batch файл. Например, создайте файл make.bat со следующим содержимым:
@amxxpc.exe %1 -i.\include -o.\compiled\%1
: Чтобы с помощью него откомпилировать плагин, необходимо выполнить следующую команду:
make.bat my_plugin.sma
: В итоге откомпилированный файл будет помещен в каталог ''compiled'' текущей директории. Если его там нет, значит в процессе компилирования возникли фатальные ошибки, которые выводятся на экран.
: Если вам необходимо (например, в случае ошибок) отправить кому-нибудь результат компиляции, можете перенаправить вывод информации о процессе компилирования в файл, например таким образом:
make.bat my_plugin.sma > my_plugin.log

=== Компилятор выводит "max. usage is unknown, due to recursion" ===
: Ничего страшного - просто компилятор не может вычислить предполагаемый объем памяти, используемый вашим плагином.

= Вопросы по скриптингу =
=== С чего начать? ===
: С со статьи [[Ru Fundamental Basics of AMX Mod X Scripting|Фундаментальные основы AMX Mod X скриптинга]].

=== А стоит ли вообще начинать? ===
: В зависимости от того, какую цель вы преследуете, а также от вашего желания и потенциала. Знание английского языка (чтение) будет огромным плюсом во время обучения, иначе постигать азы будет очень сложно. CS является закрытым проектом без исходных кодов, поэтому могие новые (неизученные) элементы приходится постигать через проведение экспериментов.