pymud 0.20.4__py3-none-any.whl → 0.21.0__py3-none-any.whl

pymud/pkuxkx.py

@@ -1,156 +1,281 @@
 # 示例脚本：如何在PyMud中玩PKUXKX
 
 import webbrowser
-from pymud import Alias, Trigger, SimpleCommand, Timer, SimpleTrigger, SimpleAlias
+from pymud import Session, IConfig, alias, trigger, timer, gmcp, Alias, Trigger, Timer, SimpleTrigger, SimpleAlias
 
 # 在PyMud中，使用#load {filename}可以加载对应的配置作为脚本文件以提供支撑。支持多脚本加载
-# 本示例脚本对PyMud支持的变量(Variable)、触发器(Trigger，包含单行与多行触发)、别名(Alias)、定时器(Timer)、命令(Command，本示例中使用了SimpleCommand子类)都进行了代码示例
-# 使用#load {filename}加载的配置文件中，若有一个类型名为Coniguration，则在#load操作时，会自动创建此类型；若没有Configuration类，则仅将文件引入
+# 本示例脚本对PyMud支持的变量(Variable)、触发器(Trigger，包含单行与多行触发)、别名(Alias)、定时器(Timer)进行了代码示例
+# 使用#load {filename}加载的配置文件中，若有一个类型继承自IConfig，则在#load操作时，会自动创建此类型；若没有继承自IConfig的类，则仅将文件引入
 # 例如，加载本文件指定的配置，则使用 #load pymud.pkuxkx即可
 
-# PyMud中，触发器Trigger、别名Alias、命令Command，都是匹配对象(MatchObject)的子类，使用同一种处理逻辑
-# 匹配对象，意味着有匹配的pattern。在匹配对象成功后，会调用对象的onSuccess方法
-# Trigger、Alias仅有成功，即仅onSuccess方法会被调用，该方法参数参考了MushClient，会传递name, line, wildcards三个参数，含义与MushClient相同；
+# 定义一个自定义配置类，并继承自IConfig。
+# 目前不在推荐使用Configuration类，而是使用IConfig接口。因为只有使用IConfig接口，才能在类型函数中自动管理由装饰器创建的对象
+class MyConfig(IConfig):
+    # 类的构造函数，传递参数session，是会话本身。另外请保留*args和**kwargs，以便后续扩展
+    def __init__(self, session: Session, *args, **kwargs) -> None:
+        # 建议将 super().__init__()放在类型init的首句代码，该代码用于对装饰器@alias等函数所装饰的对象进行管理
+        # 调用super().__init__()时，会自动将session传递给父类，以便后续使用。
+        # 因此此处无需再使用self.session = session来保存传递的会话类型
+        # 
+        super().__init__(session, *args, **kwargs)
 
+        # 所有自行构建的对象， 建议统一放到self._objs中，方便管理和卸载。
+        # 目前加载卸载可以支持字典、列表、单个对象均可。此处使用字典，是为了方便后续处理其中某个单个对象。
+        # 对象创建时将自动增加到会话中，不需要手动调用session.addObject操作了
+        self._objs = {
+            # 别名，触发器可以通过创建一个对应类型的实例来生成
+            "tri_gem"   : SimpleTrigger(self.session ,r'^[> ]*从.+身上.+[◎☆★].+', "pack gem", group = "sys"),
+            "ali_yz_xm" : SimpleAlias(self.session ,'^yz_xm$', "w;#wa 100;w;#wa 100;w;#wa 100;w", group = "sys")
+        }
 
-class Configuration:
+        # 将自定义的状态窗口函数赋值给会话的status_maker属性，这样会话就会使用该函数来显示状态信息。
+        self.session.status_maker = self.status_window
 
