Table of content

DiceParser: что это такое?

DiceParser — программный компонент, предназначенный для броска костей с помощью простых команд. Этот программный компонент доступен на разных платформах.
Например: бот Discord, встроенный в Rolisteam, в Twitter и т. д.

О примерах в этой документации

Для ясности: во всех примерах этой документации начальный префикс не показан. Не забудьте добавить нужный префикс в зависимости от того, где выполняется команда броска костей: Rolisteam, Discord, IRC… Если не знаете, попробуйте !. Префикс позволяет системе распознать команду.

Бросок кости

Всё очень просто. Нужно вызвать:

!1d6

Первое число — количество костей, которое нужно бросить. Второе число — количество граней.

Примеры

!1d6

Бросок одной шестигранной кости.

!1d10

Бросок одной десятигранной кости.

!5d10

Бросок пяти десятигранных костей.

!777d6

Бросок 777 шестигранных костей.

Благодаря ряду операций и параметров можно немного настроить команду броска: см. Список операторов.

Бросок костей в диапазоне

!4d[-1..1]

Бросок 4 костей со значениями от -1 до 1 (система Fudge/Fate).

!3d[0..9]

Бросок 3 костей с 10 гранями, начиная с 0.

!3d[-20..-9]

Бросок 3 костей, значения в диапазоне от -20 до -9.

Инструкции

Сложить (или выполнить любые другие арифметические действия) результаты бросков двух (или более) видов костей несложно:

!1d10+1d8

Показать все результаты, не выполняя над ними никаких действий. Несколько инструкций разделяются символом ;.

!1d10;1d6 # 2 instructions

или

!5d6;1d10;4d100;3d20  # 4 instructions

Так можно выполнять вычисления, если результат первой инструкции удовлетворяет условию, и так далее. Например, если первой инструкцией бросается атака, а второй — урон, то в третьей можно сравнить результат атаки и проверить, успешна ли она. Можно вывести:

см. подробнее

Объединить

Можно объединить все инструкции в одну большую. Для этого предназначен оператор merge. Он полезен, когда нужно обработать все результаты броска костей как единый результат.

Например, если нужно оставить наибольшее значение среди d6 и d8.

!d6;d8mk1

Подробнее об операторе k — в разделе Список операторов.

Вычисление между инструкциями

Благодаря системе переменных можно ссылаться на результат конкретной инструкции.

Чтобы сослаться на первую инструкцию: $1
Чтобы сослаться на вторую инструкцию: $2
Для ссылки на третью инструкцию используется $3 и т. д. Количество инструкций не ограничено.

!8d10;$1c[>6];$1c1;$2-$3

Первая инструкция выполняет бросок 8 десятигранных костей.
Вторая инструкция подсчитывает, сколько костей со значением больше 6.
Третья инструкция подсчитывает количество костей, равных 1.
Четвёртая инструкция вычитает результат третьей инструкции из результата второй.

Список операторов

k: оставить
K: взорвать и оставить
kl: оставить наименьшие
s: сортировка
c: подсчёт
r: переброс
R: перебрасывать до
e: взорвать
a: перебросить и добавить
@: переход назад
p: раскрасить кости
m: объединить
i: условие
;: следующая инструкция
g: группа
b: привязка
#: комментарий

Оставить

!kX

Параметр сортирует итоговый список костей и выбирает X наибольших.

Взорвать и оставить

!KX

Кости взрываются, если выпавшее значение достигает максимума кости; параметр сортирует полученный список костей, а затем выбирает X костей с наибольшими значениями.

Примеры

!6d10K4

Бросьте 6 десятигранных костей, каждая выпавшая 10 взрывается. Значение взорвавшихся костей превышает 10. Результат: 40 details: 23 [10,10,3],9,5,3,1,1

Другой способ записи этой команды:

!6d10e10k4

Этот способ позволяет изменить порог взрыва.

Чтобы вычислить количество сохраняемых костей, оператор k работает с переменными. Нельзя напрямую разместить вычисление после k, но можно сослаться на предыдущее вычисление.

