paotin/mud/pkuxkx/plugins/basic/char/skills.tin

#nop vim: set filetype=tt:;

/*
本文件属于 PaoTin++ 的一部分
===========
PaoTin++ © 2020~2023 的所有版权均由担子炮(dzp <danzipao@gmail.com>) 享有并保留一切法律权利
你可以在遵照 GPLv3 协议的基础之上使用、修改及重新分发本程序。
===========
*/

#var basic_char_skills[META] {
    {NAME}      {技能列表}
    {DESC}      {解析 skills 命令的输出结果，并写入到 char[Skills]}
    {AUTHOR}    {担子炮}
    {NOTE}      {技能小点和激发关系分别由 skbrief 和 jifa 命令提供，都合并在一起}
    {CONFIG}    {
    }
};

/*
2024-12-02 09:37:00 INPUT: sk
╭───技能列表(共二十项)──────────┬──────┬───────╮
│技能                                          │描述        │级别/上限     │
├───二项职业技能──────────────┼──────┼───────┤
│  火眼金睛(anti-disguise)                     │不堪一击    │    1.00/346  │
│  占卜之术(divination)                        │不足挂齿    │   83.32/346  │
├───五项基本知识──────────────┼──────┼───────┤
│  鉴定之术(identification)                    │初窥门径    │   50.00/-    │
│  读书写字(literate)                          │已有小成    │  257.16/-    │
│＋音律(music)                                 │略知一二    │  102.00/-    │
│  奇门八卦(qimen-bagua)                       │已有小成    │  250.00/-    │
├───八项基本功夫──────────────┼──────┼───────┤
│  基本轻功(dodge)                             │平淡无奇    │  325.01/346  │
│  基本指法(finger)                            │粗通皮毛    │  346.00/346  │
│  基本内功(force)                             │平淡无奇    │  315.04/346  │
│  基本手法(hand)                              │粗通皮毛    │  346.00/346  │
│  基本招架(parry)                             │粗通皮毛    │  346.00/346  │
│  基本掌法(strike)                            │粗通皮毛    │  346.00/346  │
│  基本剑法(sword)                             │平淡无奇    │  327.00/346  │
├───十项特殊功夫──────────────┼──────┼───────┤
│□碧海神功(bihai-shengong)                    │平淡无奇    │  314.07/346  │
│□兰花拂穴手(fuxue-shou)                      │粗通皮毛    │  346.00/346  │
│□落英身法(luoying-shenfa)                    │平淡无奇    │  325.00/346  │
│□落英神剑掌(luoying-zhang)                   │粗通皮毛    │  346.00/346  │
│□弹指神通(tanzhi-shentong)                   │粗通皮毛    │  346.00/346  │
│□玉箫剑法(yuxiao-jian)                       │平淡无奇    │  327.00/346  │
├───────────────────────┴──────┴───────┤
│共使用了27.5个技能槽位，无技能槽位限制。级别上限：+1.67%。                  │
╰─────────────────────────────北大侠客行────╯
*/

load-lib event;

event.Define {char/skills}  {无参}  {$MODULE} {已经获取到 skills 命令输出结果，并更新 char[Skills]。};
event.Define {char/skbrief} {无参}  {$MODULE} {已经获取到 skbrief 命令输出结果，并更新 char[Skills]。};

#func {basic_char_skills.Init} {
    #class data/basic/char open;
    #var char[Skills] {};
    #var char-skill-limit {1};
    #class data/basic/char close;
    #delay char.skills.init {skills;jifa} 1;
    #return true;
};

#alias {skills}     {char.Skills};
#alias {sk}         {char.Skills};
#alias {cha}        {char.Skills};
#alias {skbrief}    {char.Skbrief {%1} nogag};

VAR {技能 ID 到技能名称的转换} char.skills.id2name {};

#alias {char.Skills} {
    #local args {%0};

    #if { "$args" == "" } {
        #line oneshot #action {^╭───技能列表(共%*项){(─|┬)*}──╮$} {
            #var char[Skills][count] {@math.ParseCN{%%1}};
            #local rawLine  {%%99};
            #replace rawLine {)%C─} {)&1────};
            #echo {%s} {@Beautify{{$rawLine}}};
            #line gag;
            char.skills.parse.output;
        };
    };

    xtt.Send {skills %0};
};