-    # hpbrief long情况下的含义
-    HP_KEYS = (
-        "combat_exp", "potential", "max_neili", "neili", "max_jingli", "jingli", 
-        "max_qi", "eff_qi", "qi", "max_jing", "eff_jing", "jing", 
-        "vigour/qi", "vigour/yuan", "food", "water", "fighting", "busy"
-        )
-
-    # 类的构造函数，传递参数session，是会话本身
-    def __init__(self, session) -> None:
-        self.session = session
-        self._triggers = {}
-        self._commands = {}
-        self._aliases  = {}
-        self._timers   = {}
-
-        self._initTriggers()
-        self._initCommands()
-        self._initAliases()
-        self._initTimers()
-
-    def _initTriggers(self):
-        '''
-        初始化触发器。
-        本示例中创建了2个触发器，分别对应fullme的链接触发自动打开浏览器访问该网址，以及hpbrief命令的触发器
-        '''
-        # Trigger的构造函数中，给定的位置参数仅有session(会话)和pattern(匹配模式)两个，其他所有参数都是使用命名参数进行实现
-        # 支持的命名参数详细可参见 BaseObject与MatchObject 的构造方法，此处简单列举
-        # id         : 唯一标识，不指定时自动生成
-        # group      : 组名，不指定时为空
-        # enabled    : 使能状态，默认True
-        # priority   : 优先级，默认100，越小越高
-        # oneShot    : 单次匹配，默认False
-        # ignoreCase : 忽略大小写，默认False
-        # isRegExp   : 正则表达式模式，默认True
-        # keepEval   : 持续匹配，默认False
-        # raw        : 原始匹配方式，默认False。原始匹配方式下，不对VT100下的ANSI颜色进行解码，因此可以匹配颜色；正常匹配仅匹配文本
         