# Good
!5-3;10d10k$1

# BAD
!10d10k5-3

# BAD
!10d10k(5-3)

Оставить наименьшие

klX

Этот параметр сортирует итоговый список костей, а затем выбирает X наименьших.

Сортировка

!3D10s

Список костей отсортирован по убыванию.

!10d6sl

Выполняет бросок 6 костей с 6 гранями, после чего они сортируются по возрастанию.

Подсчёт

!3D10c[Validator]

Подсчитать, сколько костей удовлетворяют условию, и вывести число (подробнее о синтаксисе см. в разделе «Средство проверки»).

Перебросить

!3D10r[Validator]

Перебросить кость, если предыдущее значение соответствует средству проверки (подробнее о синтаксисе см. в разделе «Средство проверки»).

Перебрасывать до

!3D10R[Validator]

Работает как «Перебросить», но кости бросаются до тех пор, пока условие не станет ложным.

Взорвать

!3D10e[Validator]

Взорвать, пока значение соответствует средству проверки (подробнее о синтаксисе — в разделе «Средство проверки»).

!3D10e(3)[Validator]

У оператора взрыва можно задать ограничение на количество взрывов кости.

!3D10e(1d10)[Validator]

Ограничение задаётся выражением.

Примеры

!3D10e10

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

Результат: 49 details: 8, 12 [10,2], 29 [10,10,9]

!3D10e[>8]

Пока значение кости больше 8, кость перебрасывается, а её результат прибавляется к предыдущему значению кости.

Результат: 35 details: 3, 27 [9,10,8], 5

Добавить

!3D10a[Validator]

Перебросить кость, если её значение соответствует средству проверки, и прибавить новое значение к предыдущему. Это выполняется только один раз.

Вхождение

!10d10o

Подсчитать и отсортировать вхождения каждого значения. Результат: 3x1,1x2,3x4,2x9,1x10 - [1,1,1,2,4,4,4,9,9,10]

!10d10o2,7

Подсчитать и отсортировать вхождения, если они встречаются не менее 2 раз, значение — 7 или больше. Результат: 2x8 - [1,2,3,5,6,7,8,8,9,10]

!10d10o2[<6]

Подсчитать и отсортировать вхождения, встречающиеся не менее 2 раз; значение должно удовлетворять средству проверки (здесь — меньше 6). Результат: 2x3,2x5 - [3,3,5,5,6,6,6,7,7,8]

Ошибки

!10d10o[<6]

Эта команда вызывает предупреждение: оператор occurrence может иметь 0 или 2 параметра, а одно средство проверки пока не поддерживается.

Переход назад

Этот оператор применяет следующий оператор к предпоследнему результату. Например:

!8D10c[>=7]+@c[=10]

c[=10] в этой команде подсчитывает количество 10 в результате 8D10; если убрать @, будет предпринята попытка подсчитать количество 10 в результате c[>=7]. Результат c[>=7] — скалярное число (1 или 2 … (максимальное значение 8)); это не список костей.

Раскрасить

!8D10p[1:blue]

Раскрасить первую кость в списке в синий цвет.

!8d10p[2:blue]

Раскрасить первые две кости в списке в синий цвет.

https://gist.github.com/obiwankennedy/62101383d411e55d205e44df78aa5299

Набор доступных цветов зависит от клиентского приложения DiceParser.

В Rolisteam можно задать название любого цвета Qt или шестнадцатеричный код цвета: #ff28AC.
Приложение командной строки поддерживает несколько цветов: чёрный, белый, синий, красный, чёрный, зелёный, жёлтый.

Фильтр

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

!4d6f[!=6]

Результат:

total: 11 - details[5 2 6 4]

6 игнорируется.

Объединить

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

!1d6;1d8mk1

Эта команда объединяет результаты d6 и d8. Затем к обоим результатам применяется оператор k, чтобы оставить лучший. Следует учитывать, что этот оператор объединяет список инструкций. Ссылки на инструкции (например, $1 и т. п.) не будут работать после оператора merge.

