在hellmapmanager.ts(hmmts)中提供的类的参考文档。

本文档仅介绍适合在脚本中公共使用的部分。

文档中未提到的代码不保证长期兼容性。

hmmts需要把库本身和实际使用的数据库放在合适的全局变量中。本文档中，hmmts会放在全局变量hmm中，数据库会放在全局变量Database中。

Javascript:

//hmmts库
var hmm=require("hmm.js")
//hmmts的当前数据库
var database=hmm.MapDatabase.New()

Lua:

--hmmts库
hmm=require(hmm)
--hmmts的当前数据库
database=hmm.MapDatabase:New()

MapDatabase是整个 hmmts的功能的合计。所有的功能都是通过MapDatabase类来使用的

Javascript:

var database=hmm.MapDatabase.New()

Lua:

local database=hmm.MapDatabase:New()

Current 是MapDatabase最重要的属性。当前打开的地图文件，如果为空，说明没有打开任何地图文件

NewMap方法会在当前的MapDatabase中创建一个新MapFile,相当于一般应用的新建功能。

使用NewMap后，MapDatabase的Current属性将设置为空的MapFile。

新建MapFile后，建议设置正确的MapFile编码

代码范例

Javascript:

database.NewMap()
//database.Current.Map.Encoding=hmm.MapEncoding.GB18030

Lua:

database:NewMap()
--database.Current.Map.Encoding=hmm.MapEncoding.GB18030

将给到的hmm文件正文字符串导入到当前的MapDatabase中。

会创建新的MapFile。

注意，导入时不会根据hmm文件进行转码，需要在保存hmm文件时就设置正确的编码。

参数

• body hmm文件正文
• path 设置MapFile的文件位置属性，无实际用途

代码范例

Javascript:

database.Import(hmmbody,"map.hmm")

Lua:

database:Import(hmmbody,"map.hmm")

将当前的MapFile到处为hmm文件正文以便保存。

注意，到处时不会自动设置编码，需要在创建MapFile或者导出前手动指定。

参数

• path 文件保存位置，无实际意义

返回值

HMM文件正文。如果没有打开或新建MapFile,则返回空字符串

代码范例

Javascript:

var hmmToSave=database.Export("map.hmm")

Lua:

local hmmToSave=database:Export("map.hmm")

关闭当前MapFile。将Current属性设置为空。

代码范例

Javascript:

database.CloseCurrent()

Lua:

database:CloseCurrent()

地图数据封装类 MapFile是对整体数据的一个封装，API接口的实际实现都在MapFile类上，起到隔离数据和操作的作用。

一般不应该直接使用或操作MapFile类

Map属性中包含的是实际的地图信息，会在 MapDatabase的NewMap和Import方法调用时，随着MapFile自动创建

使用MapDatabse的Import和Export时自动设置。为了保持代码与HMM完全一致而保留，没有实际用途

Map是地图本身信息的对象。

地图的编码，一个MapEncoding对象，可以设置为 MapEncoding.Default (utf8) 或 MapEncoding.GB18030

地图基本信息

地图的基本信息，名字和描述

值标签代表环境中的一个标签值，与值条件(ValueCondition)成对使用。

依次将主键(Key)和值(Value)传入创建函数创建。

Javascript:

var tag=hmm.ValueTag.New("tagkey",1)

Lua:

local tag=hmm.ValueTag:New("tagkey",1)

主键值，不可为空

标签值。

如果标签代表真，则标签值为1。如果标签代表假，则标签值为0。

与值标签匹配时，会判断同键值的值条件的值。如果条件值大于等于标签值，则匹配，否则不匹配。

判断ValueTag是否有效。ValueTag的Key不可为空。

Javascript:

var validated=tag.Validated()

Lua:

local validated=tag:Validated()

复制一个独立的ValueTag

Javascript:

var newtag=tag.Clone()

Lua:

local newtag=tag:Clone()

判断是否和另一个ValueTag相等

Javascript:

var same=tag.Equal(hmm.ValueTag.New("key",1))

Lua:

local same=tag:Equal(hmm.ValueTag:New("key",1))

静态方法

批量匹配传入的值标签列表和值条件列表。

如果有任何一个不匹配，返回false,否则返回true

Javascript:

