| Библиотека сработана для версии плеера QSP 5.7.0. Не гарантируется правильная работа на плеерах иных версий. Некоторые функции имеют ограничения на значение числовых аргументов, это связано с используемыми плеером библиотеками. Для разных версий плеера могут быть разные ограничения, поэтому внимательно читайте документацию к плееру, под который разрабатываете игру. По всем вопросам и предложениям обращаться: ICQ: 437337904 Skype: aleksversus e-mails:
Изначально создавалась для обеспечения нужд игры МАГИКОН. |
Сопроводительный текст и инструкции для пользования библиотекой.
Предполагается, что Вы читали справку по QSP, пробовали писать игры и уже знаете, что такое подпрограммы и функции в QSP, чем отличаются текстовые и числовые переменные, что есть аргументы и для чего они нужны.
Если Вы хотите использовать библиотеку в своей игре:
Например, Вы поместили библиотеку в папку "lib", которая находится в папке с игрой, тогда подключение библиотеки будет выглядеть так:
addqst 'lib\easy.math.qsp'
Все функции библиотеки вызываются оператором FUNC( ) - для получения числовых значений, и $FUNC( ) - для получения текстовых значений. Исключением являются функции, результат которых записывается в массив. Такие функции вызываются оператором GOSUB, или GS.
$FUNC('#fnct#',$args[0],$args[1],$args[2],$args[3],$args[4],$args[5],$args[6],$args[7],$args[8])
Аргументы могут быть как текстовыми, так и числовыми.
Библиотека работает с переменными, имена которых включают сочетание easy_math, чтобы избежать пересечений с именами переменных, используемых Вами в своих играх.
Все переменные, используемые функциями, после использования уничтожаются.
Если результат работы функции помещается в массив, одним из параметров функции указывается имя массива, в который должен быть помещён результат. Имена массивов, передаваемые в аргументах функций записываются по общим правилам записи имён переменных для плеера: текстовые массивы с символом $ перед именем, числовые без символа $ перед именем. Само имя не должно содержать символа $, и других запрещённых симовлов.
Функция предназначена для округления целых чисел. Работает только с числами, поддерживаемыми библиотеками вашего плеера. Для QSP 5.7.0 это числа в пределе [-2147483648 ... 2147483647]
args[0] - число
args[1] - разрядность округления 10 ,100 ,1000 и тд если не указано принимается равным 100
$args[2] - up - в сторону увеличения down - в сторону уменьшения, пусто - по правилам
func ("#even#",549,10,"up") =550
func ("#even#",549,10,"down") =540
func ("#even#",549,1000)=1000
func ("#even#",-5545,12) =-5500
func ("#even#",45599) =45600
func ("#even#",-45599) =-45600
Функция предназначена для суммирования значений всех элементов массива.
Будут сложены числовые значения всех элементов массива, независимо от способа индексирования.
Используйте только для заведомо малых значений - функция корректно работает только с числами, укладывающимися в предопределённые интервалы. Для QSP 5.7.0 это числа в пределе [-2147483648 ... 2147483647].
$args[0] - имя массива, не может быть числовым (args[0])
результатом работы функции будет число. Значения массива при этом не изменяются.
получает разрядность целого числа. Ограничением на использование функции является ограничение по значениям переменных в Вашем плеере.
args[0] - число
результатом является круглое число.
func('#raz#',36) = 10
func('#raz#',360) = 100
func('#raz#',366) = 100
func('#raz#',9999) = 1000
func('#raz#',-45023) = 10000
функция предназначена для возведения целого числа в степень.
args[0] - основание, целое число
args[1] - показатель, целое положительное число
ограничением использования функции является ограничение по значениям переменных в Вашем плеере.
Также следует заметить, что для подсчёта функция использует цикл. Если Вы возводите число, пусть даже единицу, в большую степень, вычисления на слабых компьютерах могут заметно подвешивать игру.
func('#^#',6,6) = 46656
func('#^#',
4,2) = 16
func('#^#',4,3) = 64
func('#^#',4,4) = 256
func('#^#',
250,2) = 62500
Возвращает разницу между двумя целыми числами. Всегда вычитает из большего меньшее.
args[0] - первое число, целое
args[1] - второе число, целое
Эта функция несёт не столько какую-то практическую пользу, сколько сокращает запись. Например, есть две переменные, разницу между которыми нам надо вычислить. Вот запись без использования функции:
if a>b: c=a-b else c=b-a
Или:
c=a-b
if c<0: c=-c
Двадцать знаков в первом случае, пятнадцать во втором, не считая пробелов. Теперь функция:
c=func('#-#',a,b)
Семнадцать знаков. Выглядит неубедительно, потому как взяты переменные с короткими именами. А что если вместо этих переменных вам бы пришлось использовать такие:
if a_easy_math>b_easy_math: c_easy_math=a_easy_math-b_easy_math else c_easy_math=b_easy_math-a_easy_math
сто четыре символа. А теперь функция:
c_easy_math=func('#-#',a_easy_math,b_easy_math)
сорок семь символов - запись вдвое короче. Вот почему я так упорно отстаиваю право этой функции на жизнь.
Функция выполняет логическое сложение двух чисел. Это могут быть два числа абсолютно любой длины (ограничения для числовых значений аргументов связаны с ограничением на значения переменных для Вашего плеера).
$args[0] - первое число (сколько угодно длинное), можно args[0] (ограничение на значение)
$args[1] - второе число (сколько угодно длинное), можно args[1] (ограничение на значение)
Любой посторонний символ интерпретируется, как 0 (нуль). Т.е. суммируются только целые положительные числа.
Использует функцию #zero#
Суммирует два целых числа любой длины по следующим правилам:
Например 998765
и 273
273 приводится к длине 998765 добавлением недостающих байтов.
273 -> 000273
слово 998765
номер байта 543210
пример:
998765
+
000273
------
999038 : /5+3=8/6+7=13/2+7+1=10/8+1+0=9/9+0=9/9+0=9/
999038 : / 8/ 3/ 0/ 9/ 9/ 9/
пример:
998765
+
001273
------
1000038 - слово Сумма
+1
------
000039 - итог. слово Сумма. Будет записано в $result
$func('#add#',998765,273) = 999038
$func('#add#','9987Y5','-273') = 998978
$func('#add#','999999','6273') = 006273
$func('#add#','998705','5773') = 004479
$args[0] - уменьшаемое (любой длины), можно args[0] - ограничение на значение
$args[1] - вычитаемое (любой длины), можно args[1] - ограничение на значение
Результат - текстовое значение (слово Сумма) без потери разрядов.
Использует функцию #zero#
логическое вычитание. Вычитает из одного числа другое. Оба числа приводятся к одной длине по аналогии с #add#.
Далее происходит поразрядное вычитание. Причём если в результате получается отрицательное число в байт записывается 10+число, в следующий разряд переносится -1
пример:
990763
-
099271
------
981492
Если отрицательное число получается на последнем байте последний байт вычисляется по общим правилам, а из нулевого байта Суммы вычитается 1.
$func('#dev#',998765,273) = 998492
$func('#dev#','9987Y5','-273') = 998432
$func('#dev#','999999','6273') = 993726
$func('#dev#','998705','5773') = 992932
! Генерирует строку одинаковых символов
args[0] - количество генерируемых символов (только число)
$args[1] - какие символы должны присутствовать в строке. По умолчанию '0'. Только текст.
Если написать в $args[1] не один символ а группу, будет сгенерирована строка из args[0] повторяющихся групп символов.
количество повторений символов, как видно, ограничено ограничениями Вашего плеера на использование значений переменных (для QSP 5.7.0 в пределе [-2147483648 ... 2147483647]).
$func('#zero#',13) = 0000000000000
$func('#zero#',13,'1') = 1111111111111
$func('#zero#',13,'10') = 10101010101010101010101010
$func('#zero#',13,'a') = aaaaaaaaaaaaa
$func('#zero#',3,'bla') = blablabla
функция получает строку случайных символов
args[0] - необходимая длина строки. Если не задана, выбирается случайным образом от 1 до 8 символов. Только число
$args[1] - символы, которых не должно быть в строке. Только текст.
если $args[1] = 'буквы и цифры' - строка только из букв и цифр.
$args[2] - символы, стоящие здесь, напротив включаются в строку (например, можно добавить пробел к стандартному набору символов, или символ табуляции). Только текст
Подробнее о том, какие символы будут в сгенерированной строке, смотрите код функции с 4 по 10 строчки.
$func('#rndstr#') = вЗНзГШмf
$func('#rndstr#',16,'буквы и цифры') = у1ЭAXВ6чГVЫДJМxD
$func('#rndstr#',16) = "i!TОж5wПЬрYхв#а
$func('#rndstr#',16,'буквы и цифры','$ @ !') = cл4фYЛ7@EnoiЪm А
$func('#rndstr#',16,'24680',' ©') = f!с/ Xsэu'\ZlcХ"
$func('#rndstr#') = c}fjрIЩB
$func('#rndstr#',16,'буквы и цифры') = БxПxуИЧаgрsмщю9д
$func('#rndstr#',16) = ,5яN}BВPсИ>kJlw[
$func('#rndstr#',16,'буквы и цифры','$ @ !') = @rtwЪnЦFЩиВлМяf
$func('#rndstr#',16,'2 4 6 8 0',' ©') = Q©)ь©gЪ*Вл<С@ррх
функция вычисляет позицию предмета в "инвентаре", содержащего указанное слово или строку
$args[0] - слово
Поиск осуществляется только по конкретному значению. Результатом является число.
Раньше мне приходилось часто совершать поиск по конкретному значению в инвентаре. Сейчас такая необходимость отпала. Но функция осталась, поскольку некоторые игры до сих пор используют её.
Вполне возможно, что и Вам она пригодится.
находит позицию элемента в массиве, содержащую регулярное выражение, либо возвращает -1
$args[0] - имя массива
$args[1] - регулярное выражение
$args[2] - first last - первая или последняя позиция
все передаваемые функции аргументы должны быть текстовыми. Результатом является число.
Фактически эта функция заменила предыдущую, поскольку я отказался от одноуровневого инвентаря. Следует отметить значения "first" и "last" для второго аргумента. если выставлено значение first, или пустое, функция начнёт поиск с нулевого элемента массива. Если выставлено 'last', функция начнёт поиск с последнего элемента массива.
Функция использует arrcomp, однако, в отличие от arrcomp, находит элемент, который содержит строку, соответствующую регулярному выражению, а не тот элемент, который полностью соответствует регулярному выражению.
При больших размерах массива (более 1000 элементов на core-i5/x64/2,5 ГГц/8 Гб RAM), функция может заметно подвешивать плеер.
из переданного блока текста выбираются строки, находящиеся между разделителями, в том числе строка до первого разделителя и после последнего. В качестве разделителя можно задать что угодно: символ, слово, строку. Для того, чтобы задать несколько разделителей, или неявный разделитель (шаблон разделителя. Например, html-тег), можно использовать регулярные выражения.
$args[0] - отрывок текста, который нужно разбить на строки
$args[1] - имя массива, в который нужно поместить полученные строки
$args[2] - разделитель, по которому нужно произвести выборку строк.
$args[3] - дополнительные опции (можно комбинировать, записав через пробел):
Посмотрим на выборку строк по разным разделителям на примере одного текста. Текст помещаем в переменную для удобства записи:
$text="Адское Пекло и Небеса -
Я весь мир мечтаю продать.
Время - деньги. Пусть стрелки бегут на часах -
И мне нечего больше желать."
Разбиваем на строки по символу переноса строки:
$func('#str.inArray#',$text,'$mass','
','')
Результат:
$mass[0]=Адское Пекло и Небеса -
$mass[1]=Я весь мир мечтаю продать.
$mass[2]=Время - деньги. Пусть стрелки бегут на часах -
$mass[3]=И мне нечего больше желать.
Разбиваем на строки по пробелу:
$func('#str.inArray#',$text,'$mass',' ','')
Результат (Заметьте, что символ переноса строки в этом случае попадает в результирующие строки. Туда же попадают знаки препинания и прочее):
$mass[0]=Адское
$mass[1]=Пекло
$mass[2]=и
$mass[3]=Небеса
$mass[4]=-
Я
$mass[5]=весь
$mass[6]=мир
$mass[7]=мечтаю
$mass[8]=продать.
Время
$mass[9]=-
$mass[10]=деньги.
$mass[11]=Пусть
$mass[12]=стрелки
$mass[13]=бегут
$mass[14]=на
$mass[15]=часах
$mass[16]=-
И
$mass[17]=мне
$mass[18]=нечего
$mass[19]=больше
$mass[20]=желать.
А вот пример выборки по нескольким разделителям с игнорированием пустых строк. Из текста будут выбраны исключительно слова:
$func('#str.inArray#',$text,'$mass','("|!|\?|-|,|;|:|\.| |
)','NOTSPACE REGULAR LCASE')
Результат:
$mass[0]=адское
$mass[1]=пекло
$mass[2]=и
$mass[3]=небеса
$mass[4]=я
$mass[5]=весь
$mass[6]=мир
$mass[7]=мечтаю
$mass[8]=продать
$mass[9]=время
$mass[10]=деньги
$mass[11]=пусть
$mass[12]=стрелки
$mass[13]=бегут
$mass[14]=на
$mass[15]=часах
$mass[16]=и
$mass[17]=мне
$mass[18]=нечего
$mass[19]=больше
$mass[20]=желать
На момент публикации этой функции в библиотеке была исправлена конструкция функции, не позволявшая использовать в качестве разделителя апостроф. Однако пришлось ввести временную переменную $easy_math_copy_array. Избегайте использования этой переменной в своих играх одновременно с использованием библиотеки.
В первоначальном варианте называлась #delete-zero#, однако игр, использующих такое название, насколько я помню, нет.
#dz# - delete zero - одна из основных функций, позволяющая упразднять несущественные нули в конце натурального числа
, а так же все несущественные нули в начале.
$args[0] - обрабатываемое число, только в текстовом виде!!!
args[1] - разряд до которого требуется удалить нули. 1 - до целых, 10 - до десятых, 100 - до сотых и т.д, по умолчанию 1
$result - текстовое значение вида 000.000
$func('#dz#','64',100)=64
$func('#dz#','64.0080000',1)=64.008
$func('#dz#','64.0080000',100)=64.008
$func('#dz#','64.0080000',10000)=64.0080
вычисляет рациональное частное из целых чисел.
args[0] - делимое
args[1] - делитель, по умолчанию = 100
args[2] - точность вычисления. 1 - до целых, 10 - до десятых, 100 - до сотых и т.д. По умолчанию, вычисляет до девятого знака после запятой.
$result - текстовое значение вида 000.000
Использует функцию #dz#
имеются ограничения на значения аргументов (для QSP 5.7.0 в пределах [-2147483648 ... 2147483647]).
$func('#indiv#',-950000,1000)=-950
$func('#indiv#',64)=0.64
$func('#indiv#',64,8,1)=8
$func('#indiv#',64,7,100000)=9.14285
$func('#indiv#',64,7)=9.142857142
$func('#indiv#',8,125)=0.064
$func('#indiv#',150,100,10)=1.5
$func('#indiv#',200,100,10)=2
#undiv# - переводит рациональное число в целое. (фактически умножает рациональное число на круглое число, с округлением-отсечением дробной части)
$args[0] - натуральное число
args[1] - точность перевода 10 - один знак после запятой, 100 - два знака, и т.д, по умолчанию до последнего знака после запятой
result - целое число
Не использует дополнительных функций, однако есть ограничение на значения аргументов и результата (для QSP 5.7.0 в пределах [-2147483648 ... 2147483647]).
$func('#undiv#','1',1000)=1000
$func('#undiv#','-1',1000)=-1000
$func('#undiv#','0.123',100)=12
$func('#undiv#','0.123',10)=1
$func('#undiv#','0.123')=123
$func('#undiv#','1.23')=123
получает разрядность дробной части числа в виде целого круглого числа
$args[0] - число в текстовом виде
result - число, в числовом виде (соответственно для QSP 5.7.0 в пределах [-2147483648 ... 2147483647])
$func('#razdiv#','0.64') = 100
$func('#razdiv#','0.064') = 1000
$func('#razdiv#','0.640') = 1000
$func('#razdiv#','0.647777') = 1000000
$func('#razdiv#','-7777.64') = 100
$func('#razdiv#','-7777.646666666666666666666666') = -1593835520 - превышено допустимое значение, результат неверен!!!
округление числа до указанной разрядности
возможны варианты 1, 10, 100, 1000 и т.п., и 0.1, 0.01 и т.п.
$args[0] - число
$args[1] - разрядность
$args[2] - up в сторону увеличения
Функция работоспособна, но не доработана (актуально для версии библиотеки 2.1.4 и ниже). Использует функции #even# #indiv# #razdiv# #raz#, в следствии чего накладывается ограничение на значения аргументов.
$func("#rounddiv#","945.459","0.1") = 945.5
$func("#rounddiv#","945.459","0.01") = 945.46
$func("#rounddiv#","945.459","0.001")= 945.459
$func("#rounddiv#","945.459","1") = 945
$func("#rounddiv#","945.459","10") = 950
$func("#rounddiv#","945.459","100") = 900
$func("#rounddiv#","-945.459","10") = -950
$func("#rounddiv#","-945.459","0.01")= -945.46
Функция сложения. Может суммировать целые и дробные числа любого знака любой длины (ограничение на значение текстовых переменных для QSP 5.7.0 около 2Гб).
использует функции #zero# #add# #dev# #dz#. Каждая из этих функций включает в себя один и более циклов, в результате чего могут наблюдаться заметные подвисания плеера для ОЧЕНЬ больших чисел. Вычисления могут оказаться долгими, но они будет произведены - результат гарантирован.
$args[0] ... $args[8] - девять слагаемых. Могут быть переданы в числовом виде (для QSP 5.7.0 в пределах [-2147483648 ... 2147483647]).
$result - всегда текстовое значение.
$func('#+#','9.05',"-9") = 0.05
$func('#+#','9.05',"-9.05") = 0
$func('#+#','9.05',"9") = 18.05
$func('#+#','9.05',"9.55","9.25") = 27.85
$func('#+#','9.99',"9.999","9.9") = 29.889
$func('#+#','384.384',"92.8",3) = 480.184
$func('#+#','283','126') = 409
$func('#+#','283','-126') = 157
$func('#+#','-283','126') = -157
$func('#+#','-283','-126') = -409
$func("#+#","-234","125","-13.7890303","3484889") = 3484766.2109697
Будьте внимательны. Функция работает с переменными minus_em_plus, i_em_plus, o_em_plus, len_em_plus. Если вы используете такие же переменные в своей игре, переименуйте переменные в функции.
Перемножает несколько чисел любой длины.
Внимание! Функция использует функции #+#, #zero#, #dz#, каждая из которых основана на циклических расчётах. Сама функция использует для подсчёта 4 цикла, что может замедлять работу программ при вычислении больших значений. Тем не менее функция работает, хотя и несколько подвешивает игру, если выполнять несколько умножений подряд.
$args[0] ... $args[8] - девять множителей. Могут быть переданы в числовом виде (для QSP 5.7.0 в пределах [-2147483648 ... 2147483647]).
$result - всегда текстовое значение.
Функция работает с переменными i_em_um, j_em_um, a_em_um. Если вы используете такие же переменные в своей игре, переименуйте переменные в функции.
$func('#*#',"38.4","2.5") = 96
$func('#*#','9.05',"-9.05") = -81.9025
$func('#*#','9.05',"10") = 90.5
$func('#*#','9.05',"9.55","9.25") = 799.454375
$func('#*#','9.99',"-9.999","9.9") = -988.911099
$func('#*#','2','2','2','2','2','2','2','2','2') = 512
$func('#*#','-2','-2','-2','-2','-2','-2','-2','-2','-2') = -512
Функция деления любого числа на любое. К сожалению, в настоящее время функция не доработана и использует примитивный способ вычисления. В связи с этим на размер аргументов и результата имеются ограничения. Тем не менее для небольших величин функция работает очень даже хорошо и вполне может использоваться.
$args[0] - делимое, только текстовое
$args[1] - делитель, только текстовое
args[2] - точность 1 -целые- 10 десятые доли, 100 сотые, 1000 - тысячные.
$result - частное, текстовое значение
Используются функции #dz# #razdiv# #indiv# #undiv#
$func('#:#','9.05',"-9",10000) = -1.0055
$func('#:#','9.05','-9.05',10000) = -1
$func('#:#','9.05',"10") = 0.905
$func('#:#','9.05',"9.55",10000) = 0.9476
$func('#:#','9.99',"9.999",10000) = 0.999
$func('#:#','9.99',"9.999",1000000) = 0.999099
$func('#:#','-1.69',"1.3",10000) = -1.3
$func('#:#','1.69',"1.3",10000) = 1.3
$func('#:#','-1.69',"-1.3",10000) = 1.3
$func('#:#','1.69',"-1.3",10000) = -1.3
Функция simplificate сравнивает два числа и выдаёт в результат большее.
Функция использует функции #dz# #razdiv# #undiv#, соттветственно для неё актуальны все ограничения связанные с этими функциями.
В настоящее время функция недоработана и использует примитивные механизмы сравнения. Тем не менее для небольших значений функция вполне работоспособна.
$args[0] - первое число, только текстовое значение
$args[1] - второе число, только текстовое значение
$result - результат, текстовое значение
$func('#sim#','9.05',"-9") = 9.05
$func('#sim#','9.05','-9.05') = 9.05
$func('#sim#','9.05',"10") = 10
$func('#sim#','9.05',"9.55") = 9.55
$func('#sim#','9.99',"9.999") = 9.999
$func('#sim#','-1.69',"1.3") = 1.3
$func('#sim#','-1.69',"-1.3") = -1.3
$func('#sim#','1.69',"1.3") = 1.69
$func('#sim#','1.69',"-1.3") = 1.69
Внимание, результаты функции даются в обработке функцией #dz#, а значит они могут отличаться по количеству символов с данными, передаваемыми в аргументах. Будьте аккуратны при использовании сравнений.
Вычисление квадратного корня методом Ньютона.
$args[0] - число, текстовое значение
args[1] - точность. Целое число: 100 - сотые, 1000 - тысячные и т.д.
$args[2] - первое приближение, только текстовое значение. Вы можете указать примерно чему будет равен результат. Это ускорит вычисление
Существует простое линейное уравнение, повторяя вычисление которого несколько раз, мы получаем корень числа с некоторой погрешностью. Чем чаще мы производим вычисление, тем точнее результат. Округление числа производится до требуемого знака после запятой. Когда предыдущее вычисленное значение становится равно предыдущему, проверяется погрешность вычисления. Если погрешность не превышает 0.00000001, число принимается. В противном случае выдаётся ноль. |
Функция использует #:# #*# #+# в связи с чем к ней применимы те же ограничения, что и к этим функциям. Так же поскольку производится несколько десятков и сотен циклических вычислений, функция может заметно подвешивать игру даже при вычислении небольших значений. В настоящее время функция позволяет использовать значение первого приближения, чтобы сократить время расчётов. Значение необходимо передавать вторым аргументом ($args[2]). В будущем таблицы приближений небольших чисел будут непосредственно встроены в функцию.
#SQRT# 1000, точность 10000 = 31.6227
#SQRT# 16, точность 10000 = 4
#SQRT# 257, точность 100000 = 16.03121
#SQRT# 257, точность 10000 = 16.0312
#SQRT# 257, точность 1000 = 16.031
#SQRT# 257, точность 100 = 16.03
#SQRT# 2.1, точность 100 = 1.44
#SQRT# 259, точность 100 = 16.09
#SQRT# 260, точность 100 = 16.12
#SQRT# 1.69, точность 100 = 1.3
#SQRT# 0.69, точность 10000 = 0.8306
при вычислении без первого приближения расчёт для всех значений в совокупности даёт 9 секунд задержки. При вычислении с первым приближением близким по значению к результату, время на все вычисления составило 3 секунды задержки. Наибольшее количество времени ушло на вычисление корня из 1000, причём без первого приближения это время оказалось в два раза больше, чем с первым приближением.
Простая функция . Подставляет в начало строки '-', если его там нет, и убирает, если он там есть.
$args[0] - строка (по идее число в текстовой записи)
$result - полученная строка
Честно говоря необходимость в этой функции отпала, когда была разработана вторая версия библиотеки. Поскольку я не помню, где ещё я мог использовать эту функцию, я её оставил. Тем не менее может пригодиться, скажем, для быстрого инвертирования шестнадцатеричных чисел.
Функция перевода из гексаметричного числа в декаметричное. Не работает с отрицательными значениями.
Использует циклический алгоритм перевода, в связи с чем может заметно подвешивать игру при переводе больших чисел. Имеет те же ограничения на значение результата, что и прочие фукции, т.е. результат должен лежать в пределе [-2147483648 ... 2147483647] (для Q.S.P. 5.7.0).
$args[0] - шестнадцатеричное число (текстовый вид). Значения в пределе 7fffffff
result - полученное число
func('#hex-dec#','ff') = 255
func('#hex-dec#','22') = 34
func('#hex-dec#','10') = 16
func('#hex-dec#','1') = 1
func('#hex-dec#','a') = 10
func('#hex-dec#','ffaa233') = 268083763
func('#hex-dec#','ffaa23') = 16755235
func('#hex-dec#','ffaa2') = 1047202
func('#hex-dec#','ffaa233451') = -1440533423
func('#hex-dec#','ffaa23345') = -90033339
func('#hex-dec#','ffaa2334') = -5627084
Как видно, последние три результата получились отрицательными, значит превышены пределы значений резултата, а соответственно и числа, которые переводятся в десятеричную систему тоже превышают предел.
Функция перевода из декаметричного числа в гексаметричное. Не работает с отрицательными значениями.
Использует циклический алгоритм перевода, в связи с чем может заметно подвешивать игру при переводе больших чисел. Имеет ограничения на значения аргумента в пределе [-2147483648 ... 2147483647] (для Q.S.P. 5.7.0).
args[0] - целое число (числовой вид). Значения в пределе 2147483647
$result - полученная строка
$func('#dec-hex#',2147483647) = 7fffffff
$func('#dec-hex#',214) = d6
$func('#dec-hex#',255) = ff
$func('#dec-hex#',10) = a
$func('#dec-hex#',9) = 9
$func('#dec-hex#',2147483648) = -0
Как видно, последний результат получился отрицательным, потому что был превышен предел на значения аргумента.
Преобразует десятеричное число в шестнадцатеричное. Отличием от функции #dec-hex# является ограничение на значение аргумента в пределах [-16777215 ... 16777215]. Если пределы превышены, функция выдаёт в результат 00. Любое число в пределах преобразуется к двуразрядному шестнадцатеричному числу. Таким образом ограничение на результат лежит в пределах [-ff ... ff].
В общем и целом, такое преобразование необходимо для того, чтобы силами QSP конвертировать значения цветовой составляющей от HTML формата (где запись идёт в шестнадцатеричном коде) в RGB формат (где запись идёт в десятеричном коде). Используется в библиотеке easy.titles.qsp для ковертирования цветовых значений.
args[0] - число целое, десятеричное.
$result - шестнадцатеричное двуразрядное число (текстовое значение).
$func('#dec-col#',2147483647) = 00
$func('#dec-col#',214) = d6
$func('#dec-col#',255) = ff
$func('#dec-col#',-10) = -0a
$func('#dec-col#',256) = 10
$func('#dec-col#',16) = 10
Данная функция работает с отрицательными значениями, поэтому результат, отмеченный зелёным, верен. Результат, отмеченный красным, - не верен.
Функция предназначена для изменения цвета для HTML.
! функция использует функции #hex-dec# и #dec-col#
$args[0] - цвет. Шестнадцатеричный формат, шестизначное число. (не может быть отрицательным)
$args[1] - значение. Шестнадцатеричный формат, двузначное число. (может быть отрицательным)
Функция действует следующим образом: разбивает первый аргумент на три двузначных шестнадцатеричных числа, и к каждому из чисел прибавляет второй аргумент. Если сумма превышает значение ff, она приводится к ff. И напротив, если сумма оказывается меньше 0, она приводится к 0. Таким образом результат работы функции лежит в пределах [000000 ... ffffff]
Это может пригодиться для плавного гашения цвета, или наоборот. Функция используется в движке игры "МАГИКОН", чтобы гасить цвета заголовков в зависимости от уровней.
$func('#+col#','ff0000','-44') = bb0000
$func('#+col#','000000','-44') = 000000
$func('#+col#','dd0000','22') = ff2222
$func('#+col#','dd8822','-44') = 994400
$func('#+col#','dd8822','44') = ffcc66
Генерирует случайные числа и заполняет ими указанный массив
$args[0] - название массива, элементы которого необходимо сформировать (исследуемый массив), обязательный параметр
args[1] - количество формируемых элементов, обязательный параметр
args[2] - номер элемента, с которого необходимо начать.
args[3] - нижняя граница случайного числа (по умолчанию - ноль)
args[4] - верхняя граница случайного числа (по умолчанию - тысяча)
gs '#array.rand#','mass',8
mass[0]=574
mass[1]=668
mass[2]=413
mass[3]=765
mass[4]=478
mass[5]=205
mass[6]=701
mass[7]=272
gs '#array.rand#','mass',6,2
mass[0]=0
mass[1]=0
mass[2]=174
mass[3]=371
mass[4]=69
mass[5]=732
mass[6]=334
mass[7]=950
gs '#array.rand#','mass',6,2,10,20
mass[0]=0
mass[1]=0
mass[2]=12
mass[3]=19
mass[4]=19
mass[5]=13
mass[6]=10
mass[7]=17
Иногда необходимо просмотреть содержимое массива, или записать его в удобном виде в переменную. Для этого приходится вводить цикличиские конструкции непосредственно в код. Данная функция предназначена для того, чтобы избавить Вас от необходимости строить такие конструкции каждый раз. Достаточно указать аргументом имя массива и функция вернёт в результате столбец со значениями массива. Пример работы функции можно посмотреть выше. Чтобы просмотреть результаты работы функции #array.rand#, была использована как раз таки функция #array.prnt#.
$args[0] - имя массива, содержимое которого необходимо просмотреть.
$args[1] - управляющая конструкция. Если указано [only result], выводит только содержимое массива, не показывая его названия и номера ячеек.
*pl $func('#array.prnt#','mass')
- выведет на экран числовые значения массива 'mass'
*pl $func('#array.prnt#','$mass')
- выведет на экран текстовые значения массива '$mass'
*pl $func('#array.prnt#','$mass','[only Result]')
- выведет на экран только содержимое массива '$mass'
Программа сортирует значения массива (используется метод сортировки "пузырьком"). Результатом работы программы могут быть три разных массива. Направление сортировки: от нулевого элемента к последнему.
$args[0] - название массива, элементы которого необходимо отсортировать (исследуемый массив), обязательный параметр
$args[1] - порядок сортировки элементов массива: 'up' или ничего - значения сортируются от большего к меньшему, 'down' - значения сортируются от меньшего к большему.
$args[2] - имя массива, в который будут помещены исходные номера элементов исследуемого массива в порядке сортировки. Например, если при сортировке местами поменялись первый и второй элемент, первый элемент указанного массива получит номер 2, а второй - 1.
$args[3] - название результирующего массива, т.е. массива, в который будут переданы результаты сортировки. Если не указано, результирующим массивом становится исследуемый.
Исследуемый массив до сортировки
Исследуемый массив после сортировки
Изменение в позициях элементов массива
Результирующий массив
gs '#array.rand#','old_mass',8
gs '#array.sort#','old_mass'
em_array
new_mass
old_mass[0]=157
old_mass[1]=250
old_mass[2]=709
old_mass[3]=413
old_mass[4]=532
old_mass[5]=779
old_mass[6]=730
old_mass[7]=565old_mass[0]=779
old_mass[1]=730
old_mass[2]=709
old_mass[3]=565
old_mass[4]=532
old_mass[5]=413
old_mass[6]=250
old_mass[7]=157не указано в параметрах
не указано в параметрах
Исследуемый массив до сортировки
Исследуемый массив после сортировки
Изменение в позициях элементов массива
Результирующий массив
gs '#array.rand#','old_mass',8
gs '#array.sort#','old_mass','down','em_array'
em_array
new_mass
old_mass[0]=966
old_mass[1]=812
old_mass[2]=796
old_mass[3]=304
old_mass[4]=678
old_mass[5]=118
old_mass[6]=901
old_mass[7]=132old_mass[0]=118
old_mass[1]=132
old_mass[2]=304
old_mass[3]=678
old_mass[4]=796
old_mass[5]=812
old_mass[6]=901
old_mass[7]=966em_array[0]=5
em_array[1]=7
em_array[2]=3
em_array[3]=4
em_array[4]=2
em_array[5]=1
em_array[6]=6
em_array[7]=0не указано в параметрах
Исследуемый массив до сортировки
Исследуемый массив после сортировки
Изменение в позициях элементов массива
Результирующий массив
gs '#array.rand#','old_mass',8
gs '#array.sort#','old_mass','down','em_array','new_mass'
em_array
new_mass
old_mass[0]=967
old_mass[1]=629
old_mass[2]=541
old_mass[3]=290
old_mass[4]=852
old_mass[5]=334
old_mass[6]=318
old_mass[7]=529old_mass[0]=967
old_mass[1]=629
old_mass[2]=541
old_mass[3]=290
old_mass[4]=852
old_mass[5]=334
old_mass[6]=318
old_mass[7]=529em_array[0]=3
em_array[1]=6
em_array[2]=5
em_array[3]=7
em_array[4]=2
em_array[5]=1
em_array[6]=4
em_array[7]=0new_mass[0]=290
new_mass[1]=318
new_mass[2]=334
new_mass[3]=529
new_mass[4]=541
new_mass[5]=629
new_mass[6]=852
new_mass[7]=967
Исследуемый массив до сортировки
Исследуемый массив после сортировки
Изменение в позициях элементов массива
Результирующий массив
gs '#array.rand#','old_mass',8
gs '#array.sort#','old_mass','down','em_array'
em_array
new_mass
$old_mass[0]=88ff88
$old_mass[1]=ff00ff
$old_mass[2]=0ff0f8
$old_mass[3]=ffffff
$old_mass[4]=8888ff
$old_mass[5]=fff8f8$old_mass[0]=0ff0f8
$old_mass[1]=8888ff
$old_mass[2]=88ff88
$old_mass[3]=ff00ff
$old_mass[4]=fff8f8
$old_mass[5]=ffffffem_array[0]=2
em_array[1]=4
em_array[2]=0
em_array[3]=1
em_array[4]=5
em_array[5]=3параметр не задан
Программа перетасовывает элементы массива согласно сведениям в массиве фиксации.
$args[0] - массив, данные в котором необходимо перетасовать (исследуемый)
$args[1] - массив фиксации, где находится список, согласно которому тасуются элементы
$args[2] - результирующий массив - сюда помещается итог перетасовки, если не указан результат помещается в исходный массив.
gs '#array.rstd#','old_mass','em_array','new_mass'
Исследуемый массив до сортировки
Опорный массив до сортировки
Опорный массив после сортировки
Массив фиксации позиций
Результирующий массив
$arr_mass
gs '#array.rand#','old_mass',8
gs '#array.sort#','old_mass','down','em_array'
em_mass
$new_mass
$arr_mass[0]=голова
$arr_mass[1]=плечи
$arr_mass[2]=грудь
$arr_mass[3]=живот
$arr_mass[4]=бёдра
$arr_mass[5]=колени
$arr_mass[6]=икры
$arr_mass[7]=ступниold_mass[0]=722
old_mass[1]=136
old_mass[2]=788
old_mass[3]=177
old_mass[4]=780
old_mass[5]=97
old_mass[6]=649
old_mass[7]=75old_mass[0]=75
old_mass[1]=97
old_mass[2]=136
old_mass[3]=177
old_mass[4]=649
old_mass[5]=722
old_mass[6]=780
old_mass[7]=788em_array[0]=7
em_array[1]=5
em_array[2]=1
em_array[3]=3
em_array[4]=6
em_array[5]=0
em_array[6]=4
em_array[7]=2$new_mass[0]=ступни
$new_mass[1]=колени
$new_mass[2]=плечи
$new_mass[3]=живот
$new_mass[4]=икры
$new_mass[5]=голова
$new_mass[6]=бёдра
$new_mass[7]=грудь
$args[0] - массив, данные в котором необходимо восстановить (исследуемый)
$args[1] - массив фиксации, где находится список, согласно которому тасуются элементы
$args[2] - результирующий массив - сюда помещается итог перетасовки, если не указан результат помещается в исходный массив.
Исследуемый массив до сортировки
Исследуемый массив после сортировки
Массив фиксации позиций
Результирующий массив
gs '#array.rand#','old_mass',8
gs '#array.sort#','old_mass','down','em_array'
em_array
gs '#array.dsrt#','old_mass','em_array','new_mass'
old_mass[0]=949
old_mass[1]=913
old_mass[2]=269
old_mass[3]=901
old_mass[4]=257
old_mass[5]=561
old_mass[6]=529
old_mass[7]=293old_mass[0]=257
old_mass[1]=269
old_mass[2]=293
old_mass[3]=529
old_mass[4]=561
old_mass[5]=901
old_mass[6]=913
old_mass[7]=949em_array[0]=4
em_array[1]=2
em_array[2]=7
em_array[3]=6
em_array[4]=5
em_array[5]=3
em_array[6]=1
em_array[7]=0new_mass[0]=949
new_mass[1]=913
new_mass[2]=269
new_mass[3]=901
new_mass[4]=257
new_mass[5]=561
new_mass[6]=529
new_mass[7]=293
$args[0] - первый массив (исследуемый).
$args[1] - второй массив (исследуемый).
$args[2] - управляющая конструкция. Если указано пустое значение - массивы сравниваются на предмет полной идентичности. Если указано "simp" - массивы сортируются по одинаковым правилам и вновь сравниваются. Такое сравнение называется сравнением на подобие, т.е. в обоих массивах присутствуют одинаковые элементы, но расположенные в разном порядке. Сортировка производится во временные массивы и на исследуемые массивы не влияет.
$result - принимает два значения "true" - массивы идентичны "false" - массивы неидентичны.
Исследуемый массив
Полностью идентичный массив
Массив с тем же набором элементов, но отсортированный
результат абсолютного сравнения mass1 и mass2
результат абсолютного сравнения mass1 и mass3
результат сравнения на подобие mass1 и mass3
gs '#array.rand#','mass1',8
copyarr 'mass2','mass1'
gs '#array.sort#','mass1','','','mass3'
$func'#array.simp#','mass1','mass2'
$func'#array.simp#','mass1','mass3'
$func'#array.simp#','mass1','mass3','simp'
mass1[0]=455
mass1[1]=705
mass1[2]=967
mass1[3]=452
mass1[4]=829
mass1[5]=84
mass1[6]=983
mass1[7]=824
mass2[0]=455
mass2[1]=705
mass2[2]=967
mass2[3]=452
mass2[4]=829
mass2[5]=84
mass2[6]=983
mass2[7]=824
mass3[0]=983
mass3[1]=967
mass3[2]=829
mass3[3]=824
mass3[4]=705
mass3[5]=455
mass3[6]=452
mass3[7]=84true
false
true
Сравнение текстовых значений массивов происходит аналогично. Если хотя бы у одного из массивов будет стоять выбор по текстовым значениям (т.е. имя массива будет начинаться с $), будут сравниваться текстовые значения.
Библиотека будет модернизироваться и пополняться новыми функциями в зависимости от необходимости и возможности. Некоторые функции в настоящее время попросту невозможно сделать - они будут либо слишком сложны, либо черезчур сильно повлияют на быстродействие игры. Вполне вероятно, что некоторые математические операции будут встроены непосредственно в движок плеера, и необходимость в них отпадёт. Такие функции будут исключаться из последующих версий библиотеки. По возможности, будут упрощаться и алгоритмы работы функций, а так же достраиваться необходимые для работы с ними параметры. Последняя версия библиотеки, а так же ключевые версии, всегда будут доступны на сайте aleksversus.narod.ru.
| Aleks Versus'Easy Libraries'2013 Aleks Versus'Game Adventure Making'Really Unimaginable Stories'2013 |