tintin++ 慢走function

wolfwar 发表于 2022-12-26 06:59:29

本帖最后由 wolfwar 于 2022-12-26 05:02 PM 编辑

为了这个慢走又头疼了一通，不过现在总算写了个能用的功能，请大家看看怎么样。
自己测试觉得还满足要求，主要是以后触发里用。

#function {f_run_delay} {
#list l1 create $p_action;
#var v_teller 1;
#list l1 size v_max;
#ticker {run_delay} {

$l1[$v_teller];
#if { $v_teller<$v_max }
{
#math {v_teller} {$v_teller+1};
};
#else
{
#untick run_delay;
#unvar v_max;
#unvar v_teller;
}

} {1};
#return "慢走";
}

用法；
定义路径
#VARIABLE {p_daoguo_to_gang} {n;n;w;n;n;w}
#VARIABLE {p_gang_to_daoguo} {e;s;s;e;s;s}

要走路时
#var p_action $p_daoguo_to_gang
#show @f_run_delay{}

回来
#var p_action $p_gang_to_daoguo
#show @f_run_delay{}

xgg 发表于 2022-12-26 20:31:49

可以看看我写的命令解析执行器，目前还没实现回调，凑活用。
#nop 命令解析器;

/*
Author:xgg

功能：解析执行使用分号分隔的命令列表。

例如：
cmd_set {1;2;3;busy1;wait 5;waitfor 666;waitline 888;stop}

列表中特定参数有：

1）wait <n> 等待给定秒数，省略参数则等待 2s。
2）waitfor 等待给定文本出现。
3）waitline 等待给定行出现。
4）busy1 等待 2s。
5）stop 停止执行。

run 恢复执行。

*/

#nop ====根据服务器指令数限制修改====;

#nop 每秒最大命令数;
#var step_accu_max {5};
#nop 命令间隔时间;
#var step_short {0.2};
#nop 指令数超限间隔时间;
#var step_long {1};

#nop ====以下为代码实现部分，勿随意修改====;

#nop 等待指定时间;
#ali {wait}{
#switch {"%1"}{
   #case {""}{
         #var cmd {wait 2};
   };
   #default {
         #var cmd {wait %1};
   };
};
};

#nop 等待指定事件;
#alias {waitfor}{
#var cmd {waitfor %1};
};

#nop 等待指定内容;
#alias {waitline}{
#var cmd {waitline %1};
};

#nop 停止解析执行;
#alias stop {
#echo {<103>停止解析执行..};
#var cmd stop;
};

#nop 继续解析执行;
#alias run {
#echo {@bc1{继续解析执行..}};
cmd_do;
};

#nop ====自定义函数====
#function {numitems} {#list {%1} size result};
#function {ismember} {#list {%2} find {%1} result};
#function {item} {#list {%1} get {%2} result};
#nop ==================

#nop 解析队列;
#alias {cmd_set} {
#var cmds {};
#list cmds create %0;
#math stepmax &{cmds[]};
#echo {@bc1{当前待执行命令共计 $stepmax 个。}};
#line ignore #show {@bc1{队列：{${cmds[]}}}};
#math step_accu 1;
#math step 1;
cmd_do;
};

#nop 执行队列;
#alias cmd_do {
#if {$step<=$stepmax} {
#switch {"$cmd"} {
   #case {"stop"} {
   #echo {<171>STOPPING...};
   #var cmd {};
   };
   #case {"wait%s%d"} {
   #local time {$cmd};
   #replace time {wait} {};
   #replace time { } {};
   #echo {@bc1{等待「$time\s」后行动。}};
   #delay {$time} cmd_do;
   #var cmd {};
   };
   #case {"wait{for|line} %*"} {
   #local waitfor {$cmd};
   #var matchline {false};
   #if { "$cmd" == "waitline %*" } {
      #format matchline {true};
   };
   #replace waitfor {waitfor}{};
   #replace waitfor {waitline} {};
   #replace waitfor { } {};
   #if { "$matchline" == "true" } {
      #format waitfor {^%p$} {$waitfor};
   };
   #else {
      #format waitfor {%p} {$waitfor};
   };
   #var cmd {
      #class cmd_do_tmp kill;
      #class cmd_do_tmp open;
      #echo {@bc1{等待「$waitfor」出现。}};
      #action {$waitfor} {
         #class cmd_do_tmp kill;
         #delay 1 cmd_do;
      };
      #class cmd_do_tmp close;
   };
   $cmd;
   };
   #default {
   #var cmd @item{cmds;$step};
   #nop #echo {
      @bc1{当前执行第 $step 个命令：「${cmds[+$step]}」}
   };
   #if {"$cmd"=="busy1"} {
      #echo {<103>BUSYING...};
      #math step_accu {$step_accu+1};
      #math step {$step+1};
      #delay 2 cmd_do;
   };
   #else {
      $cmd;
      #math step_accu {$step_accu+1};
      #math step {$step+1};
      #if {$step_accu >= $step_accu_max} {
         #delay $step_long cmd_do;
         #math step_accu 1;
      };
      #else {
         #delay $step_short cmd_do;
      };
   };
   };
};
};
#else {
#show {@bc1{命令解析执行完毕}};
};
};

