258 lines
10 KiB
Python
258 lines
10 KiB
Python
import re
|
|
import secrets
|
|
|
|
import numpy as np
|
|
|
|
from config import Config
|
|
from core.utils.text import remove_prefix
|
|
|
|
MAX_DICE_COUNT = Config('dice_limit', 100) # 一次摇动最多的骰子数量
|
|
MAX_ROLL_TIMES = Config('dice_roll_limit', 10) # 一次命令最多的摇动次数
|
|
MAX_MOD_NUMBER = Config('dice_mod_max', 10000) # 骰子最大加权值
|
|
MIN_MOD_NUMBER = Config('dice_mod_min', -10000) # 骰子最小加权值
|
|
MAX_OUTPUT_CNT = Config('dice_output_cnt', 50) # 输出的最多数据量
|
|
MAX_OUTPUT_LEN = Config('dice_output_len', 200) # 输出的最大长度
|
|
MAX_DETAIL_CNT = Config('dice_detail_cnt', 5) # n次摇动的骰子的总量超过该值时将不再显示详细信息
|
|
MAX_ITEM_COUNT = Config('dice_count_limit', 10) # 骰子多项式最多的项数
|
|
|
|
|
|
class DiceSyntaxError(Exception):
|
|
"""骰子语法错误"""
|
|
|
|
def __init__(self, session, message):
|
|
self.message = session.locale.t("dice.message.error.syntax") + message
|
|
|
|
|
|
class DiceValueError(Exception):
|
|
"""骰子参数值错误"""
|
|
|
|
def __init__(self, session, message, value=None):
|
|
if value is not None:
|
|
self.message = session.locale.t("dice.message.error.value.invalid", value=value) + message
|
|
else:
|
|
self.message = session.locale.t("dice.message.error.value") + message
|
|
|
|
|
|
class DiceItemBase(object):
|
|
"""骰子项的基类"""
|
|
|
|
def __init__(self, dice_code: str, positive: bool):
|
|
self.positive = positive
|
|
self.code = dice_code
|
|
self.result = None
|
|
self.detail = ''
|
|
|
|
def GetResult(self, abs=True):
|
|
if abs:
|
|
return self.result
|
|
else:
|
|
return self.result if self.positive else -self.result
|
|
|
|
def GetDetail(self):
|
|
return self.detail
|
|
|
|
def Roll(self, session):
|
|
pass
|
|
|
|
|
|
class DiceMod(DiceItemBase):
|
|
"""调节值项"""
|
|
|
|
def __init__(self, session, dice_code: str, positive: bool):
|
|
super().__init__(dice_code, positive)
|
|
if not dice_code.isdigit():
|
|
raise DiceValueError(session,
|
|
session.locale.t("dice.message.error.value.M.invalid"),
|
|
'+' if self.positive else '-' + dice_code)
|
|
else:
|
|
self.result = int(dice_code)
|
|
if self.result > MAX_MOD_NUMBER or self.result < MIN_MOD_NUMBER:
|
|
raise DiceValueError(session,
|
|
session.locale.t("dice.message.error.value.M.out_of_range", min=MIN_MOD_NUMBER,
|
|
max=MAX_MOD_NUMBER),
|
|
self.result)
|
|
|
|
def GetDetail(self):
|
|
return self.result
|
|
|
|
|
|
class Dice(DiceItemBase):
|
|
"""骰子项"""
|
|
|
|
def __init__(self, session, dice_code: str, positive: bool):
|
|
dice_code = dice_code.replace(' ', '')
|
|
super().__init__(dice_code, positive)
|
|
args = self.GetArgs(session)
|
|
self.count = args[0]
|
|
self.type = args[1]
|
|
self.adv = args[2]
|
|
if self.count <= 0 or self.count > MAX_DICE_COUNT:
|
|
raise DiceValueError(session,
|
|
session.locale.t("dice.message.error.value.n.out_of_range", max=MAX_DICE_COUNT),
|
|
self.count)
|
|
if self.type <= 0:
|
|
raise DiceValueError(session,
|
|
session.locale.t("dice.message.error.value.n.less2"),
|
|
self.count)
|
|
if self.type == 1:
|
|
raise DiceValueError(session, session.locale.t("dice.message.error.value.n.d1"))
|
|
if abs(self.adv) > self.count:
|
|
raise DiceValueError(session,
|
|
session.locale.t("dice.message.error.value.k.out_of_range"),
|
|
self.adv)
|
|
|
|
def GetArgs(self, session):
|
|
dice_code = self.code.upper() # 便于识别
|
|
dice_count = '1' # 骰子数量
|
|
advantage = '0' # 保留的骰子量
|
|
if re.search(r'[^0-9DKL]', dice_code):
|
|
raise DiceSyntaxError(session, session.locale.t("dice.message.error.syntax.invalid"))
|
|
if 'D' not in dice_code:
|
|
raise DiceSyntaxError(session, session.locale.t("dice.message.error.syntax.missing_d"))
|
|
temp = dice_code.split('D')
|
|
if len(temp[0]):
|
|
dice_count = temp[0]
|
|
else:
|
|
dice_count = '1'
|
|
midstrs = temp[1].partition('K')
|
|
dice_type = midstrs[0]
|
|
if 'K' in midstrs[1]:
|
|
advantage = midstrs[2].replace('L', '-')
|
|
if not len(advantage.removeprefix('-')):
|
|
advantage += '1' # K/KL后没有值默认为1
|
|
# 语法合法检定
|
|
if not dice_count.isdigit():
|
|
raise DiceValueError(session,
|
|
session.locale.t("dice.message.error.value.m.invalid"),
|
|
dice_count)
|
|
if not dice_type.isdigit():
|
|
raise DiceValueError(session,
|
|
session.locale.t("dice.message.error.value.n.invalid"),
|
|
dice_type)
|
|
if not (advantage.isdigit() or (advantage[0] == '-' and advantage[1:].isdigit())):
|
|
raise DiceValueError(session,
|
|
session.locale.t("dice.message.error.value.k.invalid"),
|
|
advantage)
|
|
return (int(dice_count), int(dice_type), int(advantage))
|
|
|
|
def Roll(self, session):
|
|
output = ''
|
|
result = 0
|
|
dice_results = []
|
|
adv = self.adv
|
|
output += self.code + ' = '
|
|
# 生成随机序列
|
|
for i in range(self.count):
|
|
dice_results.append(secrets.randbelow(int(self.type)) + 1)
|
|
if adv != 0:
|
|
new_results = []
|
|
indexes = np.array(dice_results).argsort()
|
|
indexes = indexes[-adv:] if adv > 0 else indexes[:-adv]
|
|
output += '( '
|
|
output_buffer = ''
|
|
for i in range(self.count):
|
|
output_buffer += str(dice_results[i])
|
|
if i in indexes:
|
|
new_results.append(dice_results[i])
|
|
output_buffer += '*'
|
|
if i < self.count - 1:
|
|
output_buffer += ','
|
|
if self.count >= MAX_OUTPUT_CNT:
|
|
output_buffer = session.locale.t("dice.message.output.too_long", length=self.count)
|
|
output += output_buffer + ' ) = '
|
|
dice_results = new_results
|
|
# 公用加法
|
|
length = len(dice_results)
|
|
if (length > 1):
|
|
output += '[ '
|
|
if length > MAX_OUTPUT_CNT: # 显示数据含100
|
|
output += session.locale.t("dice.message.output.too_long", length=length)
|
|
for i in range(length):
|
|
result += dice_results[i]
|
|
if length <= MAX_OUTPUT_CNT: # 显示数据含100
|
|
output += str(dice_results[i])
|
|
if i < length - 1:
|
|
output += '+'
|
|
output += ' ] = '
|
|
else:
|
|
result = dice_results[0]
|
|
if len(output) > MAX_OUTPUT_LEN:
|
|
output = session.locale.t("dice.message.too_long")
|
|
self.detail = output + f"{result} "
|
|
self.result = result
|
|
|
|
|
|
async def GenerateMessage(msg, dices: str, times: int, dc: int):
|
|
if not all([MAX_DICE_COUNT > 0, MAX_ROLL_TIMES > 0, MAX_MOD_NUMBER >= MIN_MOD_NUMBER, MAX_OUTPUT_CNT > 0,
|
|
MAX_OUTPUT_LEN > 0, MAX_DETAIL_CNT > 0, MAX_ITEM_COUNT > 0]):
|
|
raise OverflowError(msg.locale.t("error.config.invalid"))
|
|
if re.search(r'[^0-9+\-DKL]', dices.upper()):
|
|
return DiceSyntaxError(msg, msg.locale.t('dice.message.error.syntax.invalid')).message
|
|
if times > MAX_ROLL_TIMES or times < 1:
|
|
return DiceValueError(msg, msg.locale.t('dice.message.error.value.N.out_of_range', max=MAX_ROLL_TIMES),
|
|
times).message
|
|
dice_code_cist = re.compile(r'[+-]?[^+-]+').findall(dices)
|
|
dice_list = []
|
|
have_err = False
|
|
output = ""
|
|
dice_count = 0
|
|
i = 0
|
|
if len(dice_code_cist) > MAX_ITEM_COUNT:
|
|
return DiceValueError(msg, msg.locale.t('dice.message.error.value.too_long'), len(dice_code_cist)).message
|
|
# 初始化骰子序列
|
|
for item in dice_code_cist:
|
|
i += 1
|
|
is_add = True
|
|
if item[0] == '-':
|
|
is_add = False
|
|
item = item[1:]
|
|
if item[0] == '+':
|
|
item = item[1:]
|
|
try:
|
|
if 'D' in item or 'd' in item:
|
|
d = Dice(msg, item, is_add)
|
|
dice_list.append(d)
|
|
dice_count += d.count
|
|
elif item.isdigit():
|
|
dice_list.append(DiceMod(msg, item, is_add))
|
|
except (DiceSyntaxError, DiceValueError) as ex:
|
|
output += '\n' + msg.locale.t('dice.message.error.prompt', i=i) + ex.message
|
|
have_err = True
|
|
if have_err:
|
|
return msg.locale.t('dice.message.error') + output
|
|
success_num = 0
|
|
fail_num = 0
|
|
output = msg.locale.t('dice.message.output')
|
|
# 开始投掷并输出
|
|
for i in range(times):
|
|
output_line = ''
|
|
result = 0
|
|
for dice in dice_list:
|
|
dice.Roll(msg)
|
|
output_line += '+' if dice.positive else '-'
|
|
if isinstance(dice, Dice) and times * dice_count < MAX_DETAIL_CNT:
|
|
output_line += f'( {dice.GetDetail()})'
|
|
else:
|
|
output_line += str(dice.GetResult())
|
|
result += dice.GetResult(False)
|
|
output_line = remove_prefix(output_line, '+') # 移除多项式首个+
|
|
output_line += ' = ' + str(result)
|
|
if dc != 0:
|
|
if msg.data.options.get('dice_dc_reversed'):
|
|
if result <= dc:
|
|
output_line += msg.locale.t('dice.message.dc.success')
|
|
success_num += 1
|
|
else:
|
|
output_line += msg.locale.t('dice.message.dc.failed')
|
|
fail_num += 1
|
|
else:
|
|
if result >= dc:
|
|
output_line += msg.locale.t('dice.message.dc.success')
|
|
success_num += 1
|
|
else:
|
|
output_line += msg.locale.t('dice.message.dc.failed')
|
|
fail_num += 1
|
|
output += f'\n{dices} = {output_line}'
|
|
if dc != 0 and times > 1:
|
|
output += '\n' + msg.locale.t('dice.message.dc.check', success=str(success_num), failed=str(fail_num))
|
|
return output
|