Развёртывание

Взорвавшиеся кости считаются новыми костями. Оператор вызывается символом y.

!4d6e6y6k3

Первый результат: 10 [6, 4], 3, 3, 2
Результат после развёртывания: 6, 4, 3, 2
Итоговый результат: 6+4+3 = 13

Все одинаковые

Этот оператор временный. Он предназначен для решения проблемы системы Tunnels and Trolls. Именно поэтому оператор-маркер — t. Кости взрываются, когда у всех костей одинаковое значение.

!2d6t

> # Explode twice because 2,1
Result: 12 - details:[2d6t (5 [2,1,2] 7 [2,1,4])]

> # Nothing happened
Result: 10 - details:[2d6t (4 6)]

Уникальные

Взорвавшиеся кости считаются новыми костями.

!4d6e6u

Результат: 6 4 3 3 2 Итоговый результат: 6+4+3 = 13

Список значений

Создайте собственный список значений и примените любой оператор костей.

![10,25,43,8]k1

Получение более высокого результата с помощью нескольких инструкций:

!1d10;2d6+9;1d20;[$1,$2,$3,$4]k1

Каждое значение преобразуется в кость.

Привязка

Оператор bind работает точно так же, как merge, но оставляет массив инструкций без изменений.

!2d8;2d12b;$2k2;$2k2kl1;"your total is $3 with lowest: $4"

Бросаем две восьмигранные кости и две двенадцатигранные, затем объединяем их результаты оператором bind. Из полученного результата оставляем 2 старшие кости, после чего выделяем меньшую из двух. В конце выводим результат внутри предложения.

Если

Оператор if позволяет выполнить одно действие, если выполняются некоторые условия. Оператор if имеет 2 обязательных параметра:

условие (см. средство проверки)
инструкция, выполняемая, если условие истинно.

Также имеются 2 необязательных параметра:

способ сравнения
инструкция, выполняемая при ложном условии.

i*[]{}{}

*: метод сравнения
[]: средство проверки

Способ сравнения

Существует 4 способа сравнения.

Для каждой кости: условие проверяется для каждой кости из предыдущей части команды. [Способ по умолчанию]
Для каждого значения ?: условие проверяется для каждого конечного значения кости из предыдущей части команды.
Все кости *: чтобы сработала инструкция при истинном условии, все кости должны удовлетворять условию. Если не все кости удовлетворяют условию, выполняется инструкция при ложном условии.
Один из них .: чтобы сработала инструкция при истинном условии, хотя бы одна кость должна удовлетворять условию. Если ни одна кость не удовлетворяет условию, выполняется инструкция при ложном условии.
По скалярному значению :: условие вычисляется по скалярному результату броска костей.

Примеры:

!1d6i[<4]{3}

Если значение кости меньше 4, значение кости становится равным 3. (То есть 1, 2, 3 становятся 3).

!4d6e6i[=4]{-4}

Если значение кости равно 4, она удаляется. [Kuro System]

!4d6i.[=6]{+1d6}

Если хотя бы одна кость равна 6, бросается ещё один d6, и его результат прибавляется к итогу.

!4d6i*[=6]{+1d6}

Если все кости равны 6, бросается ещё один d6, и его результат прибавляется к итогу.

!2d10i:[>15]{"Success"}{"Fail"}

Если сумма двух костей больше 15, выводится «Успех», иначе — «Провал».

!2d10i:[>15]{"Success %1 "}{"Fail %1"}

То же, что выше, но итоговый результат показывается рядом с «Успех» или «Провал».

!2d10i:[>15]{"Success %1 [%2]"}{"Fail %1 [%2]"}

То же, что и выше, но результат каждой кости выводится в квадратных скобках.

Группа

Сгруппировать кости, затем подсчитать количество групп (система 7th Sea).

Сложный вывод

Оператор group может принимать параметр для включения сложного вывода. Такой вывод показывает каждую группу и все отложенные в сторону значения, если они есть. Чтобы включить этот вывод, требуется добавить s сразу после g. См. пример ниже:

