Перевод и редактирование: DJ_WEST
Часть 1. Числа, множества чисел.
Для сохранения чисел нам необходимо место, называемое "переменной". Ее создание происходит следующим путем:
- Код: Выделить всё
new numberHolder
new - означает, что мы создали переменную.
numberHolder - это название (метка) переменной, необходимое для дальнейщего к ней обращения.
Это называется "объявление переменной".
Чтобы сохранить число в нашей переменной, мы делаем:
- Код: Выделить всё
numberHolder = 5
Где 5 - это наше число, к примеру.
Для сохранения множества чисел нам необходимо место, называемое "массивом". Его создание происходит следующим путем:
- Код: Выделить всё
new numberGroupHolder[x]
Где x количество чисел, которые мы сможем хранить в массиве (его размер).
Этот массив будет иметь x позиций. Одно для каждого числа. Чтобы обратиться к позиции, мы делаем:
- Код: Выделить всё
numberGroupHolder[0]
Где 0 - это наша позиция, к примеру. Последняя позиция будет x-1. Следовательно, для хранения цвета нам необходимо сделать:
- Код: Выделить всё
new color[3]
color[0] = 0
color[1] = 100
color[2] = 255
Или:
- Код: Выделить всё
new color[3]
color = { 0, 100, 255 }
Или:
- Код: Выделить всё
new color[3] = { 0, 100, 255 }
Все эти способы имеют одинаковый эффект и означают одно и тоже. Наиболее предпочтительными способами являются второй и третий, третий удобно использовать при объявлении "глобальной" переменной. Глобальная переменная - это переменная, которая создается один раз и хранится в памяти на протяжении всего периода действия плагина, и к которой можно обращаться из любой функции.
Pawn позволяет делать арифметические операции, поэтому мы можем сделать нашу переменную с данными о цвете немного темнее:
- Код: Выделить всё
color[0] = color[0] - 10
color[1] = color[1] - 10
color[2] = color[2] - 10
Если нам нужно изменить цвет не только у одной переменной, то не обязательно выполнять арифметические действия для каждой из них. Для этого мы создадим "функцию":
- Код: Выделить всё
darkenColor(anyColor[3])
{
anyColor[0] = anyColor[0] - 10
anyColor[1] = anyColor[1] - 10
anyColor[2] = anyColor[2] - 10
}
Это называется "объявлении функции darkenColor".
darkenColor - это название функции (метка), которое мы будем потом использовать при обращении к ней.
anyColor - это название переменной, которое мы передаем функции для дальнейщего ее использования.
Между скобками функции находится ее аргумент (anyColor[3]). Между { } находится тело функции, набор действий, которые необходимо выполнить.
К примеру, для изменения цвета нескольких переменных, мы делаем:
- Код: Выделить всё
new someColor[3] = {100,100,100}
new otherColor[3] = {50,100,150}
new anotherColor[3] = {255,30,233}
darkenColor(someColor)
darkenColor(otherColor)
darkenColor(anotherColor)
Это называется "вызов функции darkenColor". Перед тем, как ее вызывать, функция должна быть объявлена. В результате выполнения данного кода, мы получим следующие результаты:
someColor будет хранить значения 90,90,90.
otherColor будет хранить значения 40,90,140.
anotherColor будет хранить значения 245,20,223.
Но у нашей функции есть проблема. Если одно из значений переменной, которое мы передаем нашей, будем меньше 10, то мы получим отрицательный результат, что неверно, потому что значение цвета должно быть в пределах от 0 до 255.
Поэтому нам требуется создать "условие":
- Код: Выделить всё
darkenColor(anyColor[3])
{
anyColor[0] = anyColor[0] - 10
anyColor[1] = anyColor[1] - 10
anyColor[2] = anyColor[2] - 10
if(anyColor[0] < 0)
{
anyColor[0] = 0
}
if(anyColor[1] < 0)
{
anyColor[1] = 0
}
if(anyColor[2] < 0)
{
anyColor[2] = 0
}
}
Между скобками после выражения if мы имеем условие (anyColor[0] < 0).
Между { } мы имеем тело условия, которое будет выполняться в том случае, если условие верно. То есть anyColor[0] = 0, когда anyColor[0] < 0.
Наша функция немного не практична. Мы не можем сказать ей (функции) насколько хотим изменить яркость цвета. Поэтому переделаем ее так:
- Код: Выделить всё
changeColorLuminosity(anyColor[3], factor)
{
anyColor[0] = anyColor[0] + factor
anyColor[1] = anyColor[1] + factor
anyColor[2] = anyColor[2] + factor
if(anyColor[0] < 0)
{
anyColor[0] = 0
}
if(anyColor[1] < 0)
{
anyColor[1] = 0
}
if(anyColor[2] < 0)
{
anyColor[2] = 0
}
}
Теперь передавая функции changeColorLuminosity еще один аргумент, который называется factor, мы можем более практично менять яркость цвета. Передавая положительный factor мы делаем цвет ярче, передавая отрицательный factor - темнее. Но теперь у нас есть проблема, что значение может превысить число 255, поэтому решаем проблему:
- Код: Выделить всё
changeColorLuminosity(anyColor[3],factor)
{
anyColor[0] = anyColor[0] + factor
anyColor[1] = anyColor[1] + factor
anyColor[2] = anyColor[2] + factor
if(anyColor[0] < 0)
{
anyColor[0] = 0
}
if(anyColor[1] < 0)
{
anyColor[1] = 0
}
if(anyColor[2] < 0)
{
anyColor[2] = 0
}
if(anyColor[0] > 255)
{
anyColor[0] = 255
}
if(anyColor[1] > 255)
{
anyColor[1] = 255
}
if(anyColor[2] > 255)
{
anyColor[2] = 255
}
}
Наша функция будет работать, но ее можно улучшить, потому что нам не нужно проверять больше ли число 255, когда оно меньше 0:
- Код: Выделить всё
changeColorLuminosity(anyColor[3],factor)
{
anyColor[0] = anyColor[0] + factor
anyColor[1] = anyColor[1] + factor
anyColor[2] = anyColor[2] + factor
if(anyColor[0] < 0)
{
anyColor[0] = 0
}
else if (anyColor[0] > 255)
{
anyColor[0] = 255
}
if(anyColor[1] < 0)
{
anyColor[1] = 0
}
else if (anyColor[1] > 255)
{
anyColor[1] = 255
}
if(anyColor[2] < 0)
{
anyColor[2] = 0
}
else if (anyColor[2] > 255)
{
anyColor[2] = 255
}
}
Данный участок кода:
- Код: Выделить всё
if(anyColor[x] < 0)
{
anyColor[x] = 0
}
else if (anyColor[x] > 255)
{
anyColor[x] = 255
}
Можно прочитать так: если значение переменной anyColor меньше нуля, то оно равняется нулю, иначе если значение больше 255, то оно равняется 255.
Часть 2. Символы, множество символов.
Строки
Строка - это два или более смежных символа. С точки зрения программирования, строка - это множество чисел. Каждый символ имеет ASCII кодировку, которая представляется числами от 0 до 255. В данной статье мы будем рассматривать только символы алфавита, хотя у ASCII есть и множество других. Строка должна заканчиваться пустым символом, которое в таблице ASCII имеет значение 0. Когда данное число будет найдено - значит это конец строки. Когда вы объявляете массив для хранения строки, необходимо увеличивать его размер на 1, чтобы иметь место для пустого символа. Например, для хранения слова "word" в вашей строке, объявленный массив будет new szWord[5]. Когда вы объявляете массив, каждый элемент равен пустому символу, поэтому не нужно прописывать конец строки самостоятельно. Имейте в виду, что массив начинается с 0, так в нашем примере символы будут иметь 0-4 позиции.
Кодировка ASCII
Запомните, что заглавные и строчные символы не равны. К примеру, 'a' это не одно и тоже, что и 'A'.
Значения ASCII кодировки:
A-Z диапозон 65-90. 65 = 'A' и 90 = 'Z'.
a-z диапозон 97-122. 97 = 'a' и 122 = 'z'.
Объявление строк
К примеру, мы хотим объявить строку и сохранить в ней слово "word" или "WORD".
Мы можем сделать это несколькими путями:
- Код: Выделить всё
new szWord[] = "word"
new szWord[] = "WORD"
При объявлении строки и присвоения ей значения (слова) размер массива указывать не нужно, компилятор сделает это автоматически.
Или:
- Код: Выделить всё
new szWord[5]
szWord[0] = 119 //w
szWord[1] = 111 //o
szWord[2] = 114 //r
szWord[3] = 100 //d
szWord[4] = 0 // конец строки - это делать не обязательно, потому что при объявлении массива все его элементы равны пустому значению
szWord[0] = 87 //W
szWord[1] = 79 //O
szWord[2] = 82 //R
szWord[3] = 68 //D
szWord[4] = 0 // конец строки - это делать не обязательно, потому что при объявлении массива все его элементы равны пустому значению
// Вам необязательно запоминать значения кодировки ASCII, для этого достаточно использовать
// и символы с использованием одной кавычки
szWord[0] = 'w'
szWord[1] = 'o'
szWord[2] = 'r'
szWord[3] = 'd'
szWord[4] = '^0'
Завершение строки
Напомним, что если в строки найдено пустое значение (0), то следовательно - это конец строки.
Маленький пример:
- Код: Выделить всё
new szWord[] = "alphabet"
szWord[5] = 0 // Установка 'b' в пустое значение
//Результатом будет "alpha" вместо "alphabet"
Перемещение по строке (циклы)
Рассмотрим пример перемещения по строке для подсчитывания количества пробелов и символа 't'. Это можно сделать с использованием if/else или switch.
Цикл - это механизм повторения одно и того же кода программы определенное количество раз. В данном случае мы знаем количество повторений, поэтому будем использовать цикл for.
Его синтаксис: for ( выражение1 ; выражение2 ; выражение3 )
Пояснение:
выражение1 - обычно используется для объявления переменной-индекса и присвоения ей первоначального значения.
выражение2 - условие, которое используется перед началом каждого повторения, если оно возвращает значение верно (true), то происходит выполнение кода цикла.
выражение3 - используется обычно для увеличения переменной-индекса, объявленной в выражение1.
Примечание: Вы можете не использовать выражения: for ( ; ; ) (это приведет к бесконечному циклу, не делайте этого, если вы не понимаете, что делаете).
- Код: Выделить всё
//Выражение1: Объявление переменной-индекса i и присвоение ей значения 0 (по умолчанию).
//Выражение2: Выполнять цикл пока i > 9 (цикл будет выполняться пока i <= 9).
//Выражение3: Увеличение i на один (каждый раз увеличение i на 1).
// В данном цикле выполнение кода произойдет при i = 0. Выполниться тело цикла, а затем произойдет обращение к выражению2.
// Если это выражение верно, то произойдет обращение к выражению3.
// Цикл будет выполняться пока выражение2 не станет неверным (false).
for ( new i ; i <= 9 ; i++ )
{
// код, который будет выполняться
}
strlen() - это функция, встроенная в AMXX, которая вернет длину строки (не включая пустое значение).
- Код: Выделить всё
new szString[] = "this is a test string" // Объявление массива и присвоение ему предложения "this is a test string".
new iLen = strlen( szString ) // Объявление переменной iLen и присвоение ей длины строки szString. Если вы знаете длину, ее можно указать вручную.
new iSpaces
new iLetter_t
// Начинаем с 0 и выполняем цикл пока i меньше длины строки
for ( new i = 0 ; i < iLen ; i++ )
{
if ( szString[i] == ' ' )
iSpaces++
else if ( szString[i] == 't' )
iLetter_t++
// или
switch ( szString[i] )
{
case ' ': iSpaces++
case 't': iLetter_t++
}
}
Результат:
Пробелов: 4
Символа 't': 4
Создание массива для хранение строчного алфавита:
- Код: Выделить всё
new szAlphabet[27] // 26 символов + 1 пустой символ
// 'a' имеет значение 97 в кодировке ASCII, следовательно мы будем добавлять его в нашем цикле
for ( new i = 0 ; i < 26 ; i++ )
szAlphabet[i] = i + 97 // Присвоение переменной значение и его увеличение
// Что у нас получится в результате выполнения цикла:
// szAlphabet[0] = 97 //a
// szAlphabet[1] = 98 //b
// szAlphabet[2] = 99 //c
// szAlphabet[3] = 100 //d
// ...
// szAlphabet[25] = 122 //z
Массив строк
Вы можете создать массив строк известный также, как "двумерный массив".
- Код: Выделить всё
new szString[][] = { "this" , "is" , "an" , "array" , "of" , "strings" }
// Следовательно каждый элемент массива будет хранить определенное значение: szString[0] = "this", szString[1] = "is"
// Если массив будет заполняться в режиме работы плагина, например, для хранения имен игроков или их Steam ID
new szString[кол-во строк][длина самой длинной строки]
К примеру, чтобы получить доступ к слову "array" в нашем двумерном массиве, мы будем использовать szString[3]. Чтобы получить доступ к одному символу, например, первому 'r' в слове 'array', мы будем использовать szString[3][1].
Часть 3. Условные выражения.
Основные
Условные выражения - это выражения, которые позволяют решить, что делать с участком кода.
Например:
&& используется для выражения "и"
|| испольузется для выражения "или"
Пример:
- Код: Выделить всё
// x больше 0 или меньше или равно 255
x > 0 || x <= 255
// x больше 15 и y меньше 10
x > 15 && y < 10
// x меньше 15
// или y меньше 0 и y больше -10
x < 15 || y < 0 && y > -10
// x больше 16
// и y больше 10 или y меньше 0
x > 16 && (y > 10 || y < 0)
// a больше b и c меньше d и e меньше f
a > b && c < d && e < f
Неравенства можно использовать в различных форматах:
- Код: Выделить всё
// x больше 0 и меньше или равно 5
x > 0 && x <= 5
// Тоже самое, только в более красивой и удобной форме
0 < x <= 5
Но такие двойной формат выражений не будет работать, например, в данном случае:
- Код: Выделить всё
// x больше 5 или меньше 0
x > 5 || x < 0
Условные выражения также можно проверять на неверность (false).
! - отрицание
!= - означает, не равно
- Код: Выделить всё
// x не меньше 0
!(x < 0)
// x не равный 0
x != 0
- Код: Выделить всё
// x больше 0 меньше 2
x > 0 && y < 2
// тоже самое, только с использованием отрицания
!(x <= 0 || y >= 2)
// Если x <= 0, значит неверно (false)
// Если y >= 2, значит неверно (false)
// иначе - верно (true), потому что x > 0 и y < 2
Выражение IF
if - это выражение, которое решает какой из блоков кода нужно выполнять.
Синтаксис:
- Код: Выделить всё
if ( условие )
{
// блок кода
}
- Код: Выделить всё
if ( x > 1 )
{
// данный код будет выполняться, если x больше 1
}
Вместе c if есть и выражения else / else if:
- Код: Выделить всё
if ( условие №1 )
{
// выполняется, если условие №1 верно
}
else if ( условие №2 )
{
// выполняется если условие №1 неверно
// и условие №2 верно
}
else испольузется, когда выражения if и else if неверны:
- Код: Выделить всё
if ( условие №1 )
{
// выполняется, если условие №1 верно
}
else if ( условие №2 )
{
// выполняется если условие №1 неверно
// и условие №2 верно
}
else
{
// выполняется если условие №1 неверно
// и условие №2 неверно
}
Циклы
Существует 3 вида циклов, с которыми вы можете работать:
1) while
2) do, while
3) for
Цикл с использованием while будет выполняться, пока условие верно:
- Код: Выделить всё
while( условие )
{
// блок кода
}
Методика работы:
1. Проверка условия.
2. Если верно - выполнение блока кода, если нет - выход из цикла.
3. Возвращение к пункту 1.
Цикл с do, while почти идентичен циклу с while:
- Код: Выделить всё
do
{
// блок кода
}
while( условие )
Методика работы:
1. Выполнение блока кода.
2. Проверка условия.
3. Если верно выполнение блока кода, если нет - выход из цикла.
3. Возвращение к пункту 2.
Цикл for более сложный, чем другие:
- Код: Выделить всё
for (инициализация; условие; увеличение/уменьшение)
{
// блок кода
}
Методика работы:
1. Выполнение инициализации.
2. Если условие верно - выполнять блок кода, если не верно - выход из цикла.
3. Выполнение блока кода.
4. Выполнение увеличения/уменьшения переменной-индекса.
5. Возвращение к пункту №2.
Пример, цикл от 1 до 5:
- Код: Выделить всё
for( new i = 1; i <= 5; i++ ) // i++ увеличивает i на 1
{
// блок кода
}
Пример, цикл от 10 до 1:
- Код: Выделить всё
for( new i = 10; i >= 1; i-- ) // i-- уменьшает i на 1
{
// блок кода
}
Выражение SWITCH
SWITCH выражение используется для сравнения переменной с 2 или больше значениями и выполнения в зависимости от этого действия.
- Код: Выделить всё
switch (переменная)
{
case значение1:
{
// переменная равняется значение1
}
case значение2
{
// переменная равняется значение2
}
case значение3:
{
// переменная равняется значение3
}
}
Если все значения неверны, то используется следующий код:
- Код: Выделить всё
switch (переменная)
{
case значение1:
{
// переменная равняется значение1
}
case значение2
{
// переменная равняется значение2
}
case значение3:
{
// переменная равняется значение3
}
default:
{
// переменная не равняется значение1, значение2, значение3
}
}
Часть 4. Математические операции.
Основные
1. Сложение
2. Вычитание
3. Умножение
4. Деление
- Код: Выделить всё
new x = 1, y = 4;
// Сложение
x = y + 1; // x равняется 5
// Вычитание
y = x - 2; // y равняется 3
// Умножение
x = y * 2; // x равняется 6
// Деление
y = 12 / x; // y равняется 2
Увеличение/уменьшение
- Код: Выделить всё
new x = 5;
x *= 10;
// x теперь 50
x -= 10;
// x теперь 40
x /= 2;
// x теперь 20
x += 4;
// x теперь 24
- Код: Выделить всё
new x = 1
x += 1
// x теперь 2
x++
// x теперь 3
// ++ эквивалентно += 1
// также может быть использовано, как:
++x
// Есть отличия между ++переменная и переменная++
// ++переменная увеличивает переменную перед тем, как она будет использована
// и переменная++ увеличивает переменную после того, как она будет использована
new x = 1
new y = x++
// x = 2, y = 1
// x увеличена до 2 после присвоения y
x = 1
y = ++x
// x = 2, y = 2
// x увеличена до 2 перед присвоением y
Аналогично и для --:
- Код: Выделить всё
new x = 1
new y = --x
// x = 0, y = 0
x = 10
y = x--
// x = 9, y = 10