var matched=ValueTag.ValidateConditions(
    [hmm.ValueTag.New("Key1",1),hmm.ValueTag.New("Key2",2)],
    [hmm.ValueCondition.New("Key1",1,false),hmm.ValueCondition.New("Key2",1,true)]
)

Lua:

local matched=ValueTag:ValidateConditions(
    {hmm.ValueTag:New("Key1",1),hmm.ValueTag:New("Key2",2)},
    {hmm.ValueCondition.New("Key1",1,false),hmm.ValueCondition.New("Key2",1,true)}
)

条件值，与值标签(ValueTag)成对使用

依次将主键(Key)，值(Value)，取否(Not)传入创建函数创建。

Javascript:

var vc=hmm.ValueCondition.New("tagkey",1,false)

Lua:

local vc=hmm.ValueCondition:New("tagkey",1,false)

匹配的主键，与ValueTag的Key对应

需要满足的Tag值，ValueTag的值在没有取否时必须大于等于这个值才能匹配

取否，对匹配的结果做逻辑否操作

判断ValueCondition是否有效。ValueCondition的Key不可为空。

Javascript:

var validated=vc.Validated()

Lua:

local validated=vc:Validated()

复制一个独立的ValueCondition

Javascript:

var newvc=vc.Clone()

Lua:

local newvc=vc:Clone()

判断是否和另一个ValueCondition相等

Javascript:

var same=vc.Equal(hmm.ValueCondition.New("key",1,false))

Lua:

local same=vc:Equal(hmm.ValueCondition:New("key",1,false))

Data对象是房间附属的房间数据的结构

将数据的键和值一次传入New函数

Javascript:

var data=hmm.Data.New("datakey","datavalue")

Lua:

local data=hmm.Data:New("datakey","datavalue")

判断Data是否有效。Data的Key和Value不可为空。

Javascript:

var validated=data.Validated()

Lua:

local validated=data:Validated()

复制一个独立的Data

Javascript:

var newdata=data.Clone()

Lua:

local newdata=data:Clone()

判断是否和另一个Data相等

Javascript:

var same=data.Equal(hmm.Data.New("key","value"))

Lua:

local same=data:Equal(hmm.Data:New("key","value"))

Exit代表通向一个房间的出口信息。

Exit作为HMM最重要的基础结构，会被很多类继承。

Javascript:

var exit=hmm.Exit.New()
exit.Command="north"
exit.To="0"
exit.Conditions=[hmm.ValueCondition.New("gb",1,false)]
exit.Cost=1

Lua:

local exit=hmm.Exit:New()
exit.Command="north"
exit.To="0"
exit.Conditions={hmm.ValueCondition:New("gb",1,false)}
exit.Cost=1

出口的实际指令，不可为空

出口对应的房间。建议待处理的可以用 * 或 ？占位

值条件列表

必须在Context里满足所有Condition,才能使用出口

出口的消耗，默认1.

计算路径时的出口消耗。小于1的值属于Undefined Behave

判断Exit是否有效。Exit的Command不可为空。

Javascript:

var validated=exit.Validated()

Lua:

local validated=exit:Validated()

复制一个独立的Exit

Javascript:

var newexit=exit.Clone()

Lua:

local newexit=exit:Clone()

判断是否和另一个Exit相等

Javascript:

var same=exit.Equal(hmm.Exit.New("key",1,false))

Lua:

local same=exit:Equal(hmm.Exit:New("key",1,false))

用于验证地图主键的类

验证传入的字符串是否是有效的地图元素主键。

主键需要符合以下条件

• 不为空字符串
• 不含空格

参数

• string 待验证的主键

返回值

是否有效

代码范例

Javascript:

var validated=hmm.ItemKey.Validate("key")

Lua:

local validated=hmm.ItemKey:Validate("key")

标准维护接口的列出过滤选项

Javascript:

var lo=hmm.APIListOption.New()
lo.WithKeys(["gc","gd"]).WithGroups(["扬州","北京"])

Lua:

local lo=hmm.APIListOption:New()
lo:WithKeys({"gc","gd"}):WithGroups({"扬州","北京"})

Clear,WithKeys,WithGroups会返回APIListOption本身方便调用。

当Keys或者Groups任何一个为空时，调用接口时不限制对应的属性