-        # 1. fullme的链接对应的触发器，匹配URL
-        # 当匹配成功后，调用ontri_webpage
-        self._triggers["tri_webpage"] = self.tri_webpage = Trigger(self.session, id = 'tri_webpage', patterns = r'^http://fullme.pkuxkx.net/robot.php.+$', group = "sys", onSuccess =  lambda id, line, wildcards: webbrowser.open(line))
-        # 2. fullme的链接对应的触发器，因为要进行多行匹配（3行），因此匹配模式pattern为3个正则表达式模式构成的元组（所有列表类型均可识别），无需像MushClient一样要指定multiline标识和linesToMatch数量
-        # 当匹配成功后，调用ontri_hpbrief
-        # 特别说明：此处的hpbrief触发匹配，需要set hpbrief long后才可以支持
-        self._triggers["tri_hp"]      = self.tri_hp      = Trigger(self.session, id = 'tri_hpbrief', patterns = (r'^[> ]*#(\d+.?\d*[KM]?),(\d+),(\d+),(\d+),(\d+),(\d+)$', r'^[> ]*#(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)$', r'^[> ]*#(\d+),(\d+),(-?\d+),(-?\d+),(\d+),(\d+)$',), group = "sys", onSuccess = self.ontri_hpbrief)
-        
-        # 3. 现在支持简单Trigger了，例如
-        self._triggers["tri_gem"] = SimpleTrigger(self.session ,r'^[> ]*从.+身上.+[◎☆★].+', "pack gem", group = "sys")
-
-        self.session.addTriggers(self._triggers)
-
-
-    def _initCommands(self):
-        '''初始化命令，本示例中创建了1个命令，支持hpbrief命令'''
-
-        # Command是异步执行的命令，可以理解为Alias+Trigger+Timer的组合。在MUD中发出一条命令后，会有成功、失败、超时的不同状态，在这三种状态下，会分别调用onSuccess、onFailure、onTimeout方法
-        # 举个Command的应用例子说明：加入把移动（s/e/n/w等等）实现为一个Command。
-        # 1. 当向某个方向移动时，成功的时候会移动到下一个房间；
-        # 2. 不成功的时候，会出现“这个方向没有出路”等描述；
-        # 3. 而当角色处于晕倒状态时，移动命令是不会有任何反应的，超出设定超时时间之后，会调用onTimeout
-        # 在上述实现情况下，我们在执行命令时，可以明确的根据命令的执行结果再判断下一步该做什么
-        # 本示例使用了简单命令SimpleCommand，其在MatchObject的基础上，增加了以下参数：
-        # 1. succ_tri: 命令执行成功时的触发器，不能为空
-        # 2. fail_tri: 命令执行失败时的触发器，可以为空
-        # 3. retry_tri: 需要重新尝试命令的触发器，可以为空（仍以移动为例，当向某个方向移动，出现“你现在正忙着呢”之后，可以在等待2s之后，再次尝试该命令，知道到达最大尝试次数
-
-        # 命令可以同步调用，也可以在异步函数（async）中使用await语法异步调用
-        # 例如，下面的hpbrief可以在这样使用：
-        # self.session.exec_command("hpbrief")
-        # self.session.exec_command_after(2, "hpbrief")
-        # await self.cmd_hpbrief.execute("hpbrief")
-
-        # 异步实现意味着，在函数实现过程中可以以循环实现，而不是以回调实现，有利于代码的可读性
-        # 假设已经实现了一个 cmd_move 的 Command，现在要从ct 执行"s;s;w"行走指令到达春来茶馆，然后根据当前的hpbrief结果判断是否需要drink，然后走回中央广场，可以在函数中这样实现：
-        # async def gotodrink(self):
-        #     for step in "s;s;w".split(";"):
-        #         await self.cmd_move.execute(step)
-        #         await self.cmd_hpbrief.execute("hpbrief")
-        #     await asyncio.sleep(1)
-        #     water = self.session.getVariable("water")
-        #     if int(water) < 300:
-        #         self.session.writeline("drink")
-        #     await asyncio.sleep(1)
-        #     for step in "e;n;n".split(";"):
-        #         await self.cmd_move.execute(step)
-
-
-        self._commands['cmd_hpbrief']    = self.cmd_hpbrief     = SimpleCommand(self.session, id = "cmd_hpbrief", patterns = "^hpbrief$", succ_tri = self.tri_hp, group = "status", onSuccess = self.oncmd_hpbrief)
-        self.session.addCommands(self._commands)
-
-    def _initAliases(self):
-        '''初始化别名，本示例中创建了1个别名，是get xxx from corpse'''
-
-        #  get xxx from corpse的别名操作，匹配成功后会自动调用getfromcorpse函数
-        #  例如， gp silver 相当于 get silver from corpse
-        self._aliases['ali_get'] = Alias(self.session, r"^gp\s(.+)$", id = "ali_get", onSuccess = self.getfromcorpse)
-
-        # 3. 现在支持简单Alias了，在其中也可以支持#wait（缩写为#wa操作）等待，当然，Trigger也支持
-        # 从扬州中心广场到西门的行走，每步中间插入100ms等待
-        self._aliases["ali_yz_xm"] = SimpleAlias(self.session ,'^yz_xm$', "w;#wa 100;w;#wa 100;w;#wa 100;w", group = "sys")
-
-        self.session.addAliases(self._aliases)
-
-    def _initTimers(self):
-        '''初始化定时器，本示例中创建了1个定时器，每隔2秒打印信息'''
-
-        self._timers["tm_test"] = self.tm_test = Timer(self.session, timeout = 2, id = "tm_test", onSuccess = self.onTimer)
-        self.session.addTimers(self._timers)
-
-    def getfromcorpse(self, name, line, wildcards):
+    # 如果仅使用了装饰器定义的PyMUD对象（Alias，Trigger等），则无需实现__unload__方法。
+    # 但如果自定义了PyMUD对象，那么必须实现__unload__方法，否则会导致加载的对象无法被正常卸载。
+    # 如果实现了__unload__方法，那么在该方法中必须调用super().__unload__()，否则会导致@alias等函数装饰器生成的对象不能被正常卸载
+    def __unload__(self):
+        # 在__unload__方法中定义卸载时需要从会话中清除的对象。
+        # 目前加载卸载可以支持字典、列表、单个对象均可。
+        self.session.delObjects(self._objs)
+
+        # 不要遗漏 super().__unload__()，否则会导致@alias等函数装饰器生成的对象不能被正常卸载
+        super().__unload__()
+
+    # 别名， gp gold = get gold from corpse
+    @alias(r"^gp\s(.+)$", id = "ali_get", group = "sys")
+    def getfromcorpse(self, id, line, wildcards):
         cmd = f"get {wildcards[0]} from corpse"
         self.session.writeline(cmd)
 