#nop 测试;
#alias cmd_test {
cmd_set {
#echo 1;
wait;
#echo 2;
waitfor 666;
#echo 3;
busy1;
#echo 4;
stop;
waitline 999;
#echo 5;
#echo 6;
#echo 7;
#echo 8;
#echo 9;
busy1;
};
};

xgg 发表于 2022-12-26 20:34:10

单纯的慢走则可以使用#path run delay
#nop 慢速执行，必须带括号;
#nop 示例：slowdo {w;w;s};
#alias slowdo {
#path load %0;
#path run 1;
};

wolfwar 发表于 2022-12-26 23:51:25

本帖最后由 wolfwar 于 2022-12-27 01:08 AM 编辑

xgg 发表于 2022-12-26 08:34 PM
单纯的慢走则可以使用#path run delay
测试了一下，原来path 可以执行任何命令，只是在录制的时候不能接受除n,s,e,w,之外的命令，你这个功能和我的一样，只不过简洁多了{:7_277:}

wolfwar 发表于 2022-12-26 23:57:11

xgg 发表于 2022-12-26 08:31 PM
可以看看我写的命令解析执行器，目前还没实现回调，凑活用。

谢谢！等我慢慢研究学习{:7_280:}

xgg 发表于 2022-12-27 09:15:46

wolfwar 发表于 2022-12-26 11:51 PM
测试了一下，原来path 可以执行任何命令，只是在录制的时候不能接受除n,s,e,w,之外的命令，你这个功能和 ...

并不是不支持，请查看#pathdir条目，要录制自定义指令则必须预先指定路径方向。
自定义命令只能是 1-63 之间的值。
比如：enter，out。

#PATHDIR       {n}{s}{1}
#PATHDIR       {e}{w}{2}
#PATHDIR       {s}{n}{4}
#PATHDIR       {w}{e}{8}
#PATHDIR       {u}{d}{16}
#PATHDIR       {d}{u}{32}
#PATHDIR       {ne} {sw} {3}
#PATHDIR       {se} {nw} {6}
#PATHDIR       {nw} {se} {9}
#PATHDIR       {sw} {ne} {12}
#PATHDIR       {nu} {sd} {17}
#PATHDIR       {eu} {wd} {18}
#PATHDIR       {su} {nd} {20}
#PATHDIR       {wu} {ed} {24}
#PATHDIR       {nd} {su} {33}
#PATHDIR       {ed} {wu} {34}
#PATHDIR       {sd} {nu} {36}
#PATHDIR       {wd} {eu} {40}
#nop 自定义命令范围 1-63;
#PATHDIR       {out} {enter} {61}
#PATHDIR       {enter} {out} {62}

wolfwar 发表于 2022-12-27 17:04:52

xgg 发表于 2022-12-27 09:15 AM
并不是不支持，请查看#pathdir条目，要录制自定义指令则必须预先指定路径方向。
...

原来这样啊，信息太多一时弄不过来了，谢谢{:7_276:}

oakbai 发表于 2023-1-21 12:18:29

xgg 发表于 2022-12-26 08:34 PM
单纯的慢走则可以使用#path run delay

请问怎么判断慢走是否结束？

dtp 发表于 2023-1-21 12:26:46

oakbai 发表于 2023-1-21 12:18 PM
请问怎么判断慢走是否结束？

自己判断。tintin++ 不管这个。你做好房间触发，或者 response 触发，然后自己调用命令就行了。

页: [1]

北大侠客行MUD论坛's Archiver

tintin++ 慢走function