Room是hmmts里最基础的地图对象，代表了Mud里的一个一个抽象的位置以及对应的出口关系。

Javascript:

var room=hmm.Room.New()
room.Key="myroom"
room.Name="我的房间"
room.Desc="abcdefg"
room.Tags=[hmm.Tag.New("indoor",1)]
var exit=hmm.Exit.New()
exit.Command="out"
exit.To="chatroom"
exit.Conditions=[hmm.ValueCondition.New("isWiz",1,false)]
exit.Cost=1
room.Exits=[exit]
room.Data=[hmm.Data.New("datakey","datavalue")]

Lua:

local room=hmm.Room:New()
room.Key="myroom"
room.Name="我的房间"
room.Desc="abcdefg"
room.Tags={hmm.Tag:New("indoor",1)}
local exit=hmm.Exit:New()
exit.Command="out"
exit.To="chatroom"
exit.Conditions={hmm.ValueCondition:New("isWiz",1,false)}
exit.Cost=1
room.Exits={exit}
room.Data={hmm.Data:New("datakey","datavalue")}

房间的主键，hmm中最核心的概念。

房间名，人类可阅读的房间名称。

除了阅读作用外，还会用于搜索/过滤房间，以及在hmm的关系地图中显示

描述属性，备注用，无实际用途。

分组属性。在Room中一般可以记录城市所属的城市。

可以在List接口中使用

房间本身的标签，一般用于匹配Context中的RoomConditions。

常见的可以用来设置是否为室外，是否为安全区等

房间的出口列表，描述房间与房间之间的关联。

房间数据属性。可以用来存放需要的房间数据。比如特殊的NPC/任务道具等。

可以在搜索/过滤房间中使用

判断Room是否有效。

主键不可为空，需要符合ItemKey验证

Javascript:

var validated=room.Validated()

Lua:

local validated=room:Validated()

复制一个独立的Room

Javascript:

var newroom=room.Clone()

Lua:

local newroom=room:Clone()

判断是否和另一个Room相等

Javascript:

var same=room.Equal(hmm.Room.New())

Lua:

local same=room:Equal(hmm.Room:New())

判断 是否给到的Tag主键是否符合具体的Value值

参数

• key 标签主键
• value 标签值

返回值

是否符合

代码范例

Javascript:

var match=room.HasTag("outdoor",1)

Lua:

local match=room:Hastag("outdoor",1)

返回房间给定数据主键的数据值。

参数

• key 数据主键

返回值

房间对应数据主键的数据值。如果无对应值，返回空字符串

代码范例

Javascript:

var datavalue=room.GetData("datakey")

Lua:

local datavalue=room:GetData("datakey")

为房间设置具体的数据值,设置结束后房间数据会按照主键排序。

参数

• rd 房间数据，如果有同名会进行更新，如果Value为''则删除该Key对应数据

返回值

无

代码范例

Javascript:

room.SetData(hmm.Data.New("datakey","datavalue"))

Lua:

room:SetData(hmm.Data:New("datakey","datavalue"))

批量为房间设置具体的数据值,设置结束后房间数据会按照主键排序。

参数

• list 房间数据列表，会依次设置。如果有同名会进行更新，如果Value为空字符串则会只删除

返回值

无

代码范例

Javascript:

room.SetDatas([hmm.Data.New("datakey","datavalue"),hmm.Data.New("datakey2","datavalue2")])

Lua:

room:SetDatas({hmm.Data:New("datakey","datavalue"),hmm.Data:New("datakey2","datavalue2")})

由于搜索和过滤房间的个过滤器

Javascript:

var rf=hmm.RoomFilter.New()
rf.RoomConditions=[hmm.ValueCondition.New("outdoor",1,false)]
rf.HasAnyExitTo=["gc"]
rf.HasAnyData=[hmm.Data.New("datakey","datavalue")]
rf.HasAnyName=["中心广场"]
rf.HasAnyGroup=["扬州"]
rf.ContainsAnyData=[hmm.Data.New("datakey2","value2")]
rf.ContainsAnyName=["广场"]
rf.ContainsAnyKey=["yz"]

Lua:

local rf=hmm.RoomFilter:New()
rf.RoomConditions={hmm.ValueCondition:New("outdoor",1,false)}
rf.HasAnyExitTo={"gc"}
rf.HasAnyData={hmm.Data:New("datakey","datavalue")}
rf.HasAnyName={"中心广场"}
rf.HasAnyGroup={"扬州"}
rf.ContainsAnyData={hmm.Data.New("datakey2","value2")}
rf.ContainsAnyName={"广场"}
rf.ContainsAnyKey={"yz"}

不同的属性都是列表，代表不同的筛选条件。

空列表代表不做限制。

同一组的筛选条件，互相之间是 or 判定，任何一个符合既符合。

不同组的筛选条件，互相之间是 and 判定，必须全部符合才能符合。

不为空时，Room必须有和 RoomCondition 对应的Tag才能匹配

不为空时，Room必须要有出口到给定的目标房间才能匹配。只判断原始房间信息，不包含Context。

不为空时，Room必须有给定的房间数据才能匹配，判断时对Data.Value进行完整匹配判断。

不为空时，Room只有有给定的房间名才能匹配，匹配时对Name属性进行完整匹配。

不为空时，Room只有有给定的分组才能匹配，匹配时对Group属性进行完整匹配。

不为空时，Room必须包含给定的房间数据才能匹配，判断时对Data.Value进行部分整匹配判断，只要包含条件即可。

不为空时，Room必须包含定的房间名据才能匹配，判断时对Name属性进行部分整匹配判断，只要包含条件即可。

标记是hmm中的一种重要属性，是处于业务对房间Key的一种别名或者映射。

Javascript:

var marker=hmm.Marker.New()
marker.Key="mykey"
marker.Value="gc"
marker.Desc="描述"
marker.Group="npc"
marker.Message="小混混(xiao hunhun)"

Lua:

local marker=hmm.Marker:New()
marker.Key="mykey"
marker.Value="gc"
marker.Desc="描述"
marker.Group="npc"
marker.Message="小混混(xiao hunhun)"

标记主键

标记对应的房间ID

描述，做备注，无实际作用

分组，可以用于筛选以及判断怎么处理Message

消息，传递给脚本的数据，可以附带标记对应的npc/道具/人物等

判断Marker是否有效。

主键不可为空，需要符合ItemKey验证。

Value不可为空。

Javascript:

var validated=marker.Validated()

Lua:

local validated=marker:Validated()

复制一个独立的Marker

Javascript:

var newmarker=marker.Clone()

Lua:

local newmarker=marker:Clone()

判断是否和另一个Marker相等

Javascript:

var same=marker.Equal(hmm.Marker.New())

Lua:

local same=marker:Equal(hmm.Marker:New())

有顺序的房间列表

Javascript:

var route=hmm.Route.New()
route.Key="myroute"
route.Group="quest"
route.Desc="描述"
route.Message="zone:yz"
route.Rooms=["0","1","2","3"]

Lua:

local route=hmm.Route:New()
route.Key="myroute"
route.Group="quest"
route.Desc="描述"
route.Message="zone:yz"
route.Rooms={"0","1","2","3"}

路线主键

描述，做备注，无实际作用

分组，可以用于筛选以及判断怎么处理Message

消息，传递给脚本的数据，可以附带路线对应的npc/道具/人物等

房间列表

判断Route是否有效。

主键不可为空，需要符合ItemKey验证

Javascript:

var validated=route.Validated()

Lua:

local validated=route:Validated()

复制一个独立的Route

Javascript:

var newroute=route.Clone()

Lua:

local newroute=route:Clone()

判断是否和另一个Route相等

Javascript:

var same=route.Equal(hmm.Route.New())

Lua:

local same=route:Equal(hmm.Route:New())

Npc或者人物对象出现的分布

Javascript:

var trace=hmm.Trace.New()
trace.Key="questnpc"
trace.Group="quest"
trace.Desc="描述"
trace.Message="托钵僧(tuobo seng)"
trace.Locations=["1","2","3"]

Lua:

local trace=hmm.Trace:New()
trace.Key="questnpc"
trace.Group="quest"
trace.Desc="描述"
trace.Message="托钵僧(tuobo seng)"
trace.Locations={"1","2","3"}

足迹主键

描述，做备注，无实际作用

分组，可以用于筛选以及判断怎么处理Message

消息，传递给脚本的数据，可以附带路线对应的npc/道具/人物等

位置列表

判断Trace是否有效。