#alias {char.skills.parse.output} {
    #class {ParseSkills} open;

    #var char[Skills][currentType]  {};
    #var char[Skills][nameList]     {};

    #gag {^│技能 %s │描述 %s │级别/上限 %s │};

    #action {^├───%%1项%%2──} {
        #var char[Skills][currentType] {%%2};
        #local rawLine  {%%99};
        #replace rawLine {%C├───%C%*项%*%C──} {&1├───&2&3项&4&5─────};
        #echo {%s} {@Beautify{{$rawLine}}};
        #line gag;
    };

    #sub {~^%C│%*(%*)%*│%*│%*/%C-%*│} {%%1│%%2(%%3)%%4      │%%5│%%6/%%7-%%8│};

    #nop □已激发，△另一种激发，☆真传武功，＋有子技能。;
    #action {^│{□|△|☆|＋|  }%S(%S) {|(?:＋)+}%!s │%S {|↑}%!s │%!s %S/%S %!s│{|ID=char.skills}} {
        #local rawLine  {%%99};
        #local type     {$char[Skills][currentType]};
        #local enabled  {%%1};
        #local name     {%%2};
        #local code     {%%3};
        #local prof     {%%4};
        #local rank     {%%5};
        #local level    {%%7};
        #local limit    {%%8};

        #tab {$code};

        #if { "$limit" == "-" } {
            #local limit {0};
        };

        #replace name { } {};

        #if { "$enabled" == "{□|△}" } {
            #format enabled {true};
        };
        #else {
            #format enabled {false};
        };

        #if { "$prof" == "＋" } {
            #local prof {{color}{@str.WordColor{{$rawLine};{$prof}}}{mark}{$prof}};
        };

        #list char[Skills][nameList] add {$name};

        #var {char[Skills][$name]} {
            $char[Skills][$name]
            {name}      {$name}
            {type}      {$type}
            {enabled}   {$enabled}
            {code}      {$code}
            {prof}      {$prof}
            {rank}      {$rank}
            {level}     {$level}
            {limit}     {$limit}
        };

        #var char.skills.id2name[$code] {$name};

        #if { $char-skill-limit < $limit } {
            #var char-skill-limit $limit;
        };

        #if { $limit == 0 } {
            #return;
        };

        #nop 接下来给技能加上彩色进度条，用来表示当前级别距离上限的程度;
        #replace rawLine {^%*│%*(%S)%C{(?:＋)*}%C│%*│%+1c%c %*│%*$} {&1│&2@char.Skills.colorIt{{&3};{&4&5};{&6};{&9};$level;$limit;10}│&7│&8&9 &10│&11};
        #echo {%s} {@Beautify{{$rawLine}}};
        #line gag;
    };

    #sub {├─%*──┴─%*──┴──%*──┤} {├─%%1────────┴─%%2──┴──%%3──┤};

    #action {^│共使用了%*个技能槽位，空余槽位(%*)。级别上限：%*。%s│} {
        #local rawLine  {%%99};
        #replace rawLine { %C│} {       &1│};
        #echo {%s} {@Beautify{{$rawLine}}};
        #line gag;
    };

    #action {^│本日高级演练，使用点数：%*，潜能：%*。%s│} {
        #local rawLine  {%%99};
        #replace rawLine { %C│} {       &1│};
        #echo {%s} {@Beautify{{$rawLine}}};
        #line gag;
    };

    #action {^╰───{(┴|─)*}─%S────╯{|ID=char.skills}$} {
        #local rawLine  {%%99};
        #replace rawLine {╯} {───╯};
        #echo {%s} {@Beautify{{$rawLine}}};
        #line gag;
        char.skills.parse.done;
    };

    #action {^你不是查看过吗？{|ID=char/skills}$} {
        char.skills.parse.done;
    };

    #alias {char.skills.parse.done} {
        #local __unused {%%0};

        #local nameList {$char[Skills][nameList]};
        #local count    {$char[Skills][count]};

        #unvar char[Skills][currentType];
        #unvar char[Skills][nameList];
        #unvar char[Skills][count];

        #class {ParseSkills} kill;

        #if { &nameList[] != $count } {
            #line sub var #delay 0 {
                errLog skills 命令结果解析不完整，识别到了 &nameList[] 条记录。数据可能有误，请联系开发者。;
            };
            #return;
        };

        #list nameList collapse {|};
        #local skillName {};
        #foreach {*char[Skills][]} {skillName} {
            #if { "$skillName" != "{$nameList}" } {
                #unvar {char[Skills][$skillName]};
            };
        };

        event.Emit {char/skills};
    };

    event.ClassHandleOnce GA {char.skills} {char} {char.skills.parse.done};

    #class {ParseSkills} close;
};