-    def onTimer(self, name, *args, **kwargs):
-        self.session.info("每2秒都会打印本信息", "定时器测试")
-
-    def ontri_hpbrief(self, name, line, wildcards):
-        self.session.setVariables(self.HP_KEYS, wildcards)
-
-    def oncmd_hpbrief(self, name, cmd, line, wildcards):
-        # 为了节省服务器资源，应使用hpbrief来代替hp指令
-        # 但是hpbrief指令的数据看起来太麻烦，所以将hpbrief的一串数字输出成类似hp的样式
-        # ┌───个人状态────────────────────┬─────────────────────────────┐
-        # │【精神】 1502    / 1502     [100%]    │【精力】 4002    / 4002    (+   0)    │
-        # │【气血】 2500    / 2500     [100%]    │【内力】 5324    / 5458    (+   0)    │
-        # │【真气】 0       / 0        [  0%]    │【禅定】 101%               [正常]    │
-        # │【食物】 222     / 400      [缺食]    │【潜能】 36,955                       │
-        # │【饮水】 247     / 400      [缺水]    │【经验】 2,341,005                    │
-        # ├─────────────────────────────┴─────────────────────────────┤
-        # │【状态】 健康、怒                                                             │
-        # └────────────────────────────────────────────北大侠客行────────┘
-        var1 = self.session.getVariables(("jing", "effjing", "maxjing", "jingli", "maxjingli"))
-        line1 = "【精神】 {0:<8} [{5:3.0f}%] / {1:<8} [{2:3.0f}%]  |【精力】 {3:<8} / {4:<8} [{6:3.0f}%]".format(var1[0], var1[1], 100 * float(var1[1]) / float(var1[2]), var1[3], var1[4], 100 * float(var1[0]) / float(var1[2]), 100 * float(var1[3]) / float(var1[4]))
-        var2 = self.session.getVariables(("qi", "effqi", "maxqi", "neili", "maxneili"))
-        line2 = "【气血】 {0:<8} [{5:3.0f}%] / {1:<8} [{2:3.0f}%]  |【内力】 {3:<8} / {4:<8} [{6:3.0f}%]".format(var2[0], var2[1], 100 * float(var2[1]) / float(var2[2]), var2[3], var2[4], 100 * float(var2[0]) / float(var2[2]), 100 * float(var2[3]) / float(var2[4]))
-        var3 = self.session.getVariables(("food", "water", "exp", "pot", "fighting", "busy"))
-        line3 = "【食物】 {0:<4} 【饮水】{1:<4} 【经验】{2:<9} 【潜能】{3:<10}【{4}】【{5}】".format(var3[0], var3[1], var3[2], var3[3],  "未战斗" if var3[4] == "0" else "战斗中", "不忙" if var3[5] == "0" else "忙")
-        self.session.info(line1, "状态")
-        self.session.info(line2, "状态")
-        self.session.info(line3, "状态")
+    # 定时器，每5秒打印一次信息
+    @timer(5)
+    def onTimer(self, id, *args, **kwargs):
+        self.session.info("每5秒都会打印本信息", "定时器测试")
+
+    # 导航触发器示例
+    @trigger('^http://fullme.pkuxkx.net/robot.php.+$', group = "sys")
+    def ontri_webpage(self, id, line, wildcards):
+        webbrowser.open(line)
+
+    # 若多个对象共用同一个处理函数，也可以同时使用多个装饰器实现
+    @trigger(r"^\s+你可以获取(.+)")
+    @trigger(r"^\s+这里位于(.+)和(.+)的.+")
+    def ontri_multideco(self, id, line, wildcards):
+        self.session.info("触发器触发，ID: {0}, 内容: {1}, 匹配项: {2}".format(id, line, wildcards), "测试")
+
+    # 多行触发器示例
+    @trigger([r'^[> ]*#(\d+.?\d*[KM]?),(\d+),(\d+),(\d+),(\d+),(\d+)$', r'^[> ]*#(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)$', r'^[> ]*#(\d+),(\d+),(-?\d+),(-?\d+),(\d+),(\d+)$'], group = "sys")
+    def ontri_hpbrief_3lines(self, id, line, wildcards):
+        # 注意注意，此处捕获的额内容在wildcards里都是str类型，直接用下面这种方式赋值的时候，保存的变量也是str类型，因此这种在status_window直接调用并用于计算时，需要另行处理
+        self.session.setVariables([
+        "combat_exp", "potential", "max_neili", "neili", "max_jingli", "jingli", 
+        "max_qi", "eff_qi", "qi", "max_jing", "eff_jing", "jing", 
+        "vigour/qi", "vigour/yuan", "food", "water", "fighting", "busy"
+        ]
+        , wildcards)
+        # 因为GMCP.Status传递来的是busy和fighting，与hpbrief逻辑相反，因此重新处理下，保证hpbrief和GMCP.Status一致
+        is_busy = not wildcards[-1]
+        is_fighting = not wildcards[-2]
+        self.session.setVariables(['is_busy', 'is_fighting'], [is_busy, is_fighting])
+
+    # gmcp定义式，name的大小写必须与GMCP的大小写一致，否则无法触发
+    @gmcp("GMCP.Status")
+    def ongmcp_status(self, id, line, wildcards):
+        # GMCP.Status in pkuxkx
+        # 自己的Status和敌人的Status均会使用GMCP.Status发送
+        # 区别在于，敌人的Status会带有id属性。但登录首次自己也会发送id属性，但同时有很多属性，因此增加一个实战经验属性判定
+        if isinstance(wildcards, dict):     # 正常情况下，GMCP.Status应该是一个dict
+            if ("id" in wildcards.keys()) and (not "combat_exp" in wildcards.keys()):
+                # 说明是敌人的，暂时忽略
+                #self.session.info(f"GMCP.Status 收到非自己信息： {wildcards}")
+                pass
+
+            else:
+                # GMCP.status收到的wildcards是一个json格式转换过来的字典信息，可以直接用于变量赋值
+                # 但json过来的true/false时全小写字符串，此处转换为bool类型使用
+                #self.session.info(f"GMCP.Status 收到个人信息： {wildcards}")
+                for key, value in wildcards.items():
+                    if value == "false": value = False
+                    elif value == "true": value = True
+                    self.session.setVariable(key, value)
+
+        # 如果这些变量显示在状态窗口中，可以调用下面代码强制刷新状态窗口
+        self.session.application.invalidate()
+
+    # 创建自定义的健康条用作分隔符
+    def create_status_bar(self, current, effective, maximum, barlength = 20, barstyle = "—"):
+        from wcwidth import wcswidth
+        barline = list()
+        stylewidth = wcswidth(barstyle)
+        filled_length = int(round(barlength * current / maximum / stylewidth))
+        # 计算有效健康值部分的长度
+        effective_length = int(round(barlength * effective / maximum / stylewidth))
+
+        # 计算剩余部分长度
+        remaining_length = barlength - effective_length
+
+        # 构造健康条
+        barline.append(("fg:lightcyan", barstyle * filled_length))
+        barline.append(("fg:yellow", barstyle * (effective_length - filled_length)))
+        barline.append(("fg:red", barstyle * remaining_length))
+
+        return barline
+
+    # 自定义状态栏窗口
+    def status_window(self):
+        from pymud.settings import Settings
+        try:
+            formatted_list = list()
+
+            # line 0. hp bar
+            jing = self.session.getVariable("jing", 0)
+            effjing = self.session.getVariable("eff_jing", 0)
+            maxjing = self.session.getVariable("max_jing", 0)
+            jingli = self.session.getVariable("jingli", 0)
+            maxjingli = self.session.getVariable("max_jingli", 0)
+            qi = self.session.getVariable("qi", 0)
+            effqi = self.session.getVariable("eff_qi", 0)
+            maxqi = self.session.getVariable("max_qi", 0)
+            neili = self.session.getVariable("neili", 0)
+            maxneili = self.session.getVariable("max_neili", 0)
+
+            barstyle = "━"
+            screenwidth = self.session.application.get_width()
+            barlength = screenwidth // 2 - 1
+            span = screenwidth - 2 * barlength
+            qi_bar = self.create_status_bar(qi, effqi, maxqi, barlength, barstyle)
+            jing_bar = self.create_status_bar(jing, effjing, maxjing, barlength, barstyle)
+
+            formatted_list.extend(qi_bar)
+            formatted_list.append(("", " " * span))
+            formatted_list.extend(jing_bar)
+            formatted_list.append(("", "\n"))
+
+            # line 1. char, menpai, deposit, food, water, exp, pot
+            formatted_list.append((Settings.styles["title"], "【角色】"))
+            formatted_list.append((Settings.styles["value"], "{0}({1})".format(self.session.getVariable('name'), self.session.getVariable('id'))))
+            formatted_list.append(("", " "))
+          
+            formatted_list.append((Settings.styles["title"], "【食物】"))
+            
+            food = int(self.session.getVariable('food', '0'))
+            max_food = self.session.getVariable('max_food', 350)
+            if food < 100:
+                style = Settings.styles["value.worst"]
+            elif food < 200:
+                style = Settings.styles["value.worse"]
+            elif food < max_food:
+                style = Settings.styles["value"]
+            else:
+                style = Settings.styles["value.better"]
+
+            formatted_list.append((style, "{}".format(food)))
+            formatted_list.append(("", " "))
+
+            formatted_list.append((Settings.styles["title"], "【饮水】"))
+            water = int(self.session.getVariable('water', '0'))
+            max_water = self.session.getVariable('max_water', 350)
+            if water < 100:
+                style = Settings.styles["value.worst"]
+            elif water < 200:
+                style = Settings.styles["value.worse"]
+            elif water < max_water:
+                style = Settings.styles["value"]
+            else:
+                style = Settings.styles["value.better"]
+            formatted_list.append((style, "{}".format(water)))
+            formatted_list.append(("", " "))
+            formatted_list.append((Settings.styles["title"], "【经验】"))
+            formatted_list.append((Settings.styles["value"], "{}".format(self.session.getVariable('combat_exp'))))
+            formatted_list.append(("", " "))
+            formatted_list.append((Settings.styles["title"], "【潜能】"))
+            formatted_list.append((Settings.styles["value"], "{}".format(self.session.getVariable('potential'))))
+            formatted_list.append(("", " "))
+
+            formatted_list.append((Settings.styles["title"], "【门派】"))
+            formatted_list.append((Settings.styles["value"], "{}".format(self.session.getVariable('family/family_name'))))
+            formatted_list.append(("", " "))
+            formatted_list.append((Settings.styles["title"], "【存款】"))
+            formatted_list.append((Settings.styles["value"], "{}".format(self.session.getVariable('deposit'))))
+            formatted_list.append(("", " "))
+            
+            # line 2. hp
+            # a new-line
+            formatted_list.append(("", "\n"))
+
+            formatted_list.append((Settings.styles["title"], "【精神】"))
+            if int(effjing) < int(maxjing):
+                style = Settings.styles["value.worst"]
+            elif int(jing) < 0.8 * int(effjing):
+                style = Settings.styles["value.worse"]
+            else:
+                style = Settings.styles["value"]
+            
+            if maxjing == 0: 
+                pct1 = pct2 = 0
+            else:
+                pct1 = 100.0*float(jing)/float(maxjing)
+                pct2 = 100.0*float(effjing)/float(maxjing)
+            formatted_list.append((style, "{0}[{1:3.0f}%] / {2}[{3:3.0f}%]".format(jing, pct1, effjing, pct2)))
+
+            formatted_list.append(("", " "))
+
+            formatted_list.append((Settings.styles["title"], "【气血】"))
+            if int(effqi) < int(maxqi):
+                style = Settings.styles["value.worst"]
+            elif int(qi) < 0.8 * int(effqi):
+                style = Settings.styles["value.worse"]
+            else:
+                style = Settings.styles["value"]
+
+            if maxqi == 0: 
+                pct1 = pct2 = 0
+            else:
+                pct1 = 100.0*float(qi)/float(maxqi)
+                pct2 = 100.0*float(effqi)/float(maxqi)
+            formatted_list.append((style, "{0}[{1:3.0f}%] / {2}[{3:3.0f}%]".format(qi, pct1, effqi, pct2)))
+            formatted_list.append(("", " "))
+
+            # 内力
+            formatted_list.append((Settings.styles["title"], "【内力】"))
+            if int(neili) < 0.6 * int(maxneili):
+                style = Settings.styles["value.worst"]
+            elif int(neili) < 0.8 * int(maxneili):
+                style = Settings.styles["value.worse"]
+            elif int(neili) < 1.2 * int(maxneili):
+                style = Settings.styles["value"]   
+            else:
+                style = Settings.styles["value.better"]
+
+            if maxneili == 0: 
+                pct = 0
+            else:
+                pct = 100.0*float(neili)/float(maxneili)
+            formatted_list.append((style, "{0} / {1}[{2:3.0f}%]".format(neili, maxneili, pct)))
+            formatted_list.append(("", " "))
+
+            # 精力
+            formatted_list.append((Settings.styles["title"], "【精力】"))
+            if int(jingli) < 0.6 * int(maxjingli):
+                style = Settings.styles["value.worst"]
+            elif int(jingli) < 0.8 * int(maxjingli):
+                style = Settings.styles["value.worse"]
+            elif int(jingli) < 1.2 * int(maxjingli):
+                style = Settings.styles["value"]   
+            else:
+                style = Settings.styles["value.better"]
+            
+            if maxjingli == 0: 
+                pct = 0
+            else:
+                pct = 100.0*float(jingli)/float(maxjingli)
+
+            formatted_list.append((style, "{0} / {1}[{2:3.0f}%]".format(jingli, maxjingli, pct)))
+            formatted_list.append(("", " "))
+            
+            return formatted_list
+    
+        except Exception as e:
+            return f"{e}"