主键不可为空，需要符合ItemKey验证

Javascript:

var validated=trace.Validated()

Lua:

local validated=trace:Validated()

复制一个独立的Trace

Javascript:

var newtrace=trace.Clone()

Lua:

local newtrace=trace:Clone()

判断是否和另一个Trace相等

Javascript:

var same=trace.Equal(hmm.Trace.New())

Lua:

local same=trace:Equal(hmm.Trace:New())

移除多个位置

参数

• locations 需要移除的位置列表

返回值

无

范例代码

Javascript:

trace.RemoveLocations(["1","2","3"])

Lua:

trace:RemoveLocations({"1","2","3"})

批量添加位置

添加后位置会升序排序

参数

• locations 需要添加的位置列表

返回值

无

范例代码

Javascript:

trace.AddLocations(["1","2","3"])

Lua:

trace:AddLocations({"1","2","3"})

地区元素，指组成地区的基本元素。

可以理解为地区的一个个零件，通过 加入某个地区/房间或者排除某个地区/房间，最后计算出地区的实际房间。

Javascript:

var regionitem=hmm.RegionItem.New(hmm.RegionItemType.Zone,"yz",false)

Lua:

local regionitem=hmm.RegionItem:New(hmm.RegionItemType.Zone,"yz",false)

地区元素的类型。可使用的值为

• RegionItemType.Room 单个房间类型
• RegionItemType.Zone 房间组类型

元素值，对应不同的Type.意义不同

• RegionItemType.Room 状态：单个房间的主键
• RegionItemType.Zone 状态: 房间的group名

取否。为false的话，对应的房间会添加到地区内，否则会从地区内排除。

判断RegionItem是否有效。

值不可为空

Javascript:

var validated=regionitem.Validated()

Lua:

local validated=regionitem:Validated()

复制一个独立的RegionItem

Javascript:

var newregionitem=regionitem.Clone()

Lua:

local newregionitem=regionitem:Clone()

判断是否和另一个RegionItem相等

Javascript:

var same=regionitem.Equal(hmm.RegionItem.New(hmm.RegionItemType.Zone,"yz",false))

Lua:

local same=regionitem:Equal(hmm.RegionItem:New(hmm.RegionItemType.Zone,"yz",false))

地区是用户预先定义的一系列的地图元素。

地图元素分为 Room类型和Zone类型，分别对应Room的Key和Group。

地区的设计目的是让用户方便的维护一个抽象地区，在地图发生变化时能一定程度自适应。

Javascript:

var region=hmm.Region.New()
region.Key="yz"
region.Group="quest"
region.Desc="描述"
region.Message="questcmd:finish"
region.Items=[hmm.RegionItem.New(hmm.RegionItemType.Zone,"yz",false)]

Lua:

local region=hmm.Region:New()
region.Key="yz"
region.Group="quest"
region.Desc="描述"
region.Message="questcmd:finish"
region.Items={hmm.RegionItem:New(hmm.RegionItemType.Zone,"yz",false)}

地区主键

描述，做备注，无实际作用

分组，可以用于筛选以及判断怎么处理Message

消息，传递给脚本的数据，可以附带地区对应的npc/道具/人物等

地区元素列表

判断Region是否有效。

主键不可为空，需要符合ItemKey验证

Javascript:

var validated=region.Validated()

Lua:

local validated=region:Validated()

复制一个独立的Region

Javascript:

var newregion=region.Clone()

Lua:

local newregion=region:Clone()

判断是否和另一个Region相等

Javascript:

var same=region.Equal(hmm.Region.New()

Lua:

local same=region:Equal(hmm.Region:New())

地标和一般的地图结构不一样，由于一个Room可以由多个地标定位，所以地标的唯一性是由Key和Type共同组成唯一主键的

依次传入Key和Type

Javascript:

var lk=hmm.LandmarkKey.New("key","type")

Lua:

local lk=hmm.LandmarkKey:New("key","type")

地标的主键，一般为对应的房间Key

地标类型

将键和类型转义后，以回车符号拼接。

参数 无

返回值

拼接后的字符串

代码范例

Javascript:

var str=lk.ToString()

Lua:

local str=lk:ToString()

判断是否和另一个LandmarkKey相等

Javascript:

var same=lk.Equal(hmm.LandmarkKey.New("key","type")

Lua:

local same=lk:Equal(hmm.LandmarkKey:New("key","type"))

记录用于定位的数据。

同一个Key支持通过多种不同的Type进行定位

一般情况下，程序应该在加载时读取所有地标信息，生成所有的定位所需数据/代码

Javascript:

var landmark=hmm.Landmark.New()
landmark.Key="gc"
landmark.Type="regexp"
landmark.Value="^  这里是扬州的中心广场"
landmark.Group="常规定位"
landmark.Desc="描述"

Lua:

local landmark=hmm.Landmark:New()
landmark.Key="gc"
landmark.Type="regexp"
landmark.Value="^  这里是扬州的中心广场"
landmark.Group="常规定位"
landmark.Desc="描述"

地标主键

具体用来定位的数据

描述，做备注，无实际作用

类型 判断怎么处理Value

分组，可以用于筛选

判断Landmark是否有效。

主键不可为空，需要符合ItemKey验证

Javascript:

var validated=landmark.Validated()

Lua:

local validated=landmark:Validated()

复制一个独立的Landmark

Javascript:

var newlandmark=landmark.Clone()

Lua:

local newlandmark=landmark:Clone()

判断是否和另一个Landmark相等

Javascript:

var same=landmark.Equal(hmm.Landmark.New()

Lua:

local same=landmark:Equal(hmm.Landmark:New())

获得Landmark对应的唯一标识LandmarkKey

参数

无

返回值

对应的LandmarkKey

代码范例

Javascript:

var lk=landmark.UniqueKey()

Lua:

local lk=landmark:UniqueKey()

带房间条件的出口，一般用于飞行类不定起点出口

Javascript:

var rce=hmm.RoomConditionExit.New()
rce.Command="rideto gc"
rce.To="yzzxgc"
rce.RoomConditions=[hmm.ValueCondition.New("outside",1,false)]
rce.Conditions=[hmm.ValueCondition.New("ride",1,false)]
rce.Cost=2

Lua:

local rce=hmm.RoomConditionExit:New()
rce.Command="rideto gc"
rce.To="yzzxgc"
rce.RoomConditions={hmm.ValueCondition:New("outside",1,false)}
rce.Conditions={hmm.ValueCondition:New("ride",1,false)}
rce.Cost=2

出口的实际指令，不可为空，继承自Exit

出口对应的房间。建议待处理的可以用 * 或 ？占位，继承自Exit

房间条件列表，房间Tag必须符合所有Condition，才能使用出口

值条件列表

必须在Context里满足所有Condition,才能使用出口，继承自Exit

出口的消耗，默认1.

计算路径时的出口消耗。小于1的值属于Undefined Behave

继承自Exit

捷径指能从任意符合条件的位置进入的出口。

继承自RoomConditionExit

Javascript

var shortcut=hmm.Shortcut.New()
shortcut.Key="rideyz"
shortcut.Group="ride"
shortcut.Desc="描述"
shortcut.Command="rideto gc"
shortcut.To="yzzxgc"
shortcut.RoomConditions=[hmm.ValueCondition.New("outside",1,false)]
shortcut.Conditions=[hmm.ValueCondition.New("ride",1,false)]
shortcut.Cost=2

Lua

local shortcut=hmm.Shortcut:New()
shortcut.Key="rideyz"
shortcut.Group="ride"
shortcut.Desc="描述"
shortcut.Command="rideto gc"
shortcut.To="yzzxgc"
shortcut.RoomConditions={hmm.ValueCondition:New("outside",1,false)}
shortcut.Conditions={hmm.ValueCondition:New("ride",1,false)}
shortcut.Cost=2

捷径的主键

捷径的分组

描述属性，备注用，无实际用途。

出口的实际指令，不可为空，继承自Exit

出口对应的房间。建议待处理的可以用 * 或 ？占位，继承自Exit

房间条件列表，房间Tag必须符合所有Condition，才能使用出口，继承自RoomConditionExit

值条件列表

必须在Context里满足所有Condition,才能使用出口，继承自Exit

出口的消耗，默认1.

计算路径时的出口消耗。小于1的值属于Undefined Behave

继承自Exit

判断Shortcut是否有效。

主键不可为空，需要符合ItemKey验证

Command不可为空(继承自Exit)

Javascript:

var validated=shortcut.Validated()

Lua:

local validated=shrotcut:Validated()

复制一个独立的Shortcut

Javascript:

var newshortcut=shortcut.Clone()

Lua:

local newshortcut=shortcut:Clone()

判断是否和另一个Shortcut相等

Javascript:

var same=shortcut.Equal(hmm.Shortcut.New()

Lua:

local same=shortcut:Equal(hmm.Shortcut:New())

变量指存在地图文件中，脚本可以通过Key获取的属性，用于向脚本传递一些额外信息。

Javascript:

var variable=hmm.Variable.New()
variable.Key="myvar"
variable.Value="12345"
variable.Group="demovar"
variable.Desc="描述"

Lua:

var variable=hmm.Variable:New()
variable.Key="myvar"
variable.Value="12345"
variable.Group="demovar"
variable.Desc="描述"

变量的主键

传递给脚本的值

分组

描述属性，备注用，无实际用途。

判断Variable是否有效。

主键不可为空，需要符合ItemKey验证

Javascript:

var validated=variable.Validated()

Lua:

local validated=variable:Validated()

复制一个独立的Variable

Javascript:

var newvariable=variable.Clone()

Lua:

local newvariable=variable:Clone()

判断是否和另一个Variable相等

Javascript:

var same=variable.Equal(hmm.Variable.New()

Lua:

local same=variable:Equal(hmm.Variable:New())

快照和一般的地图结构不一样，由Key,Value,Type构成一组唯一主键

依次传入Key，Type和Value

Javascript:

var sk=hmm.SnapshotKey.New("key","type","value")

Lua:

local sk=hmm.SnapshotKey:New("key","type","value")

快照的主键，一般为对应的房间Key

快照类型

具体的快照值

将键,类型，值转义后，以回车符号拼接。

参数 无

返回值

拼接后的字符串

代码范例

Javascript:

var str=sk.ToString()

Lua:

local str=sk:ToString()

判断是否和另一个SnapshotKey相等

Javascript:

var same=sk.Equal(hmm.SnapshotKey.New("key","type","value")

Lua:

local same=sk:Equal(hmm.SnapshotKey:New("key","type","value"))

快照指对房间可能变化的环境变量进行的保存。

可以通过搜索快照的方式来快速定位快照

Javascript:

//一般不会直接创建快照对象，通过APITakeSnapshot建立。
var snapshot=hmm.Snapshot.New()
snapshot.Key="yzgc"
snapshot.Type="desc"
snapshot.Value="这里是扬州广场"
snapshot.Timestamp=1700000000
snapshot.Group="mygroup"
snapshot.Count=1

Lua:

--一般不会直接创建快照对象，通过APITakeSnapshot建立。
local snapshot=hmm.Snapshot:New()
snapshot.Key="yzgc"
snapshot.Type="desc"
snapshot.Value="这里是扬州广场"
snapshot.Timestamp=1700000000
snapshot.Group="mygroup"
snapshot.Count=1

快照主键，一般是对应的房间Key

快照类型，一般决定了Value中存的是什么信息

具体的快照值

快照的更新时间

同一组 Key,Type,Value的重复次数

每次TakeSnapshot时会加1

获取快照对应的 SnapshotKey属性

参数

无

返回值

SnapshotKey

代码范例

Javascipt:

var sk=snapshot.UniqueKey()

Lua:

local sk=snapshot:UniqueKey()

重复的快照， Count属性自增1

参数

无

返回值

无

代码范例

Javascript:

snapshot.Repeat()

Lua:

snapshot:Repeat()

判断Snapshot是否有效。

主键不可为空，需要符合ItemKey验证

Javascript:

var validated=snapshot.Validated()

Lua:

local validated=snapshot:Validated()

复制一个独立的Snapshot

Javascript:

var newsnapshot=snapshot.Clone()

Lua:

local newsnapshot=snapshot:Clone()

判断是否和另一个Snapshot相等

Javascript:

var same=snapshot.Equal(hmm.Snapshot.New()

Lua:

local same=snapshot:Equal(hmm.Snapshot:New())

快照过滤器是用来批量删除快照的过滤器

依次传入 Key,Type,Group

通过WithMaxCount 传入MaxCount

Javascript:

var sf=hmm.SnapshotFilter.New("yzgc","regexp","mygroup").WithMaxCount(1)

Lua:

local sf=hmm.SnapshotFilter:New("yzgc","regexp","mygroup"):WithMaxCount(1)

属性如果不为空，那么只有具有相同属性的Snapshot才会通过过滤

多个属性之间是 and 关系

更新记录

• 版本1002 加入 MaxCount

更新记录

• 版本1002 加入 WithMaxCount

快照搜索类用于搜索具有特定指的快照

Javascript:

var ss=hmm.SnapshotSearch.New()
ss.Type="regexp"
ss.Group="mygroup"
ss.Keyword=["扬州","广场"]
ss.PartialMatch=true
ss.Any=false

Lua:

local ss=hmm.SnapshotSearch:New()
ss.Type="regexp"
ss.Group="mygroup"
ss.Keyword=["扬州","广场"]
ss.PartialMatch=true
ss.Any=false

限制快照类型，留空不限制

限制快照分组，留空不限制

关键字列表

搜索关键字，关键字列表，具体效果和下面两个参数相关

留空返回与Any相反的结果。

部分匹配，默认表现为只要关键字出现在快照内容内就匹配。为false则必须完整匹配

任意满足一般用在完整匹配时，任何一个关键字匹配则快照匹配

最大噪声数据。

Any为false的情况下，每一个不匹配的关键字为一个噪音数据。

噪音数据数量超过 NaxNoise属性则匹配失败。

快照搜索API返回的结果

代表从一个房间到另一个房间的链接，用于Context

依次传入起点和终点

Javascript:

var link=hmm.Link.New("0","1")

Lua:

local link=hmm.Link:New("0","1")

代表通过某个指令到达某地的消耗，用于Context

依次转入指令，目标和消耗

Javascript:

var cc=hmm.CommandCost.New("rideto gc","gc",5)

Lua:

local cc=hmm.CommandCost:New("rideto gc","gc",5)

带起点的临时路径，继承自Exit

Javascript:

var path=hmm.Path.New()
path.From="gc"
path.Command="north"
path.To="0"
path.Conditions=[hmm.ValueCondition.New("gb",1,false)]
path.Cost=1

Lua:

local path=hmm.Path:New()
path.From="gc"
path.Command="north"
path.To="0"
path.Conditions={hmm.ValueCondition:New("gb",1,false)]
path.Cost=1

临时路径起点

出口的实际指令，不可为空，继承自Exit

出口对应的房间。建议待处理的可以用 * 或 ？占位，继承自Exit

房间条件列表，房间Tag必须符合所有Condition，才能使用出口

值条件列表

必须在Context里满足所有Condition,才能使用出口，继承自Exit

出口的消耗，默认1.

计算路径时的出口消耗。小于1的值属于Undefined Behave

继承自Exit

上下文是计算和查询路径时的临时环境

Javascript:

var ctx=hmm.Context.New()

Lua:

local ctx=hmm.Context:New()

• 所有的方法都会返回Context本身，方便链式调用

版本更新

• 1006 版之后，加入WithRoomTags和ClearRoomTags方法。
• 1002 版之后，CommandCosts支持To为空字符串作为通配符，匹配所有出口。

在地图计算时一次性使用的选项

Javascript:

var opt=hmm.MapperOptions.New()
opt.MaxExitCost=0
opt.TotalCost=0
opt.DisableShortcuts=false

Lua:

local opt=hmm.MapperOptions:New()
opt.MaxExitCost=0
opt.TotalCost=0
opt.DisableShortcuts=false

版本更新

• 1005 加入 CommandNotContains 属性
• 1002 加入 CommandWhitelist 属性。

最大出口消耗，忽略Cost大于本值的出口，小于等于0忽略

最大路线消耗，计算路径超过这个值时路线计算失败，小于等于0忽略

计算路线时是否不使用捷径

指令必须在白名单内，出口才有效，为空忽略。

如果指令包含清单内的字符串，则出口无效

版本更新

• 1005 加入WithCommandNotContains和ClearCommandNotContains
• 1002 加入 WithCommandWhitelist和ClearCommandWhitelist方法

移动步骤对象是查询路线的结果的一部分。

路线规划结果是APIQueryPath系列接口 返回的查询结果