#func {char.Skills.colorIt} {
    #local code     {%1};
    #local prof     {%2};
    #local space    {@str.Plain{%3}};
    #local pColor   {%4};
    #local level    {%5};
    #local limit    {%6};
    #local barLen   {%7};

    #local text     {($code)$prof $space     };
    #local textLen  {@str.Len{$text}};
    #local leftLen  {@math.Eval{$textLen - $barLen - 5}};
    #local left     {@str.Left{{$text}; $leftLen}};
    #local right    {@str.Right{{$text}; $barLen}};

    #local percent  {@math.Int{@math.Eval{$level * 100 / $limit}}};
    #local color    {@util.Grade{$percent;<271>;15;<171>;30;<203>;60;<274>;90;<134>;100;<132>;101;<506>}};
    #local rest     {@math.Eval{100 - $percent}};
    #local pStr     {@str.Format{%%3d%;$percent}};

    #return {$left$pColor$pStr<299> @util.ColorBar{{$right};$color;$percent;<g08>;$rest}};
};

#alias {char.Skbrief} {
    #local skillID {%1};

    #if { "$skillID" == "" } {
        errLog 用法: skbrief <技能ID>;
        #return;
    };

    #alias {char.Skbrief.update} {
        #local lvl      {%%1};
        #local point    {%%2};

        #local skillID  {%1};

        #local skillName {$char.skills.id2name[$skillID]};
        #if { "$skillName" == "" } {
            errLog skills 相关触发出现 BUG，请联系开发者。;
            #return;
        };

        #local delta {@math.Eval{$point - $char[Skills][$skillName][point]}};
        #if { $char[Skills][$skillName][lvl] != $lvl } {
            #local delta 0;
        };

        #var char[Skills][$skillName][lvl]      {$lvl};
        #var char[Skills][$skillName][point]    {$point};

        #local level {};

        #nop 领悟有时候会领悟过头，小点偶尔会超过等级的平方。;
        #nop XXX: 这个时候就强制限制到 xxx.99，以免引起重大误解。;
        #if { $point >= $lvl ** 2 } {
            #local level {@math.Eval{$lvl + 0.99}};
        };
        #else {
            #math level {$lvl*1.0000000000000000 + $point*1.00 / ($lvl ** 2)};
            #replace level {^%*.%.%.%*$} {&1.&2&3};
        };

        #var char[Skills][$skillName][level]    {$level};

        #local limit    {@char.SkillLimit{$skillName}};
        #local jifa     {@char.GetJifaSkill{$skillName}};
        #local jifaLvl  {@char.SkillLevel{$jifa}};
        #local delta    {@str.FormatIfElse{$delta > 0; {(<129>+<299>%s)}; {}; $delta}};
        #local desc     {<== <039>$level<299> / <069>$limit<299> <== <Ffc0>$skillName<299>};

        #if { "$jifa" != "" } {
            #cat desc { 当前激发至 <059>$jifa<299>($jifaLvl)};
        };
        #else {
            #cat desc { <019>该技能尚未激发<299>};
        };

        #line sub var #line oneshot #sub {^#{$lvl}/{$point}$} {#<129>$lvl<299>/<029>$point<299>$delta $desc};

        event.Emit {char/skbrief};
    };

    #line oneshot #alias {char.Skbrief.parse} {
        #line oneshot #action {^系统回馈：R:skbrief-begin-%%1$} {
            #class char-skbrief-parse-output-%%1 open;
            #line oneshot #action {^#%d/%d{|ID=char/skbrief-%%1}$} {
                #local lvl      {%%%%1};
                #local point    {%%%%2};

                char.Skbrief.update {$lvl} {$point};

                #local gag {@default{%2;gag}};
                #if { "$gag" == "gag" } {
                    #line gag;
                };
            };
            #line oneshot #action {^系统回馈：R:skbrief-end-%%1$} {
                #line gag;
                #class char-skbrief-parse-output-%%1 kill;
            };
            #class char-skbrief-parse-output-%%1 close;
            #line gag;
        };
    };

    #local uuid {@uuid{}};
    char.Skbrief.parse $uuid $skillID;
    xtt.Send {#response R:skbrief-begin-$uuid;skbrief $skillID;response R:skbrief-end-$uuid#};
};