pymud/protocol.py

@@ -146,7 +146,7 @@ class MudClientProtocol(Protocol):
             subfunc = getattr(self, f"handle_{v.lower()}_sb", None)         # 子协商处理函数
             self._iac_subneg_handlers[k] = subfunc
 
-        self.encoding = Settings.server["default_encoding"]                 # 字节串基本编码
+        self.encoding = kwargs.get("encoding", Settings.server["default_encoding"])                 # 字节串基本编码
         self.encoding_errors = Settings.server["encoding_errors"]           # 编码解码错误时的处理
         self.mnes = Settings.mnes
 
@@ -164,7 +164,7 @@ class MudClientProtocol(Protocol):
     def get_extra_info(self, name, default=None):
         """获取传输信息或者额外的协议信息."""
         if self._transport:
-            default = self._transport._extra.get(name, default)
+            default = self._transport.get_extra_info(name, default)
         return self._extra.get(name, default)
         
     def connection_made(self, transport: BaseTransport) -> None:
@@ -204,8 +204,9 @@ class MudClientProtocol(Protocol):
             self.log.warning(f'由于异常连接已经断开: {self}, {exc}.')
             self.session.set_exception(exc)
 
-        self._transport.close()
-        self._transport = None
+        if self._transport:
+            self._transport.close()
+            self._transport = None
         #self.session.set_transport(None)
 
         # 若设置了onConnected回调函数，则调用