Пример

!3d20g10

Будут брошены 3 кости, после чего предпринимается попытка сгруппировать их в группы по 10. Если выпадет 9 9 2, можно создать только одну группу, значение которой больше или равно десяти ({9,2}, вторая 9 остаётся «неиспользованной»).

Оператор g позволяет переупорядочивать кости для создания групп. При броске 4d20g10, если выпадает 7 4 3 6, результатом будет 2 ({7,3} и {6,4}).

!5d10gs10

Тогда итоговый вывод будет таким:

2 ({7,3}, {6,4} - [2])

{7,3} и {6,4} являются группами, а [2] оставлен в стороне.

Оператор выбора (S)

Оператор switch case позволяет преобразовать числовое значение в текст. Его цель — упростить это по сравнению с использованием нескольких if. Как и следовало ожидать, синтаксис близок к if.

!1d100S[<50]{"Low"}[>=50]{"Low"}

Также можно добавить параметр по умолчанию

!1d4S[=1]{"Low"}[=2]{"small"}[=3]{"medium"}{"big"}

Режим исключения: этот режим включается, когда за S следует ^.

!1d100S^[<25]{"Low"}[<50]{"small"}[<75]{"medium"}[>=75]{"big"}

Комментарий

!2D6 # Sword attack

Вывести «Атака мечом» и результат двух костей. DiceParser игнорирует всё, что идёт после #. Вся эта часть считается одним комментарием. Так DiceParser может ответить на вопрос:

!1L[yes,no] # Am I evil ?

Am I evil ? yes

Преобразовать

Преобразует кости в соответствии с условием в другое значение.

!5d10T[>5]{15}

Бросьте 5 костей с 10 гранями, затем замените все значения больше 5 на 15, а остальные — на 0.

(6,9,7,5,2) => (15,15,15,5,2)

Этот оператор принимает несколько условий: T[=5]{15}[=6]{16}

(6,9,7,5,2) => (16,9,7,15,2)

Можно также добавить завершающее выражение, чтобы изменить значение всех костей, не соответствующих условию: T[>5]{15}{0}

(6,9,7,5,2) => (15,15,15,0,0)

Функции

DiceParser предоставляет функции для работы с инструкциями. Некоторые функции появятся в ближайшее время (например: max, min). Это позволит управлять несколькими командами одновременно.

Повторение

!repeat(1d10,5)

Вывод:

2 - Details [2]
8 - Details [8]
3 - Details [3]
1 - Details [1]
10 - Details [10]

Внимание! Следует учитывать, что repeat плохо работает с командами, содержащими несколько инструкций.

Округление вниз

15/7 = 2.14286
Floor(15/7) = 2

Команда:

15/7;**floor($1)**;ceil($1);round($1)  
result: 2.14286,**2**,3,2

Округление вверх

15/7 = 2.14286
Ceil(15/7) = 3

Команда:

15/7;floor($1);**ceil($1)**;round($1)  
result: 2.14286,2, **3** ,2

Округление

15/7 = 2.14286
Round(15/7) = 2

Команда:

15/7;floor($1);ceil($1);**round($1)**  
result: 2.14286,2,3, **2**

Вывод

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

Бросок:

"result"

Вывод: result

Внутри оператора if можно задать строковую инструкцию:

1d6i:[>3]{"Success"}{"Fail"}

Вывод: Success или Fail

Это даёт быстрый ответ, но иногда требуется увидеть выпавшие значения. DiceParser позволяет заменить некоторые специальные метки, чтобы показать значения, результат вычислений и прочее.

Сокращения

Имеются 3 метки-сокращения.

%1: последний скалярный результат каждой инструкции.
%2: все результаты броска костей.
%3: последний скалярный результат последней инструкции.

По умолчанию вывод имеет вид %1 details[%2]. То есть показывается последний скалярный результат каждой инструкции и результат броска костей.