///=== {
// #@ char.SkillID <技能中文名称>
//    返回技能的 ID。支持且仅支持所有玩家 skills 命令中可以看到的技能。
// };
#func {char.SkillID} {
    #local skill {%1};
    #return {$char[Skills][$skill][code]};
};

///=== {
// #@ char.SkillLimit [<技能中文名称>]
//    如果指定了技能名称，则返回该技能所能达到的技能上限。
//    如果没有指定或者技能不存在，则返回本人的武功技能上限。
//    如果技能上限获取失败，默认值为基本内功的上限，如果基本内功上限也没有获取到，则默认为 1。
// };
#func {char.SkillLimit} {
    #local skill {%1};
    #local limit {@defaultNum{$char-skill-limit;@defaultNum{$char[Skills][基本内功][limit];1}}};
    #local limit {@defaultNum{$char[Skills][$skill][limit];$limit}};
    #return $limit;
};

///=== {
// #@ char.SkillType <技能中文名称>
//    返回该技能的技能类别。
//    常见的技能类别有：
//        - 基本功夫
//        - 特殊功夫
//        - 基本知识
//        - 职业技能
// };
#func {char.SkillType} {
    #local skill {%1};
    #return {$char[Skills][$skill][type]};
};

///=== {
// #@ char.SkillLevel <技能中文名称>
//    返回该技能的当前等级。没学会的技能等级为 0。
// };
#func {char.SkillLevel} {
    #local skill {%1};

    #if { "$char[Skills][$skill]" == "" } {
        #return 0;
    };

    #return $char[Skills][$skill][level];
};

///=== {
// #@ char.IsSkillEnabled <技能中文名称>
//    判断该技能是否被激发。这里的技能名称既可以是基本功夫，也可以是特殊功夫。
// };
#func {char.IsSkillEnabled} {
    #local skill {%1};

    #if { "$char[Skills][$skill]" == "" } {
        #return 0;
    };

    #if { "$char[Skills][$skill][jifa-to]" == "" } {
        #return 0;
    };

    #return 1;
};

///=== {
// #@ char.GetJifaSkill <混合参数>
//    提供技能激发情况查询。
//    共分为三种情况：
//    1，输入参数为基本技能，输出对应的特殊技能名称。如果未激发则为空
//    2，输入参数为特殊技能，输出对应的基本技能名称。结果可能为多个。如果未激发则为空
//    3，输入参数为激发类型，则输出对应的基本技能名称。又分为以下两种情形：
//      (1)，输入参数为常用拳脚或者常用兵器，则输出相应的基本技能名称。
//           由于存在互备的情形，因此结果是一个字符串列表，可能包含多个技能名称
//      (2)，其它内功、躲闪、招架及武功种类，则输出对应的特殊技能名称
// };
#func {char.GetJifaSkill} {
    #local arg {%1};

    #local skills {};
    #if { "$arg" == "常用{拳脚|兵器}" } {
        #local skill {};
        #foreach {*char[Skills][]} {skill} {
            #local elem {$char[Skills][$skill]};
            #if { "$elem[type]" != "基本功夫" } {
                #continue;
            };
            #if { "$elem[jifa-type]" == "$arg" } {
                #list skills add {$skill};
            };
        };
        #return {@slist.FromList{$skills}};
    };

    #if { "$arg" == "躲闪" } {
        #local arg {基本轻功};
    };

    #if { "$char[Skills][$arg][jifa-to]" != "" } {
        #return {$char[Skills][$arg][jifa-to]};
    };

    #local arg {基本$arg};
    #if {"$char[Skills][$arg][jifa-to]" != "" } {
        #return {$char[Skills][$arg][jifa-to]};
    };
    #else {
        #return {};
    };
};