@@ -324,7 +325,7 @@ class MudClientProtocol(Protocol):
     # public protocol methods
     def __repr__(self):
         "%r下的表述"
-        hostport = self.get_extra_info("peername", ["-", "closing"])[:2]
+        hostport = self.get_extra_info("peername", ["-", "closing"])[:2] # type: ignore
         return "<Peer {0} {1}>".format(*hostport)
     
     def _iac_default_handler(self, cmd, option):
@@ -766,9 +767,9 @@ class MudClientProtocol(Protocol):
                     state_machine = "wait_val_in_table"
                 elif byte in (IAC, MSDP_VAR, MSDP_VAL):     # 正常数据 value 结束
                     current_val = val_in_text.decode(self.encoding)
-                    msdp_data[current_var] = current_val
+                    msdp_data[current_var] = current_val # type: ignore
                     state_machine = "wait_end"
-                    self.log.debug(f"收到文本形式的MSDP子协商数据： {current_var} = '{current_val}'")
+                    self.log.debug(f"收到文本形式的MSDP子协商数据： {current_var} = '{current_val}'") # type: ignore
                 else:                           # value是正常数据
                     val_in_text.append(byte)
             elif state_machine == "wait_val_in_array":
@@ -776,9 +777,9 @@ class MudClientProtocol(Protocol):
                     # 最后一个val 已结束
                     val_in_array.append(val_in_text.decode(self.encoding))
                     val_in_text.clear()