%1 и %3 эквивалентны, если инструкция только одна (без ;).

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

Итоговый результат

Также можно ссылаться на конечное значение конкретной инструкции (результат должен быть числом или строкой)

Чтобы сослаться на первую инструкцию: $1
Чтобы сослаться на вторую инструкцию: $2
Чтобы сослаться на третью инструкцию: $3

Количество инструкций не ограничено.

Строка как итоговый результат

Можно ссылаться на подрезультат строкового результата, добавив [x] после ссылки на инструкцию. Пример поможет разобраться.

!2Lu[cats,dogs,rats,rabbits,bats,squirrels]

Результат по умолчанию выглядит так:

cats,bats

Теперь нужно составить предложение из этого текста:

!2Lu[cats,dogs,rats,rabbits,bats,squirrels];"You love $1 and you are afraid of $1"

Поскольку $1 ссылается на «cats,bats», будет показано:

You love cats,bats and you are afraid of cats,bats

Итак, это не очень полезно. Чтобы немного улучшить ситуацию, нужно добавить несколько подындексов.

!2Lu[cats,dogs,rats,rabbits,bats,squirrels];"You love $1[0] and you are afraid of $1[1]"

Тогда вывод будет правильным.

You love cats and you are afraid of bats

Рассмотрим несколько примеров:

!8d10;$1c[>6];$1c1;$2-$3

По умолчанию вывод имеет вид: 45,4,0,4 details[4,3,10,7,2,2,7,10]

!8d10;$1c[>6];$1c1;$2-$3i:[>0]{"%3 Success[%2]"}{i:[<0]{"Critical fail %3 [%2]"}{"Fail %3 [%2]"}}

Вот пример вывода:

4 Success[4,3,10,7,2,2,7,10]
Fail 0 [10,3,1,1,2,2,7,5] (2 успеха - 2 провала = 0)
Critical fail -2 [1,3,1,1,2,2,7,5] (1 успех - 3 провала = -2)

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

!8d10;$1c[>6];$1c1;$2-$3;$4i:[=0]{"Fail $4 [%2]"}{$4i:[>0]{"$2 Success[%2]"}{$2i:[=0]{"Critical Fail $4 [%2]"}{"Fail $4 [%2]"}}}

Ещё один пример, показывающий, как объединить строковый результат с результатом броска костей.

!1d6+1;1L[gold coins,spell scrolls,weapons];"You found $1 $2"

You found 5 gold coins

Результат броска костей

DiceParser предоставляет метки для показа результата броска (а также каждого выпавшего значения конкретной инструкции).

Для показа значений костей из конкретной инструкции достаточно добавить @ и номер инструкции (например, @1)

!2d6;3d8;"Result $2 - d8:[@2] - d6:[@1]"

Вывод:

Result 15 - d8:[7,4,4] - d6:[3,6]`

Новая строка

Может потребоваться вывести результат на несколько строк. Это совсем просто:

!1d100;1d10;"Attack: $1\nDamage: $2"

Эта команда выведет:

Attack: 31

Damage: 7

Арифметика

Rolisteam Dice Parser позволяет вычислять простейшие арифметические операции, такие как +, -, /, *, а также учитывает приоритет этих операторов и поддерживает скобки.

!8+8+8
Result: 24

!24-4
Result: 20

!(3+4)*2
Result: 14

!7/2
Result: 3.5

!15|6
Result: 2

!15/6
Result: 2.5

Бросьте 2 кости и прибавьте 3 к их сумме. Затем результат используется как количество костей для броска: !(3+2D6)D10

Арифметика и кости

Поддерживается выполнение арифметических операций над костями. Обратите внимание, что по умолчанию список костей преобразуется в скалярное число суммированием. Так, при броске 3d6 результатом будет список из 3 значений {2, 5 ,1}. Теперь рассмотрим немного изменённую команду 3d6+4: она вычисляется так: {2, 5 ,1} = 8; 8+4 = 12. Итоговый результат — 12.

!3d6+4 ⇾ Бросьте 3 кости, сложите результаты и прибавьте 4:
!10D10-2 ⇾ Бросьте 10 костей, сложите результаты, затем вычтите 2
!87-1D20 ⇾ Вычтите из 87 результат броска одной кости
!(6-4)D10 ⇾ Вычтите 4 из 6, затем бросьте две кости.
!1D10/2 ⇾ Разделите результат броска одной кости на 2.
!(2+2)**2 ⇾ Результат: 16
!1d10**2 ⇾ Бросьте 1d10, затем умножьте результат на самого себя.
!15|2 ⇾ Целочисленное деление 15 на 2. Результат: 7
!15/2 ⇾ Деление 15 на 2. Результат: 7.5

Средство проверки

Существует пять видов средств проверки:

Скаляр
Диапазон
Логическое выражение
Операция с условием
Составное

Любой оператор, которому требуется средство проверки (например, a,r,e,c), может использовать эти три вида.

Скаляр

Скалярное значение задаёт в качестве проверки равенство значения кости этому числу.

!4d10e10

Эта команда означает: бросить 4 кости, и они взрываются при выпадении 10.

Диапазон

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

!4d10c[8..10]
!1d[-1..8]

Логическое условие

Команда подсчитывает, сколько костей имеют значения от >=8 до <=10.

!4d10c[>7]

Команда подсчитывает, сколько костей выпало больше 7.

Оператор сравнения

Rolisteam Dice Parser позволяет использовать несколько логических операторов:

Равно: =
Больше или равно: >=
Меньше или равно: <=
Меньше: <
Больше: >
Не равно: !=

Способы сравнения

Как и для оператора if, можно указать способ сравнения.

Для каждой кости: условие проверяется для каждой кости из предыдущей части команды. [Способ по умолчанию]
Для каждого значения ?: условие проверяется для каждого конечного значения кости из предыдущей части команды.
Все кости *: чтобы сработала инструкция при истинном условии, все кости должны удовлетворять условию. Если не все кости удовлетворяют условию, выполняется инструкция при ложном условии.
Один из них .: чтобы сработала инструкция при истинном условии, хотя бы одна кость должна удовлетворять условию. Если ни одна кость не удовлетворяет условию, выполняется инструкция при ложном условии.
По скалярному значению :: условие вычисляется по скалярному результату броска костей.

Примеры:

!1L[7,8,9]c[>6]

Эта команда вернёт 0, так как ни одна кость не брошена, поэтому результат 1L[7,8,9] — конечное значение.

!1L[7,8,9]c[?>6]

Вывод: 1

!5d6e6sc[>=8]

Вывод:

0 details: [8 [6,2] 2 1 1 1]

!5d6e6f[?>=16]

Вывод: итоговая сумма равна 11. Она меньше 16, поэтому фильтр отфильтровывает всё.

0 details: [2 4 1 3 1]

Итоговая сумма больше 16, поэтому оператор filter принимает весь результат.

23 details: [3 6 3 5 6]

!5d6e6sc[:>=8]

Вывод:

1 details: [8 [6,2] 2 1 1 1]

Операция с условием

Это средство проверки предоставляет в качестве операции взятие по модулю и логическое условие для проверки значения:

!4d10c[%2=0]

Подсчитывает, сколько выпало чётных чисел.

!4d10c[%2=1]

Подсчитывает, сколько выпало нечётных чисел.

Остаток от деления

Составное средство проверки

Средство проверки может быть результатом объединения нескольких средств проверки.

!4d10c[>4&%2=0]

Подсчитать все кости, значения которых больше 4 и чётные [6,8,10].

Составное средство проверки поддерживает 3 логические операции:

И: &
ИЛИ: |
Исключающее ИЛИ: ^

Составное средство проверки принимает столько средств проверки, сколько нужно:

!9d100c[=1|=3|=5|=7|=11|=13|=17|=19|=23|=29|=31|=37|=41|=43|=47|=53|=59|=61|=67|=71|=73|=79|=83|=89|=97]

Оператор списка

Текстовые значения

Оператор L (или l), означающий список, предоставляет способ извлечь значение из списка.

!1L[sword,bow,knife,gun,shotgun]

С комментарием

!1L[yes,no] # Am I evil ?

Am I evil ? yes

Получение уникальных значений

Параметр u запрашивает уникальные значения.

!2Lu[yes,no]

Эта команда может вернуть yes,no или no,yes. Параметр u делает невозможным возврат yes,yes или no,no.

Удаление запятой между значениями

По умолчанию результаты выводятся с запятой между значениями. Убрать запятую можно с помощью параметра n.

!2Ln[to,kyo]

Эта команда может вернуть toto, kyokyo, tokyo или kyoto.

Уникальные значения без запятой

!2Lun[to,kyo]

или

!2Lnu[to,kyo]

Эти команды могут вернуть tokyo или kyoto.

Числовые значения

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

!1L[-1,0,1,2,3,4]+7

Одновременное использование текста и числа

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

В будущих выпусках поведение изменится: решение будет приниматься на основе набора данных. Если набор данных содержит только числа, вычисление возможно. В противном случае результат будет рассматриваться как строка.

Изменение вероятности

Существует два основных способа управления вероятностью выпадения при выборе в списке.

Метод муравья

!1L[2,2,3,3,3,3,4,4,4,5]

или

!1L[arm,arm,leg,leg,chest,chest,chest,head]

Ленивый метод

По диапазону:

!1L[1,2,3,4,5,6[6..10]]

По весу:

!1L[1[2],2[2],3[4]]

Несколько результатов:

Прочие примеры

!3D100

Бросьте 3 кости со 100 гранями.

!10D10e[=10]s

Бросьте 10 костей с 10 гранями, каждая выпавшая 10 взрывается, и отсортируйте результат.

!100291D66666666s

Бросьте 100291 кость с 66666666666 гранями и отсортируйте результат.

!15D10c[>7]

Бросьте 15 костей с 10 гранями и подсчитайте, у скольких значение больше 7.

!1D8+2D6+7

Бросьте 1 кость с 8 гранями, прибавьте её результат к результату 2 костей с 6 гранями и добавьте 7.

!D25

Бросьте 1 кость с 25 гранями.

!88-1D20

88 минус значение 1 кости с 20 гранями

!8+8+8

Вычислить: 24

!1L[sword,bow,knife,gun,shotgun]

Будет выбрано одно из этих слов.

!8D10c[Validator1]-@c[validator2]

Бросьте 8 костей с 10 гранями, затем подсчитайте, сколько костей удовлетворяют условию первого средства проверки, вычтите количество костей, удовлетворяющих второму, и выведите число (подробнее о синтаксисе см. в разделе «Средство проверки»).

!8D10c[>=6]-@c[=1]

Система Old World in darkness.

!8D10c[>=7]+@c[=10]

Система Exalted 2-го издания.

Добавление макросов и порядок

Допустим, нужно определить 2 макроса: a и aa.

Их нужно добавлять от более сложного названия к самому простому.

Плохо

a => 1d10
aa => 2d10

Запуск aa: система макросов сравнит aa с первым макросом a, и они совпадут. Первое вычисление: aa => 1d10a. Второе вычисление: 1d10a => 1d101d10. Итоговая команда для выполнения: 1d101d10

Хорошо

aa => 2d10
a => 1d10

При выполнении команды aa система макросов сравнит aa с aa: совпадение. Первое вычисление: aa => 2d10. Итоговая команда для выполнения: 2d10

Некоторые правила

Использовать регулярное выражение для ограничения подстановки текста
Использовать совершенно другое имя
Избегать шаблонов макросов, которые содержатся в других шаблонах макросов

Всё должно быть в порядке.

Документирование макросов

Примеры и дополнительная информация

Отчёты об ошибках и новые возможности

Оформите заявку в нашей системе отслеживания ошибок. Или свяжитесь с нами в Discord или воспользуйтесь другими способами