///=== {
// #@ char.SkillJifaLevel <技能中文名称>
//    返回技能激发等级，数据来自 jifa/enable 命令。
//    如果技能未被激发，那么分两种情况：
//       1. 如果输入的技能名称为基本功夫，则取 jifa 数据。
            如果 jifa 数据取不到，则取技能当前等级的一半。
//       2. 如果输入的技能名称为特殊功夫，则取技能的当前等级。
// };
#func {char.SkillJifaLevel} {
    #local skill {%1};

    #if { "$char[Skills][$skill]" == "" } {
        #return 0;
    };

    #local level {$char[Skills][$skill][level]};
    #if { "$skill" == "基本%*" } {
        #math level {$char[Skills][$skill][level] / 2};
    };

    #return {@defaultNum{$char[Skills][$skill][jifa-level];$level}};
};

///=== {
// #@ char.CanLianxi [<基本武功>]
//    如果某项武功可以练习，则返回真，否则返回假。
//    如果省略参数，则默认为基本招架。
//    注意: 这里不考虑游戏特定的限制，只做简单的等级比较。
// };
#func {char.CanLianxi} {
    #local skill {@default{%1;基本招架}};

    #if { "$skill" != "基本%*" || "$skill" == "基本内功" } {
        #return 0;
    };

    #local baseLvl  {@math.Floor{@char.SkillLevel{$skill}}};
    #local skill    {@char.GetJifaSkill{$skill}};
    #local level    {@math.Floor{@char.SkillLevel{$skill}}};

    #if { "$skill" == "" || $baseLvl == 0 || $level == 0 } {
        #return 0;
    };

    #if { $baseLvl <= $level } {
        #return 0;
    };

    #return 0;
};

///=== {
// #@ char.CanLingwu [<基本武功>]
//    如果某项武功可以领悟，则返回真，否则返回假。
//    如果省略参数，则默认为基本内功。
// };
#func {char.CanLingwu} {
    #local skill {@default{%1;基本内功}};

    #if { "$skill" != "基本%*" } {
        #return 0;
    };

    #local baseLvl  {@math.Floor{@char.SkillLevel{$skill}}};
    #local skill    {@char.GetJifaSkill{$skill}};
    #local level    {@math.Floor{@char.SkillLevel{$skill}}};
    #local limit    {@math.Floor{@char.SkillLimit{$skill}}};

    #if { "$skill" == "" || $baseLvl == 0 || $level == 0 } {
        #return 0;
    };

    #if { $baseLvl > $level || $baseLvl >= $limit } {
        #return 0;
    };

    #return 1;
};

///=== {
// #@ char.CanXiulian [<内功中文名称>]
//    如果角色拥有足够的潜能（暂定为 10w），并且内功等级尚未达到上限，则返回真，否则返回假。
//    可选的内功名称参数用来指定具体的内功，如果省略则取当前激发的内功。
// };
#func {char.CanXiulian} {
    #local force    {%1};

    #if { "$force" == "" } {
        #local force {@char.GetJifaSkill{基本内功}};
    };

    #if { "$force" == "" } {
        #return 0;
    };

    #local level    {@math.Floor{@char.SkillLevel{$force}}};
    #local limit    {@math.Floor{@char.SkillLimit{$force}}};

    #if { @defaultNum{$char[HP][潜能];0} < 100000 } {
        #return 0
    };

    #if { $level < 100 || $level >= $limit } {
        #return 0;
    };

    #return 1;
};

#action {^你的「%*」进步了！$E} {
    #local name {%1};

    #if { "$char[Skills][$name]" == "" } {
        #return;
    };

    #local level {@math.Floor{@char.SkillLevel{$name}}};
    #local level {@math.Eval{$level + 1}};
    #local limit {@char.SkillLimit{$name}};

    fullskLog @buffer.RawLine{} 当前进度: $level / $limit;

    #line sub var #delay char.skills.update.level {skbrief $char[Skills][$name][code]} 0.1;

    #if { "$name" == "基本内功" || "@char.GetJifaSkill{$name}" == "基本内功" } {
        #delay char.skills.update.neili {hp -neili} 0.1;
    };
} {9.1};