-                    msdp_data[current_var] = val_in_array
+                    msdp_data[current_var] = val_in_array # type: ignore
                     state_machine = "wait_end"
-                    self.log.debug(f"收到数组形式的MSDP子协商数据： {current_var} = '{val_in_array}'")
+                    self.log.debug(f"收到数组形式的MSDP子协商数据： {current_var} = '{val_in_array}'") # type: ignore
                 elif byte == MSDP_VAL:
                     if len(val_in_text) > 0:                # 一个VAL已完成，保存到array，后面还有val
                         val_in_array.append(val_in_text.decode(self.encoding))
@@ -786,15 +787,16 @@ class MudClientProtocol(Protocol):
                 else:
                     val_in_text.append(byte)
             elif state_machine == "wait_val_in_table":
+                state_machine_table = "not_initialized"
                 if byte == MSDP_TABLE_CLOSE:
                     # 最后一组已结束
-                    val_in_table[table_var_name.decode[self.encoding]] = table_var_value.decode[self.encoding]
-                    msdp_data[current_var] = val_in_table
+                    val_in_table[table_var_name.decode(self.encoding)] = table_var_value.decode(self.encoding)
+                    msdp_data[current_var] = val_in_table # type: ignore
                     state_machine = "wait_end"
-                    self.log.debug(f"收到表格形式的MSDP子协商数据： {current_var} = '{val_in_table}'")
+                    self.log.debug(f"收到表格形式的MSDP子协商数据： {current_var} = '{val_in_table}'") # type: ignore
                 elif byte == MSDP_VAR:
                     if len(table_var_name) > 0:             # 上一个VAL已完成，保存到table，后面继续为VAR
-                        val_in_table[table_var_name.decode[self.encoding]] = table_var_value.decode[self.encoding]
+                        val_in_table[table_var_name.decode(self.encoding)] = table_var_value.decode(self.encoding)
                         table_var_name.clear()
                         table_var_value.clear()
                     state_machine_table = "wait_table_var"