game_server.engine

简介

游戏服务端引擎的入口文件

组件接口

auth.gs

客户端命令处理器: 登录验证

函数原型	函数作用
mixed main(object conn, string account, string pass_md5, map args = )	命令处理的主函数

debug_login.gs

客户端命令处理器: 调试时快速登录

函数原型	函数作用
array main(object conn, string account)	命令处理的主函数

exit_login_queue.gs

客户端命令处理器: 退出登录排队队列

函数原型	函数作用
void main(object conn)	命令处理的主函数

gm.gs

客户端命令处理器: 执行GM功能

函数原型	函数作用
mixed main(object user, string gm_cmd, ...)	命令处理器的主函数

list_users.gs

客户端命令处理器:列出账号下的所有角色列表

函数原型	函数作用
array main(object conn, map ld)	命令处理的主函数

login.gs

客户端命令处理器: 登录

函数原型	函数作用
array main(object conn, map ld)	命令处理的主函数

post_login.gs

客户端命令处理器: 客户端登录处理就绪后处理

触发post_user_login_ok事件

函数原型	函数作用
void main(object user)	命令处理的主函数

query_server_info.gs

客户端命令处理器:查询服务器信息

函数原型	函数作用
map main(object ob)	命令处理的主函数

request.gs

客户端命令处理器: 同步请求，执行后反馈给客户端执行结果

函数原型	函数作用
void main(object conn_or_user, int cookie, string cmd, mixed args)	命令处理的主函数

run_command.gs

客户端命令处理器: 汇报客户端远程指令执行结果

配合TelnetD模块功能

函数原型	函数作用
void main(object user, string type, string ret)	命令处理的主函数

FAttrib.gs

实体属性组件1.0版本，基于pkg.attrib_calc实现

目前推荐使用FEntityAttrib组件

函数原型	函数作用
void FAttribCalc.send_attribs()	同步消息：属性完整更新
void FAttribCalc.send_attribs_changed(array change_list)	同步消息：属性变更更新

FClientConnectionHolder.gs

持有客户端网络连接对象的组件

函数原型	函数作用
object get_connection()	获取当前持有的客户端连接对象
bool bind_connection(object conn)	关联或者绑定客户端网络连接对象
bool prev_bind_connection(object conn)	虚函数: 关联或者绑定时的前处理
object unbind_connection()	解除关联或者绑定的客户端连接对象
void post_unbind_connection(object prev_conn)	虚函数: 解除关联或者绑定时的后处理
void notify_bind(object conn)	通知处理: 执行关联或者绑定客户端连接对象
void notify_unbind(object conn)	通知处理: 执行解除关联或者绑定客户端连接对象
mixed process_request(object conn_or_user, string cmd, array args)	处理客户端请求

FComm.gs

基础通讯组件，提供发送消息和广播消息的接口

函数原型	函数作用
void set_comm(bool is_comm)	虚函数: 设置通讯状态
bool is_comm()	虚函数: 获取通讯状态
void switch_comm(bool new_value)	切换通讯状态到指定值（切换前的状态将被保存）
void recover_comm()	恢复原来的通讯状态（switch_comm时保存的状态将被恢复）
void send(string msg, ...)	发送消息（消息名称和变参形式的消息参数）
void send_arr(string msg, array msg_args)	发送消息（消息名称和数组形式的消息参数列表）
void broadcast(string msg, ...)	广播消息（消息名称和变参形式的消息参数）
void send_raw(mixed payload)	虚函数：发送消息（已经组织好的消息数据）
void broadcast_raw(mixed payload)	虚函数：广播消息（已经组织好的消息数据）

FComponentBase.gs

动态组件对象的基础组件，和FComponents对应

实现一个可被FComponents组件添加的动态组件对象时，动态组件对象应该包含本组件
一般情况下，只有在需要动态添加组件时才推荐使用动态组件对象
动态组建对象只能通过new_component/load_component创建

函数原型	函数作用
void set_component_owner(object parent)	设置本动态组件对象的所有者
object get_component_owner()	获取本动态组件对象的所有者
object gco()	get_component_owner接口的简短版本
void notify_field_update(string field_name, string d, mixed key, mixed val)	通知:本动态组件对象的字段值更新了
void notify_all_look_fields_update(string field_name, string d, mixed key, mixed val)	obsoleted
void notify_appearance_update(string field_name, string d, mixed key, mixed val)	通知:本动态组件对象的外观字段值更新了

FComponents.gs

动态组件对象的管理组件

需要挂载动态组件对象的对象都应该包含本组件

函数原型	函数作用
void dump_components()	调试接口: 输出所有动态组件信息
void add_dyn_component(object comp)	虚函数: 添加一个动态组件对象
void remove_dyn_component(object comp)	虚函数：移除一个动态组件对象
void remove_all_dyn_components()	移除所有动态组件对象
object get_dyn_component(string name)	通过动态组件名称获取动态组件对象
object comp(string name)	get_dyn_component方法的简短版本
array get_dyn_components()	获取所有动态组件对象列表
map get_dyn_components_dict()	获取所有动态组件对象词典
void do_components_heartbeat()	执行一次心跳
void notify_event(string evt, array args)	向所有动态组件对象通知事件
map query_components_dbase()	获取所有动态组件对象的常驻数据
void iterate_components(function func)	遍历所有动态组件对象

FCookieProvider.gs

对象范围内的cookie生成器，保证对象范围内相同id的cookie唯一且不重复

和FCookiePrivider配合使用时,可以发布订阅机制下的内容发布者

函数原型	函数作用
void init_cookies(array cookie_list)	初始化一组指定名称id的cookie列表
void init_cookie(mixed cookie_id)	初始化一个指定名称id的cookie
void destroy_cookie(mixed cookie_id)	销毁一个指定名称id的cookie
bool contains_cookie(mixed cookie_id)	检查是否包含指定名称id的cookie
int get_cookie(mixed cookie_id)	获取指定名称id的cookie值
void update_cookie(mixed cookie_id)	更新指定名称id的cookie值（cookie值递增+1）
bool is_cookie_matched(mixed cookie_id, int cookie_value)	检查指定名称id的cookie值是否和目标值匹配

FCookieSubscriber.gs

cookie同步机制中的订阅者

这是一个低频的单向同步机制: 主动获取目标对象的同步内容
update_subscribe_cookies()函数负责拖取所有目标对象的同步内容
目标对象是内容的发布方,需要包含FCookieProvider组件
包含本组件的对象是内容的订阅方
需要在心跳中主动执行update_subscribe_cookies方法主动获取订阅目标发布的cookie内容

函数原型	函数作用
void subscribe_cookie(mixed cookie_id, object target_ob, function func, function unsubscribe_callback = nil)	订阅目标发布的指定名称id的cookie
void unsubscribe_cookie(mixed cookie_id)	取消订阅指定名称id的cookie
void update_subscribe_cookies()	执行一次心跳（主动获取订阅目标发布的cookie内容）

FCoPoolSerial0.gs

基于hash值的有序执行的协程池

相同hash值的操作将分配到同一个操作队列中以便保证顺序执行

函数原型	函数作用
int co_pool_size()	获取当前的协程池大小
void dispatch_service_serial(int hash, function func)	分发操作（相同哈希值的操作将分配到同一个操作队列中以便保证顺序执行）

FEntity.gs

游戏里实体对象的基础组件

实体对象需要通过实体对象工厂（Entity Factory）创建
所有实体对象都应该直接或者间接包含本组件

函数原型	函数作用
bool is_entity()	是不是游戏实体对象
bool is_dynamic_entity()	是不是一个在动态创建的实体模板上创建的游戏实体对象
void post_factory_create(bool new_create)	虚函数: EntityFactroy创建本实体（不包括子对象）时的后处理
void post_factory_fully_create(bool new_create)	虚函数: EntityFactroy完整创建本实体（包括子对象）时的后处理
string desc()	虚函数: 获取实体对象的描述信息
mixed is_unloaded()	检查对象是否已被卸载
object FHeartbeat.get_heartbeat()	虚函数: 获取心跳对象
void FHeartbeat.pre_heartbeat_stop()	虚函数: 停止心跳时的前处理
void FHeartbeat.post_heartbeat_start()	虚函数: 启动心跳时的后处理
void FHeartbeat.heartbeat()	虚函数: 执行一次心跳处理
int get_class_id()	获取实体对象的class id（模板id）
string get_rid()	获取实体对象的rid
string get_name()	获取实体对象的名称
map get_info()	获取实体对象的模板信息
map get_entity_cfg()	获取实体对象的类型的模板信息
string get_entity_type()	获取实体对象的类型
void set_name(string name)	设置实体对象的名称字段(name)
void set_creating(bool is_creating)	标记实体对象的创建状态（工厂对象EntityFactory要求的接口）
bool is_creating()	检查实体对象是不是处于创建中状态
bool is_new_create()	检查实体对象是不是新创建的
mixed query_from_template(string key)	虚函数:查询实体模板信息指定的字段值
bool FDbase.is_dirty()	虚函数:判断实体的常驻数据是否发生了改变
mixed FDbase.query(string key)	虚函数:查询实体对象指定的字段值
mixed FDbase.query_by_path(string key)	虚函数: 查询实体对象指定的字段值，支持通过路径查询
void FComponents.add_dyn_component(object comp)	虚函数: 添加一个动态组件对象
void FComponents.remove_dyn_component(object comp)	虚函数：移除一个动态组件对象
void FComm.send_raw(mixed data)	虚函数：发送消息（已经组织好的消息数据）
void FComm.broadcast_raw(mixed data)	虚函数：广播消息（已经组织好的消息数据）
void FComm.set_comm(bool is_comm)	虚函数: 设置通讯状态
void FNode.on_add_child(object child, string name)	虚函数: 添加子节点对象时的后处理
void FNode.on_node_name_changed(string name, string old_name)	虚函数: 作为子节点对象时响应节点名称变化时的处理函数
void FNode.pre_add_to_parent(object parent, string name)	虚函数: 作为子节点对象时被父节点添加前的处理函数
void FNode.on_add_to_parent(object parent, string name)	虚函数: 作为子节点对象时被父节点添加后的处理函数
void FNode.pre_remove_from_parent(object parent)	虚函数: 作为子节点对象时被父节点移除前的处理函数
void FNode.on_remove_from_parent(object parent)	虚函数: 作为子节点对象时被父节点移除后的处理函数
bool need_send(object send_to)	虚函数: 检查是不是需要发送
void sync_data(bool recursively = false, string privilege = "self", object notify_ob = nil, string sync_tag = "node")	虚函数: 将指定权限类型的常驻字段数据同步给通知对象（考虑子节点）
void sync_destruct(bool resursively = false, object notify_ob = nil, string sync_tag = "node")	同步本实体销毁的消息给通知对象（考虑子节点）
void sync_destruct_self(object notify_ob = nil, string sync_tag = "node")	同步本实体销毁的消息给通知对象
object get_mongo_agent()	获取本实体对象关联的mongodb数据库连接对象
string get_db_collection()	获取本实体对象关联的mongodb数据库集合表名称
array get_children_collections()	获取本实体对象的子对象们关联的mongodb数据库集合表名称列表
void sync_myself(string privilege = "self", object notify_ob = nil, string sync_tag = "node")	虚函数: 同步本实体指定权限类型的常驻数据给通知对象
map collect_dyn_components_fields(string privilege)	收集所有动态组件对象的指定权限类型的常驻数据
array get_partner_obs()	获取伙伴对象列表
bool is_all_partners_auto_load()	检查是否自动加载所有伙伴对象
void update_partner_dict()	更新本实体对象的伙伴词典（更新__partner_dict__字段）
map get_partner_dict()	获取伙伴对象词典（__partner_dict__字段值）
object load_partner_ob(string partner_rid, function func = nil)	加载一个伙伴对象
array load_partner_obs(function func = nil)	佳作所有伙伴对象
void notify_field_update(string field_name, string d, mixed key, mixed val, mixed op)	虚函数: 自身字段更新时的通知函数
void notify_other_field_update(object other, string field_name, string d, mixed key, mixed val, mixed op)	虚函数: 目标对象字段更新时的通知函数
void notify_component_field_update(string comp, string field_name, string d, mixed key, mixed val, mixed op)	虚函数: 组件字段更新时的通知函数
void notify_other_component_field_update(string comp, object other, string field_name, string d, mixed key, mixed val, mixed op)	虚函数: 目标对象组件字段更新时的通知函数
void do_children_passive_heartbeat()	执行一次所有子对象的被动心跳

FEntityAppearance.gs

实体对象的外观组件

函数原型	函数作用
void notify_appearance_update(string field_name, string d, mixed key, mixed val, mixed op)	虚函数: 实体对象外观字段发生改变时的通知函数
void notify_component_appearance_update(string comp, string field_name, string d, mixed key, mixed val)	虚函数: 实体对象的动态组件的外观字段发生改变时的通知函数
map query_appearance_data()	获取实体对象的外观数据（权限类型为"appearance"的常驻数据）

FEntityAttrib.gs

实体对象的属性组件

本组件是基于pkg.attrib_calc2实现的，目的是取代废弃的FAttrib组件

函数原型	函数作用
string FAttribCalc.get_attrib_calculator_id()	虚函数: 获取实体对象的属性计算器id
void FAttribCalc.send_attribs(map prev_attrib_dict)	虚函数: 同步实体对象的属性值词典
void FAttribCalc.post_refresh_attribs(map prev_attrib_dict)	虚函数: 更新属性值词典时的后处理

FEntityContainer.gs

实体对象的容器功能组件

支持通过rid获取子对象

函数原型	函数作用
object get_child_by_rid(string rid, bool recursive = true)	通过rid获取子对象
map get_children_dict()	获取所有子对象词典

FEntityPrevClose.gs

实体对象支持销毁（close）前处理机制的组件

期望实体对象close时触发函数执行同时又不期望函数在析构函数中执行时，可以通过该组件实现

函数原型	函数作用
void set_prev_close_func(function func)	设置实体对象析构前的回调处理函数（在prev_close前执行）
void prev_close()	虚函数:实体对象析构前的处理函数

FEntityProfile.gs

基于心跳机制实现的资料同步组件(发布订阅模式)

做为发布者
通过add_publish_profile_type()添加发布的资料类型
做为订阅者
通过subscribe_profile方法订阅资料
重要!!!
1. 包含本组件的对象需要在心跳函数中执行publish_all_profiles()发布所有资料
1. 包含本组件的对象需要在心跳函数中执行update_subscribe_cookies()更新订阅的资料
1. 订阅者通过get_subscribe_profile()获取订阅资料

函数原型	函数作用
void add_publish_profile_type(string profile_type, function profile_gen_func)	添加发布类型
void remove_publish_profile_type(string profile_type)	移除发布类型
void remove_all_publish_profile_types()	移除所有发布类型
void set_publish_profile_dirty(string profile_type)	标记资料需要发布
void publish_profile(string profile_type, bool force_publish = false)	发布指定类型的资料
void publish_all_profiles()	发布所有资料
mixed get_publish_profile(string profile_type)	提供给订阅者获取指定类型的资料
void subscribe_profile(string profile_type, object publish_ob, function func)	订阅指定类型的资料
void unsubscribe_profile(string profile_type)	取消已订阅的指定类型的资料
void unsubscribe_all_profiles()	取消所有已订阅的资料
mixed get_subscribe_profile(string profile_type)	订阅者获取订阅的资料

FEntityRelativeQuery.gs

实体对象支持通过关联查询获取字段值的组件

主要实现就是覆盖了FEntity.query接口。
另外，关联查询功能是在特定项目的需求的基础上实现的

函数原型	函数作用
mixed FEntity.query(string key)	虚函数:查询实体对象指定的字段值

FEventEmitter.gs

事件触发器组件

仿照python的libs.pyee实现的

函数原型	函数作用
void on(string event, function fn)	响应事件（为响应函数展开参数）
void on_raw(string event, function fn)	响应事件（不为响应函数展开参数）
void once(string event, function fn)	响应事件，触发一次后自动移除（为响应函数展开参数）
void remove_event(string event)	移除指定事件的所有响应函数
void emit(string event, ...)	触发一次事件
void emit_local(string event, ...)	触发一次事件（响应函数不允许跨域）
void remove_listener(string event, function fn)	移除指定事件的指定响应函数
void remove_listener_by_object(string event, object func_ob)	移除指定事件的指定响应函数
void remove_listeners_by_object(object func_ob)	移除所有事件的指定响应函数
map debug_get_events()	调试接口：获取所有事件信息

FFields.gs

字段组件

不同类型的对象有不同字段
不同字段有不同的权限
支持不同权限字段的更新和收集
配合Entity使用，必须有class_id
字段操作四元组说明:
- 当d为nil时，key是常驻数据dbase的一个键
- 当d为常驻数据dbase的一个键时（对应的值必须是词典类型），key是词典类型值的一个子健
- 当d为常驻数据dbase的一个键时（对应的值必须是列表类型），key是列表类型值的一个有效索引
- 当value为nil时，表示删除对应数据
- 当op等于list_set时，表示更新列表对应位置的值

函数原型	函数作用
string get_field_type()	虚函数: 指定获取用于初始化本对象字段类型的接口
string get_ob_field_type()	获取本对象字段类型的接口
map collect_fields(string privilege = nil)	收集指定权限的字段数据词典
void send_field_change(string key)	同步字段变更
void FDbase.set(string key, mixed val)	设置字段值
void FDbase.delete(string key)	删除字段
void FDbase.dict_set(string d, mixed key, mixed val)	设置词典字段的子键值
void FDbase.dict_delete(string d, mixed key)	删除词典字段的子键
void FDbase.list_set(string d, int pos, mixed val)	设置数组字段指定位置的值
void FDbase.list_insert(string d, int pos, mixed val)	在数组字段指定位置插入一个值
void FDbase.list_push_back(string d, mixed val)	在数组字段的末尾插入一个值
void FDbase.list_delete_at(string d, int pos)	删除数组字段指定位置的值
int FDbase.list_delete(string d, mixed value)	删除数组字段的指定值
array get_privilege_fields(string privilege)	获取指定权限的字段列表
void iterate_privilege_fields(string privilege, function func)	遍历指定权限的字段列表
void send_field_update(string key, mixed v = "get_void_value()")	同步字段值更新
void send_dict_field_update(string d, mixed key, mixed v = "get_void_value()")	同步词典字段的键值更新
void send_list_field_update(string d, int pos, mixed v = "get_void_value()")	同步数组字段的成员值更新
Field get_field(string key)	获取字段信息
void add_dynamic_field(string field_name, mixed privileges = nil)	增加动态字段（只对自己起效）
void remove_dynamic_field(string field_name, mixed privilege = nil)	移除动态字段（只对自己起效）
void disable_field(string field_name, string privilege = nil)	限制指定字段的所有权限或者指定权限
void enable_field(string field_name, string privilege = nil)	取消指定字段的所有权限或者指定权限的限制
bool check_privilege(string field_name, string privilege)	检查字段的是否包含某个权限
bool is_field_disabled(string field_name, string privilege)	检查指定字段的指定权限是否被限制

FHeartbeat.gs

心跳组件

内置以下几种心跳:
- 固定时间间隔的主动心跳
- 以父节点心跳次数为计数的被动心跳
- 基于父节点心跳的固定时间间隔的被动心跳
支持自定义心跳（遵守HeartbeatBase约束的心跳）

函数原型	函数作用
object get_heartbeat()	虚函数: 获取心跳对象
void heartbeat()	虚函数: 执行一次主动心跳
bool is_passive_heartbeat()	当前心跳是不是被动心跳
bool is_heartbeat()	当前心跳是不是主动心跳
bool has_heartbeat()	当前是否有心跳（无论主动还是被动）
int get_heartbeat_last_timing()	获取心跳最近一次的已触发时机
void post_heartbeat_start()	开启心跳时的后处理
void pre_heartbeat_stop()	关闭心跳时的前处理
void start_heartbeat(int ms)	开启主动心跳（固定时间间隔的主动心跳）
void start_passive_heartbeat(int ms)	开启计时型的被动心跳（基于父节点心跳的固定时间间隔的被动心跳）
void start_passive_heartbeat_by_times(int times)	开始计次型的被动心跳（以父节点心跳次数为计数的被动心跳）
void start_custom_heartbeat(HeartbeatBase hb, int interval)	开启自定义心跳(遵守HeartbeatBase约束的心跳)

FInRoom.gs

可以和房间对象（Room）进行交互的实体对象的基础组件

包含本组件的实体对象可以存在于房间对象中

函数原型	函数作用
void set_position(map pos)	设置在房间里的位置
map get_position()	获取在房间里的位置
map get_ro_position()	获取在房间里的位置(parallel版)
object get_ro_room()	获取房间对象(parallel版)
object get_room()	获取房间对象(非parallel版)
void pre_enter_room(object room_ob)	虚函数: 进入放前时的前处理
bool enter_room(object room_ob, map pos)	进入房间
void pre_leave_room()	虚函数: 离开房间时的前处理
bool leave_room()	离开房间

FLightEntity.gs

轻量级实体对象的基础组件

轻量级实体对象和普通实体对象一样，都需要由EntityFactory创建
注意：轻量级实体基础组件是在某一个时间段里的特殊需求上实现的，实际应用中不具备普遍性。

函数原型	函数作用
void post_factory_create(bool new_create)
void post_factory_fully_create(bool new_create)	虚函数: EntityFactroy完整创建本实体（包括子对象）时的后处理
string desc()	虚函数: 获取实体对象的描述信息
string get_id()	获取实体对象的唯一id
string get_name()	获取实体对象的名称
string get_entity_type()	获取实体对象的类型
map get_info()	获取实体对象的模板信息
map get_entity_cfg()	获取实体对象的类型的模板信息
void set_name(string name)	设置实体对象的名称字段(name)
void set_creating(bool is_creating)	标记实体对象的创建状态（工厂对象EntityFactory要求的接口）
bool is_creating()	检查实体对象是不是处于创建中状态
mixed query_from_template(string key)	虚函数:查询实体模板信息指定的字段值
mixed FDbase.query(string key)	虚函数:查询实体对象指定的字段值

FLockable.gs

依赖原子操作实现的可被锁定组件

接口都是并行的

函数原型	函数作用
bool lock()	锁定
bool unlock()	解锁
bool is_locking()	判断当前是否已锁定

FLookField.gs

实体支持观察或者被观察字段变更的组件包含此组件后:

1.拥有了观察某个entity身上字段变化的能力
2.拥有了被entity观察身上字段改变的能力
3.开始观察notify_look
4.停止观察notify_unlook
5.字段改变notify_look_field_update
6.如果递归观察某个对象，则该对象的子节点字段发生变化也会通知
7.如果递归观察某个对象，改对象子节点attach/detach的时候也会触发look/unlook

函数原型	函数作用
void dump_look(bool deep = false, map looked = )	调试接口: 输出所有观察的字段列表
bool can_be_look(object ob)	作为被观察者，判断是否可以被观察者观察
bool can_look(object ob)	作为观察者，判断是否可以观察目标对象
void look(object ob, string privilege, string reason, bool recursive = true, object look_callback_ob = nil)	观察目标指定权限的所有字段变更
void unlook(object ob, string privilege, string reason)	取消观察目标指定权限的所有字段变更
bool is_look(object ob)	是否已经观察目标对象
bool is_look_by(object ob)	作为被观察者，是否被目标对象观察
map get_all_looks()	作为观察者，获取所有的观察对象列表
map get_all_lookers()	作为被观察者，获取所有观察我的对象列表
void sync_look(object notify_ob = nil)	作为观察者，同步所有观察对象的字段信息给通知对象
void sync_unlook(object notify_ob = nil)	作为观察者，同步所有观察对象的销毁信息给通知对象
void notify_all_look_fields_update(string field_name, string d, mixed key, mixed val, mixed op)	作为被观察者，通知所有观察我的对象，字段值发生变更
void unlook_all()	作为观察者，取消所有观察
void clear_all_lookers()	作为被观察者，从所有观察者中的观察列表中移除

FNode.gs

节点组件

节点可以拥有子节点

函数原型	函数作用
void set_capacity(int capacity)	设置可容量子节点的最大数量
int get_capacity()	获取容量
int get_vacancy()	获取剩余容量
void set_node_name(string name)	设置本节点名称
string get_node_name()	获取本节点名称
bool has_child(object child)	是否拥有指定的子节点对象
int find_child(object child)	查找子节点对象
void dump(int tab = 0)	虚函数: 输出本节点的信息（包含子节点信息）
void pre_add_child(object child, string name)	虚函数：添加子节点是的前处理
void pre_add_to_parent(object parent, string name)	虚函数: 被添加进父节点时的前处理
void on_add_to_parent(object parent, string name)	虚函数：被添加进父节点时的后处理
void pre_remove_child(object child)	虚函数：移除子节点时的前处理
void on_remove_child(object child)	虚函数：移除子节点时的后处理
void pre_remove_from_parent(object child)	虚函数：被父节点移除时的前处理
void on_remove_from_parent(object child)	虚函数：被父节点移除时的后处理
void on_node_name_changed(string name, string old_name)	虚函数：节点名称改变时的后处理
int add_child(object child, string name = nil)	添加子节点
bool insert_child(object child, int index, string name = nil)	在指定的位置上添加子节点
bool remove_child(object child)	移除子节点
object remove_child_at(int index)	移除指定位置的子节点
void detach_from_parent()	作为子节点时，主动从父节点分离
bool attach_to_parent(object parent, string name = nil)	作为子节点时，主动关联到父节点
bool set_child_name(object child, string name = nil)	设置子节点的名称
int child_count()	获取子节点数量
int named_child_count()	获取有名字的子节点数量
void set_parent(object parent)	作为子节点时，设置父节点对象
object get_parent()	作为子节点时，获取父节点对象
object get_root_parent()	获取根父节点对象
bool is_root_node()	判断本节点是否为根节点
object get_root_node()	获取根节点对象（根父节点的根节点是nil）
void set_root_node(object node)	设置根节点对象
void set_root_node_recursively(object node)	为自己以及子孙节点设置根节点
object get_child(string name)	获取指定名称的子节点对象
map get_named_children()	获取所有有名字的子节点词典
object get_child_at(int index)	获取指定索引位置的子节点对象
array get_children()	获取所有子节点列表
void iterate_children(function func)	遍历所有子节点
void iterate_dup_children(function func)	遍历所有子节点（遍历过程中可改变子节点数量）
void invoke_recursively_post(function func)	后续遍历节点树（本节点为根节点）
void invoke_recursively_pre(function func)	前序遍历节点树（本节点为根节点）
void destruct_children()	销毁所有子节点
array filter_children(function fn)	获取满足条件的子节点列表
void iterate_named_children(function func)	遍历所有有名字的子节点
void iterate_dup_named_children(function func)	遍历所有有名字的子节点（遍历过程中可改变有名字子节点数量）

FSave.gs

实体存储组件

函数原型	函数作用
void set_enable_save_stat(bool enable)	设置存盘统计的开关状态
void attach_to_db(bool flag_attached_to_db)	设置和数据库之间的关联状态
void set_savable(bool flag_savable)	设置对象是否可以保存
bool is_savable()	判断本对象自身是否可以保存
map query_self_save_dbase()	获得自身的存盘数据（常驻数据加上动态组件对象的常驻数据词典）
bool save_sync()	存盘（异步阻塞操作）
void save_async(function callback = nil)	存盘（异步非阻塞操作）
void drop(string reason)	销毁本对象（永久销毁，从数据库删除）
int ping_save()	调试接口：测试保存操作的延迟时长
map query_save_dbases()	获取自己包括自己所有子节点的存盘数据词典
bool save_self()	保存自身数据（不包括子节点，异步阻塞操作）
void save_self_async(function callback)	保存自身数据（不包括子节点，异步非阻塞操作）
void prev_drop_self(string reason)	虚函数：销毁自身时的前处理
void set_dropped_for_reason(string reason)	标记自身为已销毁并记录销毁原因
void drop_self(string reason)	销毁自身
bool check_savable()	检查本对象以及祖先节点是否可以保存
bool gridfs_save_sync()	存盘（GridFS模式，异步阻塞操作）
void gridfs_drop(string reason)	销毁本对象（GridFS模式，永久销毁，从数据库删除）

FSendNotify.gs

格式化通知消息的发送组件

函数原型	函数作用
void show_tip(string msg, ...)	发送提示信息
void show_error(string msg, ...)	发送错误信息
void show_error_code(mixed err, string type = nil)	发送错误编号和错误类型
void show_unknown_error(string err, string type = nil)	发送未知错误
void show_log_or_tip(string type, string msg, ...)	发送日志或者提示
void show_tip_box(string msg, ...)	发送提示弹窗
void show_title_tip(string msg, ...)	发送提示标题
void show_tip_code(mixed data, string type = nil, string color = nil)	发送提示编号
void show_tip_code_array(array data, string color = nil)	发送一组提示编号

FService.gs

服务组件

提供基础的串行事务处理
支持异步阻塞操作和异步非阻塞操作

函数原型	函数作用
void set_option(map option)	设置选项
void check_queue()	服务队列自检
mixed process_sync(function func, float timeout = 3, bool timeout_error = true)	处理一个同步请求（异步阻塞操作）
void process_async(function func, function callback = nil)	处理一个异步请求（异步非阻塞操作）

FTick.gs

执行耗时统计的计时组件

函数原型	函数作用
void begin_tick(string name)	开始计时
void end_tick(string name)	结束计时
void dump_tick()	调试接口：输出所有计时统计信息

FTimedTask.gs

定时执行的任务

需要自己保证任务执行的唯一性
由心跳机制驱动定时任务的执行，因此使用者需要在心跳函数中主动执行update_timed_tasks()驱动定时任务

函数原型	函数作用
void on_once_task(string task_id, function func)	创建一个一次性执行的任务
void on_day_task(string task_id, function func, int hour = 0, int minute = 0, int second = 0)	创建一个每天定时执行的任务
void on_week_task(string task_id, function func, int wday = 1, int hour = 0, int minute = 0, int second = 0)	创建一个每周定时执行的任务
void on_fixed_task(string task_id, function func, int fixed_seconds)	创建一个固定时长间隔执行的任务
void on_timed_task(string task_id, TimedTask timed_task)	创建一个自定义的定时执行的任务
void set_timed_task_update_interval(int interval)	设置定时任务的驱动间隔
void update_timed_tasks(int now)	驱动执行定时任务

FUserCmd.gs

客户端用户命令执行器基础组件

函数原型	函数作用
bool FCmdHandlerBase.verify_cmd(object user)	检查目标对象是否能执行客户端用户命令

FUserFastRelogin.gs

用户快速重连组件

默认不开启，需要手动调用set_login_relogin_enabled(秒数)开启

函数原型	函数作用
bool fast_relogin(mixed msg_seq)	快速重连
bool is_fast_relogin_data(mixed data)	检查网络消息数据是不是快速重连机制需要处理的消息
void fast_relogin_send_raw(mixed data)	快速重连模式下，执行发送网络消息
bool is_fast_relogin_enabled()	检查是不是启用了快速重连机制
void set_fast_relogin_enabled(int seconds)	启用快速重连机制

AttribD.gs

属性模块

本模块启动时自动加载名称为attrib、attrib_sources、attrib_affix的配置文件
本模块启动时自动加载名称为std_attrib的曲线配置文件

函数原型	函数作用
void load_configs()	加载配置表
map get_attrib(string name)	获取指定名称的属性配置信息
array get_attribs()	获取所有属性配置信息列表
array get_attrib_sources()	获取所有属性来源列表
map get_attrib_affixs()	获取所有属性词条词典
map get_attrib_affix_info(mixed id)	获取属性词条配置信息
array gen_attrib_affix_data(mixed id, int lv)	根据等级生成指定词条id的标准曲线数据
int get_std_attrib_val(string attrib, int lv)	根据等级获取指定属性的标准曲线属性值

CurveD.gs

曲线模块

加载曲线配置文件并创建曲线对象
本模块自动加载名称为curve的曲线配置文件

函数原型	函数作用
object load_curve(string file)	创建曲线对象（曲线对象加载指定的曲线配置文件）
int get_curve_length(string name)	获取curve表中指定名称的曲线值列表大小
array get_curve(string name)	获取curve表中指定名称的曲线值列表
mixed get_curve_val(string name, int index)	获取curve表中指定名称指定索引位置的曲线值

DomainD.gs

域管理模块

域优先级的管理（实际已经不使用）
域的分配和创建

函数原型	函数作用
void set_entity_domain_manager(object ob)	设置实体对象的域管理对象
int get_ob_level(string file)	获取对象对应的域优先级
int get_daemon_level(string file)	获取常驻功能模块对应的域优先级
int get_entity_level(int class_id)	获取实体对象对应的域优先级
domain create_entity_domain(int class_id, ...)	通过域管理器为指定class id的实体分配域
void release_entity_domain(object entity_ob)	回收分配给指定实体对象的域

EntityFactory.gs

实体对象工厂

主要功能就是创建实体对象
实体对象一般是指包含了FEntity组件或者FLightEntity组件的对象

函数原型	函数作用
object create_light_entity(string type, string id, map dbase = , domain d = nil)	创建一个轻量级实体对象
object create_entity(mixed class_id_or_alias, map dbase = , domain d = nil, bool new_create = true)	创建一个实体对象
object create_entity_by_creator(EntityCreatorBase creator)	使用实体对象构造器实例创建一个实体对象
object clone_entity(object from_entity)	复制一个实体对象
object load_entity(map condition, domain d = nil, string db_collection = "entity")	从mongodb数据库中加载一个实体对象
object load_entity_by_dbase(map dbase, domain d = nil)	从指定的实体数据中加载一个实体对象
object load_entity_by_rid(string rid, domain d = nil, string db_collection = "entity")	从mongodb的数据集合中加载一个指定rid的实体对象
void load_child_entities(object ent)	加载指定实体对象的所有子对象
void load_partial_child_entities(object ent, array child_rids)	加载指定实体对象的部分子对象
object load_entity_from_dbases(string rid, domain d, map ro_dbases)	从常驻数据词典中恢复实体对象及其子孙对象
object load_entity_from_gridfs(string db_collection, string rid, domain d = nil)	从mongo数据库的gridfs形式数据集合中加载指定rid的实体对象

FieldsD.gs

字段管理模块

对象的字段列表来自:
1. 静态配置(来自fields.xlsx)
1. 动态设置(来自FieldsD.add_type_field/fields系列接口)
字段类型包含以下几种:
1.对象组件同名的字段类型(例如type为FEntity的字段列表)
2.对象同名的字段类型(例如type为User的字段列表)
3.对象get_field_type()指定的字段类型(例如type为user)

函数原型	函数作用
void dump_ob_fields(string ob_file = nil)	调试接口: 输出对象文件对应的字段信息
void add_type_field(string type, string field_name, mixed privileges = ["self"])	为指定的字段类型的指定字段增加一组权限
void add_type_fields(string type, mixed fields, ...)	为指定的字段类型增加一组字段
void remove_type_field(string type, string field_name, mixed privilege = nil)	为指定的字段类型移除指定字段的指定权限
void remove_type_fields(string type, map fields)	为指定的字段类型移除一组指定字段的指定权限
Field get_ob_field(object ob, string field_name)	获取目标对象的指定字段
void refresh_ob_fields(string field_type = nil)	刷新指定字段类型的字段集合
FieldSet get_ob_fields(object ob)	获取目标对象的所有字段集合

GameSettingsD.gs

游戏配置模块

提供游戏配置数据的模块
本对象启动时载入游戏配置表game_settings

函数原型	函数作用
mixed get(mixed key)	获取游戏配置值

GlobalFunctionD.gs

全局函数模块

提供一些通用的全局函数（看了一下，现有的全局函数没什么用，考虑后续移除）

函数原型	函数作用
void catch_error(...)	抛出并捕获错误（没有必要用这个方法，就是catch(error(...)）
domain find_or_create_domain(string name)	查找或创建指定名称的域，如果没有则创建（没有必要用这个方法，就是domain.create(name, false)）
map array_classify_by_key(array lst, string key)	将列表中的词典元素通过某个指定的键值分类成map（一眼看不出来是这么绕的功能，不推荐使用）

GmD.gs

GM功能模块

在全局配置中的[check_gm_privilege]配置为true时，必定检查权限
在全局配置中的[check_gm_privilege]配置为false时，如果是windows系统，则不检查权限
在全局配置中的[check_gm_privilege]配置为false时，如果是非windows系统，则必定检查权限

函数原型	函数作用
void load_gm_entries(string path)	加载指定路径下的GM命令处理器
mixed run_command(string gm_cmd, object user, array args)	执行GM命令处理器

HeartbeatD.gs

心跳模块

在模块载入时自动创建一个默认的全局共享的心跳对象

函数原型	函数作用
object get_heart()	获取全局共享的心跳对象

InvokeScriptD.gs

外部脚本执行模块

函数原型	函数作用
void set_base_path(string path)	设置外部脚本所在的路径
void load_all_scripts()	载入所有外部脚本
void clear()	清空所有外部脚本函数缓存
void clear_cache(string name)	清空指定名称的外部脚本函数缓存
function get_or_create(string name, bool error_if_not_exist)	获取或者创建指定名称的外部脚本函数
mixed assure_invoke(string name, ...)	执行指定名称的外部脚本函数，如果不存在则抛出错误
mixed invoke(string name, ...)	执行指定名称的外部脚本函数，如果不存在则忽略
mixed invoke_any(array names, ...)	执行指定名称列表里的一个外部脚本函数（成功执行一个就退出）

ItemD.gs

游戏道具功能模块

函数原型	函数作用
array can_cost(object user, map items, string baggage_name = nil)	检查是否能从指定背包里扣除道具
array can_cost_by_quality(object user, map items, string baggage_name = nil)	检查是否能从指定背包里扣除指定品质/数量的道具
array cost_items_by_quality(object user, map items, string reason, string baggage_name = nil)	从指定背包里扣除指定品质的道具
array cost_items_by_class_id_and_quality(object user, map items, string reason, string baggage_name = nil)	从指定背包里扣除指定品质的道具（和cost_items_by_quality相同）
int use_item(object user, object item, string reason, mixed use_type = nil, mixed dbase = nil)	使用道具
array select_combinable(mixed item_info, int combinable, domain d)	拆分可堆叠的道具（函数名莫名奇妙，一眼看不出来是什么功能）

LocalizedTextD.gs

已经本地化的文本管理模块

本模块启动时自动加载本地化文本配置表localized_text
文本的本地项目化大概功能如下:
1.在需要的地方使用id来指代特定的文本;
一个目的是:项目游戏层就可以通过指定id对应的文本来自定义提示内容等等
2.id可以使用字符串或者数字
推荐使用前缀 + 数字的格式: UserD.001
3.默认自动加载/etc/localized_text.xlsx;其中,localized_text.xlsx必须包含id和text字段;
4.通过全局函数__L()引用本地项目化的文本;例如:__L("login.001")或者__L("login.001", "认证失败")
5.本地化文本的增加或者输出请见Functions.gs里的batch_add_localized_text/batch_remove_localized_text/dump_all_localized_text等方法

函数原型	函数作用
string get_text(mixed id)	通过文本id获取文本内容
void dump_all_localized_text()	调试接口，显示所有本地化文本
void batch_add_localized_text(map dict)	批量添加本地化文本
void batch_remove_localized_text(array ids)	批量移除本地化文本

LogD.gs

游戏日志功能模块提供基础的日志记录功能，记录到mongodb数据库

可丢弃日志操作列表:

在进入队列之前直接根据日志操作名称进行过滤(配置项为log_policy/discardable_ops)

日志策略类型:

intercept: 完全由游戏层拦截

pass: 游戏层处理模块返回true时完全拦截，否则engine层也将处理

其他: 游戏层不处理

日志策略配置例子:

"log_policy" : {
"policy" : "intercept",  // 策略类型
"threshold" : 100,       // 日志队列阈值
"max_flush_count" : 2000, // 每批次处理日志数量
"handler" : {
"default" : "default",  // 默认拦截模块的名称
"paths" : [             // 加载的拦截模块路径
"/game/game_logs/",
],
},
"op_collections" : { // 不同日志操作对应的集合;如果未指定时，默认记录在集合"logs"里
"login_ok" : "login_ok",
"new_char" : "new_char",
"online_duration" : "online_duration"
}
}```


|函数原型|函数作用|
| -- | -- |
|[void start_log()](./game_server.engine/daemons/LogD/start_log.md)|启动日志|
|[void enable_intercept(map handler_cfg = {})](./game_server.engine/daemons/LogD/enable_intercept.md)|启用日志拦截策略|
|[void disable_intercept()](./game_server.engine/daemons/LogD/disable_intercept.md)|关闭日志拦截策略|
|[void enable_mongodb()](./game_server.engine/daemons/LogD/enable_mongodb.md)|启用写入MongoDB日志（仅在游戏使用MongoDB数据库时有效）|
|[void disable_mongodb()](./game_server.engine/daemons/LogD/disable_mongodb.md)|关闭写入MongoDB日志|
|[void refresh_coll()](./game_server.engine/daemons/LogD/refresh_coll.md)|刷新MongoDB数据库的日志集合（仅在已开启写入MongoDB日志时有效）|
|[void flush_log()](./game_server.engine/daemons/LogD/flush_log.md)|批量写入一次日志队列里的日志（最大MAX_FLUSH_COUNT条）|
|[void write_logs_sync(array logs)](./game_server.engine/daemons/LogD/write_logs_sync.md)|写入一组日志（行为受日志策略影响）|
|[void log(string rid, string op, mixed v1 = nil, mixed v2 = nil, mixed v3 = nil, mixed v4 = nil, mixed misc = nil)](./game_server.engine/daemons/LogD/log.md)|记录日志（仅发送到日志队列中）|
|[void log_sync(string rid, string op, mixed v1 = nil, mixed v2 = nil, mixed v3 = nil, mixed misc = nil)](./game_server.engine/daemons/LogD/log_sync.md)|记录日志（不经过日志队列，由当前协程直接写入直至完成）|
|[void set_policy(string policy, map handler_cfg = {})](./game_server.engine/daemons/LogD/set_policy.md)|设置日志处理策略|
|[string get_collection_name_by_op(string op)](./game_server.engine/daemons/LogD/get_collection_name_by_op.md)|通过日志操作名称获取对应的mongodb数据库里日志数据集合名称|
|[void add_discardable_op(string op)](./game_server.engine/daemons/LogD/add_discardable_op.md)|将指定的日志操作名称添加到可丢弃日志操作列表里|
|[void remove_discardable_op(string op)](./game_server.engine/daemons/LogD/remove_discardable_op.md)|从可丢弃日志操作列表里移除指定的日志操作名称|
|[void dump_counter()](./game_server.engine/daemons/LogD/dump_counter.md)|调试接口：输出日志计数信息|


### LoginD.gs
玩家登录登出功能模块

* 登录和登出不使用登录锁,而是基于LoginQueueD提供的登录队列进行处理
* 规则: 相同的账号的登录或者登出请求在相同的LoginQueueD登录队列中顺序执行
* 登出的时候不需要再锁定用户数据的原因是:
*  FSave组件里，同一个用户的存盘操作是队列顺序执行的;
* 因此不再存在自动存盘和登出的数据存盘在不同的协程中处理的问题;


|函数原型|函数作用|
| -- | -- |
|[void set_auth_mod(object mod)](./game_server.engine/daemons/LoginD/set_auth_mod.md)|设置执行登录认证的模块对象|
|[object get_auth_mod()](./game_server.engine/daemons/LoginD/get_auth_mod.md)|获取执行登录认证的模块对象|
|[void add_white_list(string account)](./game_server.engine/daemons/LoginD/add_white_list.md)|将指定账号添加到登录白名单列表中|
|[void clear_white_list()](./game_server.engine/daemons/LoginD/clear_white_list.md)|清空账号登录白名单列表|
|[map get_white_list()](./game_server.engine/daemons/LoginD/get_white_list.md)|获取账号登录白名单列表|
|[void set_reject_reason(string reason)](./game_server.engine/daemons/LoginD/set_reject_reason.md)|设置拒绝登录的原因|
|[string get_reject_reason()](./game_server.engine/daemons/LoginD/get_reject_reason.md)|获取拒绝登录的原因|
|[mixed auth(string account, string pass_md5, map auth_args)](./game_server.engine/daemons/LoginD/auth.md)|执行一次客户端的认证请求|
|[mixed check_auth(map login_data)](./game_server.engine/daemons/LoginD/check_auth.md)|执行登录令牌的认证请求（请求通过后移除登录令牌）|
|[mixed check_repeatable_auth(map login_data)](./game_server.engine/daemons/LoginD/check_repeatable_auth.md)|执行登录令牌的可重复性认证请求（请求通过后不移除登录令牌）|
|[object get_or_create_login_ob(object conn, string account, string account_id)](./game_server.engine/daemons/LoginD/get_or_create_login_ob.md)|获取或创建一个登录对象（不存在时创建）|
|[object create_login_ob(object conn, string account, string account_id)](./game_server.engine/daemons/LoginD/create_login_ob.md)|创建登录对象|
|[void do_login_in_co(object conn, LoginContext context, function callback = nil)](./game_server.engine/daemons/LoginD/do_login_in_co.md)|在登录协程中执行账号登录|
|[void login_success(object user)](./game_server.engine/daemons/LoginD/login_success.md)|登录成功后的处理|
|[int get_logging_in_num()](./game_server.engine/daemons/LoginD/get_logging_in_num.md)|获取登录中的人数|
|[bool wait_until_no_logging_in()](./game_server.engine/daemons/LoginD/wait_until_no_logging_in.md)|等待直到登录中的人数为0|
|[void login(object conn, LoginContext context, function callback = nil)](./game_server.engine/daemons/LoginD/login.md)|发起登录请求（异步非阻塞）|
|[bool logout(object user, function callback)](./game_server.engine/daemons/LoginD/logout.md)|发起登出请求（异步非阻塞）|
|[void enable_debug_login(bool flag)](./game_server.engine/daemons/LoginD/enable_debug_login.md)|允许或者禁止调试登录|
|[void enable_gm_login(bool flag)](./game_server.engine/daemons/LoginD/enable_gm_login.md)|允许或者禁止gm登录|
|[void enable_login(bool flag)](./game_server.engine/daemons/LoginD/enable_login.md)|允许或者禁止登录|
|[bool is_debug_login_enabled()](./game_server.engine/daemons/LoginD/is_debug_login_enabled.md)|调试登录是否开启|
|[bool is_gm_login_enabled()](./game_server.engine/daemons/LoginD/is_gm_login_enabled.md)|gm登录是否开启|
|[bool is_login_enabled()](./game_server.engine/daemons/LoginD/is_login_enabled.md)|登录是否开启|
|[bool check_login_privilege(mixed gm_privilege = nil)](./game_server.engine/daemons/LoginD/check_login_privilege.md)|检查指定的权限是否允许登录|
|[void add_login_hook(string name, function func)](./game_server.engine/daemons/LoginD/add_login_hook.md)|增加登录成功时执行的回调函数|
|[void delete_login_hook(string name)](./game_server.engine/daemons/LoginD/delete_login_hook.md)|删除指定名称的登录成功时执行的回调函数|
|[void set_login_cost_warning_threshold(int seconds)](./game_server.engine/daemons/LoginD/set_login_cost_warning_threshold.md)|设置登录耗时警告阈值|
|[int get_login_cost_warning_threshold()](./game_server.engine/daemons/LoginD/get_login_cost_warning_threshold.md)|获取登录耗时警告阈值|
|[bool is_login_cost_warning_enabled()](./game_server.engine/daemons/LoginD/is_login_cost_warning_enabled.md)|检查是否开启登录耗时警告|
|[void invoke_login_hook(object user)](./game_server.engine/daemons/LoginD/invoke_login_hook.md)|执行登录成功时的所有回调函数|
|[object debug_login(object conn, string account, string account_id = nil)](./game_server.engine/daemons/LoginD/debug_login.md)|执行调试登录（异步阻塞模式）|


### LoginQueueD.gs
登录队列模块
* 登录队列
* 同时登录人数过多时排队
* 所有登录请求通过LoginQueueD.enqueue()来做
* 服务器会动态每过一段时间给连接发送排队状态
* 几个协程:
* 1. 登录请求分发协程
* 2. 登录处理协程池
* 3. 登录请求排队情况更新处理协程
* LoginRequestBase说明:
* enqueue: 将普通优先级的登录请求加入队列中，并且有排队序号
* prioprity_enqueue:将高优先级的登录请求加入队列中，没有排队序号
* smart_enqueue: 将登录请求加入队列中，没有排队序列号
* 其它:
* LoginRequestBase
*  invoke_func的返回值将做为post_invoke_func的参数
*  service_id: 登录请求的service id一般是账号的hash值(account.to_lower().hash()),这样通过对_LOGIN_CO_NUM取模，
*              保证相同账号的请求被分发到相同的处理协程中处理，这样登录登出操作可以不使用额外的登录锁来保证多协程安全
*  invoke_domain: invoke_func绑定的执行域
*  args: invoke_func的参数列表
*  is_priority: 是否为高优先级


|函数原型|函数作用|
| -- | -- |
|[void dump()](./game_server.engine/daemons/LoginQueueD/dump.md)|调试接口：输出调试信息|
|[bool check_login_co()](./game_server.engine/daemons/LoginQueueD/check_login_co.md)|检查当前协程是否为登录协程|
|[void enqueue(object conn, ...)](./game_server.engine/daemons/LoginQueueD/enqueue.md)|投递登录处理请求|
|[void priority_enqueue(object conn, LoginContext context, ...)](./game_server.engine/daemons/LoginQueueD/priority_enqueue.md)|投递优先登录处理请求|
|[void smart_enqueue(LoginRequestBase login_request)](./game_server.engine/daemons/LoginQueueD/smart_enqueue.md)|智能投递登录处理请求|
|[bool dequeue(int seq)](./game_server.engine/daemons/LoginQueueD/dequeue.md)|从待处理词典中移除指定排队序号的登录处理请求|
|[int get_login_queue_size()](./game_server.engine/daemons/LoginQueueD/get_login_queue_size.md)|获取登录处理请求队列的长度|
|[bool wait_until_queue_empty(int timeout = 60)](./game_server.engine/daemons/LoginQueueD/wait_until_queue_empty.md)|等待直至登录请求处理队列为空|
|[void set_debug_login_pending_time(float t)](./game_server.engine/daemons/LoginQueueD/set_debug_login_pending_time.md)|调试接口：设置之情登录处理请求的延迟时长|


### QualityD.gs
道具品质模块
* 本模块启动时加载配置表quality


|函数原型|函数作用|
| -- | -- |
|[string default_quality()](./game_server.engine/daemons/QualityD/default_quality.md)|获取默认品质|
|[int all_quality_count()](./game_server.engine/daemons/QualityD/all_quality_count.md)|获取品质数量|
|[array get_all_quality_names()](./game_server.engine/daemons/QualityD/get_all_quality_names.md)|获取所有品质名称列表|
|[map get_quality_info(string quality)](./game_server.engine/daemons/QualityD/get_quality_info.md)|通过品质获取配置信息|
|[int get_quality_index(string quality)](./game_server.engine/daemons/QualityD/get_quality_index.md)|获取品质的索引编号|
|[string get_quality_name(int quality_idx)](./game_server.engine/daemons/QualityD/get_quality_name.md)|通过品质的索引编号获取品质|
|[mixed get_quality_value(string quality, string key)](./game_server.engine/daemons/QualityD/get_quality_value.md)|获取指定品质的配置信息的指定键值|


### RewardD.gs
奖励发放功能模块
* 本模块启动时自动加载配置表reward


|函数原型|函数作用|
| -- | -- |
|[array get_rewards(string reward_type)](./game_server.engine/daemons/RewardD/get_rewards.md)|获取指定奖励类型的奖励数据列表|
|[map generate_reward_data(map r, mixed extra_data = nil)](./game_server.engine/daemons/RewardD/generate_reward_data.md)|生成格式化的奖励数据|
|[map format_reward_data(map r, mixed extra_data = nil)](./game_server.engine/daemons/RewardD/format_reward_data.md)|格式化奖励数据|
|[array generate_random_reward_data(string reward_type, int num, string reason = "reward", mixed entity_or_rid = nil, mixed extra_data = nil)](./game_server.engine/daemons/RewardD/generate_random_reward_data.md)|虚函数：随机生成指定奖励类型的奖励数据列表|
|[array random_reward(object entity, string reward_type, int num, string reason = "reward", mixed extra_data = nil, string reward_target = "baggage", float defer_time = 0)](./game_server.engine/daemons/RewardD/random_reward.md)|执行随机发放指定类型的奖励|
|[void reward(object entity, mixed rewards, string reason = "reward", mixed extra_data = nil, string reward_target = "baggage", float defer_time = 0)](./game_server.engine/daemons/RewardD/reward.md)|执行发放指定的奖励|
|[void reward_attrib(object entity, string name, int val, string reason)](./game_server.engine/daemons/RewardD/reward_attrib.md)|执行属性奖励|
|[array reward_property(object entity, map property_data, string reason, mixed extra_data = nil, string reward_target = "baggage")](./game_server.engine/daemons/RewardD/reward_property.md)|执行道具奖励|


### RidD.gs
rid模块
* 管理所有拥有Rid的对象实例，并提供全局注册查找的API
* 支持rid的生成
* 支持通过rid查找对象（对象需要提供get_rid()方法）


|函数原型|函数作用|
| -- | -- |
|[string new_rid(string prefix)](./game_server.engine/daemons/RidD/new_rid.md)|生成指定前缀的rid|
|[void add_object(object ob)](./game_server.engine/daemons/RidD/add_object.md)|登记对象，增加rid到对象的映射关系|
|[void remove_object(object ob)](./game_server.engine/daemons/RidD/remove_object.md)|移除对象，移除rid到对象的映射关系|
|[object find_object_by_rid(string rid)](./game_server.engine/daemons/RidD/find_object_by_rid.md)|通过rid查找对象|


### RoomD.gs
房间模块
* 底层房间管理
* 维护服务器中所有房间
* 只提供一些基础的增删查改功能
* 上层有更多需求需要自定封装房间相关的管理器和模块
*  提供一个预创建的房间列表
* 本模块启动时加载配置表init_rooms


|函数原型|函数作用|
| -- | -- |
|[array get_all_room_obs()](./game_server.engine/daemons/RoomD/get_all_room_obs.md)|获取所有房间对象列表|
|[void drop_room(object room, string reason)](./game_server.engine/daemons/RoomD/drop_room.md)|销毁房间对象（和房间对象的drop接口一样）|
|[object create_room(mixed class_id_or_alias, map param = {})](./game_server.engine/daemons/RoomD/create_room.md)|创建房间对象（和EntityFactory.create_entity是一样的）|
|[object get_room(string room_rid)](./game_server.engine/daemons/RoomD/get_room.md)|通过rid获取房间对象|
|[void add_room(object room)](./game_server.engine/daemons/RoomD/add_room.md)|登记房间对象|
|[void remove_room(object room)](./game_server.engine/daemons/RoomD/remove_room.md)|移除房间对象（不销毁房间对象）|
|[void list_rooms(bool deep = false)](./game_server.engine/daemons/RoomD/list_rooms.md)|列出所有房间对象|
|[void init_public_rooms()](./game_server.engine/daemons/RoomD/init_public_rooms.md)|初始化所有公共房间对象|
|[object get_public_room(mixed room_id)](./game_server.engine/daemons/RoomD/get_public_room.md)|通过配置的id获取公共房间对象|
|[object find_public_room(function func)](./game_server.engine/daemons/RoomD/find_public_room.md)|获取符合指定条件的公共房间对象|
|[void iterate_public_rooms(function func)](./game_server.engine/daemons/RoomD/iterate_public_rooms.md)|遍历所有公共房间|
|[object create_public_room(mixed room_id)](./game_server.engine/daemons/RoomD/create_public_room.md)|创建公共房间对象|


### SystemD.gs
系统模块
* 支持事件
* 支持安全关机功能
* 关联的系统配置选项字段有：
* 1. server_id：服务器ID （int）
* 2: host: 主机地址（string）
* 3: port: 端口地址（int）
* 4: server_info: 服务器其它信息（map）
* 5: product_name: 产品名称（string）


|函数原型|函数作用|
| -- | -- |
|[void shutdown(map info = nil, bool kill_self = true)](./game_server.engine/daemons/SystemD/shutdown.md)|安全关机（异步非阻塞接口）|
|[bool is_shutting_down()](./game_server.engine/daemons/SystemD/is_shutting_down.md)|是否正在执行关机|
|[void set_booting(bool booting)](./game_server.engine/daemons/SystemD/set_booting.md)|设置是否正在执行启动|
|[bool is_booting()](./game_server.engine/daemons/SystemD/is_booting.md)|是否正在执行启动|
|[void set_shuting_down(bool flag)](./game_server.engine/daemons/SystemD/set_shuting_down.md)|设置是否正在执行关机|
|[string get_server_id()](./game_server.engine/daemons/SystemD/get_server_id.md)|获取服务器id|
|[string get_server_host()](./game_server.engine/daemons/SystemD/get_server_host.md)|获取服务器主机地址|
|[int get_server_port()](./game_server.engine/daemons/SystemD/get_server_port.md)|获取服务器主机端口|
|[string get_server_name()](./game_server.engine/daemons/SystemD/get_server_name.md)|获取服务器名称|
|[map get_server_info()](./game_server.engine/daemons/SystemD/get_server_info.md)|获取服务器信息|
|[bool register_hook(string op, function func, bool call_if_exist = false)](./game_server.engine/daemons/SystemD/register_hook.md)|注册系统事件回调函数|
|[void unregister_hook(string op, string listener, bool check_exist = true)](./game_server.engine/daemons/SystemD/unregister_hook.md)|注销系统事件的回调函数|
|[array get_hooks(string op)](./game_server.engine/daemons/SystemD/get_hooks.md)|获取系统事件的回调函数列表|
|[void invoke_hooks(string op, ...)](./game_server.engine/daemons/SystemD/invoke_hooks.md)|执行系统事件的所有回调函数|
|[void on_post_boot(function func, bool call_if_exist = true)](./game_server.engine/daemons/SystemD/on_post_boot.md)|注册系统事件"system_post_boot"的回调函数|
|[void on_shutdown(function func)](./game_server.engine/daemons/SystemD/on_shutdown.md)|注册系统事件"system_shutdown"的回调函数|


### TelnetD.gs
远程telnet到玩家客户端的模块
* 支持通过服务器的telnet会话远程telnet到玩家客户端
* engine里配合本模块功能的命令处理器为run_command.gs


|函数原型|函数作用|
| -- | -- |
|[void notify_result(object user_ob, string result)](./game_server.engine/daemons/TelnetD/notify_result.md)|向游戏服务器汇报执行结果|
|[void notify_print(object user_ob, string result)](./game_server.engine/daemons/TelnetD/notify_print.md)|向游戏服务器汇报需要显示的信息|
|[void telnet_to_user(string rid, bool flag_togs = true)](./game_server.engine/daemons/TelnetD/telnet_to_user.md)|从当前的游戏服务器telnet控制台远程telnet到目标玩家的客户端|
|[void telnet_to_server()](./game_server.engine/daemons/TelnetD/telnet_to_server.md)|从telnet到目标玩家的客户端退出返回当前服务器telnet会话|


### TickD.gs
简单的性能测试和调试模块
* 功能过于简单了，没什么用


|函数原型|函数作用|
| -- | -- |
|[void init_tick_time(array data)](./game_server.engine/daemons/TickD/init_tick_time.md)|开启计时|
|[void tick_time(string name, array data)](./game_server.engine/daemons/TickD/tick_time.md)|结束计时|
|[void record_mem()](./game_server.engine/daemons/TickD/record_mem.md)|输出各种handle数量|


### TraceD.gs
trace信息功能模块
*  trace分为两个维度，一个维度为模块(module)，另一个维度为对象(object)
* 这么设计的原因是我们希望尽可能多地输出trace信息，但又不希望在一些
* 情况下被trace信息给淹没
* 有些模块被调用得非常频繁，比如行走、AI、技能等接口
* 有些对象身上的方法也会被调用得非常频繁，如拾取、交互、攻击等行为
* 但这些调用频繁的接口我们也希望有trace信息，在追查问题或调试的时候
* 方便我们知道整个系统运作的流程和顺序
* 如果像以前那样，只能屏蔽某个模块的trace，我们玩家身上被频繁调用的行为
* 就没办法trace了，否则在玩家数量多的时候会被trace信息给淹没的
* 因此我们增加一个object维度来控制trace的开关，这样一来，某些玩家/怪物
* 被调用非常平凡的方法也能trace，一般我们应该object的trace关闭，当我们
* 关注某个对象，希望看到它的一些详细诊断信息的时候再打开


|函数原型|函数作用|
| -- | -- |
|[void set_module_trace_mode(bool black_list_mode)](./game_server.engine/daemons/TraceD/set_module_trace_mode.md)|设置模块的trace输出模式|
|[void enable_module_trace(string module, bool enable)](./game_server.engine/daemons/TraceD/enable_module_trace.md)|开启或者关闭指定模块的trace|
|[void enable_object_trace(object ob, bool enable)](./game_server.engine/daemons/TraceD/enable_object_trace.md)|开启或者关闭指定对象的trace|
|[void set_trace_all(bool enable)](./game_server.engine/daemons/TraceD/set_trace_all.md)|设置是否强制开启所有的trace|
|[void set_silence(bool silence = true)](./game_server.engine/daemons/TraceD/set_silence.md)|设置是否强制不输出所有的trace|
|[bool is_module_trace_enabled(string module)](./game_server.engine/daemons/TraceD/is_module_trace_enabled.md)|判断指定名称的模块是否开启了trace|
|[bool is_object_trace_enabled(object ob)](./game_server.engine/daemons/TraceD/is_object_trace_enabled.md)|判断指定的对象是否开启了trace|
|[void trace_module_message(LogLevel level, string module, string msg, ...)](./game_server.engine/daemons/TraceD/trace_module_message.md)|输出模块的trace信息|
|[void trace_object_message(LogLevel level, string module, object ob, string msg, ...)](./game_server.engine/daemons/TraceD/trace_object_message.md)|输出对象的trace信息|
|[void enable_async_log(bool enable)](./game_server.engine/daemons/TraceD/enable_async_log.md)|设置是否开启异步日志操作|


### UserD.gs
玩家对象管理模块
* 维护所有在线玩家对象和数据
* 提供最基础的user相关逻辑
* 部分逻辑支持invoke_script外部扩展
* 本模块启动时加载配置表user_init


|函数原型|函数作用|
| -- | -- |
|[void check_logout_all_finish(function callback)](./game_server.engine/daemons/UserD/check_logout_all_finish.md)|检查是否所有玩家全部登出，如果是则全部登出则执行回调函数|
|[void logout_all_in_co(function callback = nil)](./game_server.engine/daemons/UserD/logout_all_in_co.md)|登出所有玩家（异步阻塞模式）|
|[void logout_all(function callback = nil)](./game_server.engine/daemons/UserD/logout_all.md)|登出所有玩家（异步非阻塞模式）|
|[void logout_all_sync()](./game_server.engine/daemons/UserD/logout_all_sync.md)|登出所有玩家（异步阻塞模式）|
|[bool mark_logging_out_all(bool is_logout)](./game_server.engine/daemons/UserD/mark_logging_out_all.md)|设置是否正在登出全部玩家|
|[bool is_logging_out_all()](./game_server.engine/daemons/UserD/is_logging_out_all.md)|是否正在登出全部玩家|
|[void save_all_users()](./game_server.engine/daemons/UserD/save_all_users.md)|保存所有玩家数据|
|[void add_user(object user)](./game_server.engine/daemons/UserD/add_user.md)|登记玩家对象|
|[void remove_user_and_callback(object user, function callback = nil)](./game_server.engine/daemons/UserD/remove_user_and_callback.md)|注销用户对象，如果用户列表为空则执行全部登出完成时的回调函数|
|[void remove_user(object user)](./game_server.engine/daemons/UserD/remove_user.md)|注销用户对象|
|[void add_account_user(string account_id, string rid)](./game_server.engine/daemons/UserD/add_account_user.md)|增加一个数字id账号和角色rid的对应关系|
|[bool del_account_user(string account_id, string rid)](./game_server.engine/daemons/UserD/del_account_user.md)|移除一个数字id账号和角色rid的对应关系|
|[map get_accounts()](./game_server.engine/daemons/UserD/get_accounts.md)|获取数字id账号和角色rid的映射词典|
|[array get_account_user_rids(string account_id)](./game_server.engine/daemons/UserD/get_account_user_rids.md)|获取指定的数字id账号对应的角色rid列表|
|[map get_user_init_data()](./game_server.engine/daemons/UserD/get_user_init_data.md)|获取玩家对象的初始化配置数据|
|[map new_user_data()](./game_server.engine/daemons/UserD/new_user_data.md)|生成一份新玩家对象的初始化数据|
|[object get_user(string user_rid)](./game_server.engine/daemons/UserD/get_user.md)|通过角色rid获取玩家对象|
|[object debug_find_user(string name_or_account)](./game_server.engine/daemons/UserD/debug_find_user.md)|调试接口：通过玩家名称或者玩家账号获取玩家对象|
|[array get_users(function condition_func = nil)](./game_server.engine/daemons/UserD/get_users.md)|获取所有玩家对象列表|
|[bool lock_user(string user_rid, string lock_reason = "unspecified")](./game_server.engine/daemons/UserD/lock_user.md)|锁定指定角色|
|[bool unlock_user(string user_rid)](./game_server.engine/daemons/UserD/unlock_user.md)|解锁指定角色|
|[bool is_user_locked(string user_rid)](./game_server.engine/daemons/UserD/is_user_locked.md)|判断指定角色是否已被锁定|
|[array is_user_locked_ex(string user_rid)](./game_server.engine/daemons/UserD/is_user_locked_ex.md)|获取指定角色是否被锁定以及锁定原因|
|[map get_locking_users()](./game_server.engine/daemons/UserD/get_locking_users.md)|获取所有被锁定角色rid和锁定原因词典|
|[bool lock_account(string account_id, string lock_reason = "unspecified")](./game_server.engine/daemons/UserD/lock_account.md)|锁定指定的数字id账号|
|[bool unlock_account(string account_id)](./game_server.engine/daemons/UserD/unlock_account.md)|解锁指定的数字id账号|
|[bool is_account_locked(string account_id)](./game_server.engine/daemons/UserD/is_account_locked.md)|判断指定的数字id账号是否被锁定|
|[array is_account_locked_ex(string account_id)](./game_server.engine/daemons/UserD/is_account_locked_ex.md)|获取数字id账号是否被锁定以及锁定原因|
|[void load_user(object user)](./game_server.engine/daemons/UserD/load_user.md)|载入玩家对象|
|[void unload_user_and_save_async(object user, function callback)](./game_server.engine/daemons/UserD/unload_user_and_save_async.md)|保存成功后卸载玩家对象（异步非阻塞模式）|
|[void unload_user(object user)](./game_server.engine/daemons/UserD/unload_user.md)|卸载玩家对象|
|[array delete_user_by_rid(string user_rid, string account_id)](./game_server.engine/daemons/UserD/delete_user_by_rid.md)|删除指定rid和数字id账号的角色|
|[bool is_user_exist_in_db(object mongo_agent, string user_rid)](./game_server.engine/daemons/UserD/is_user_exist_in_db.md)|判断mongo数据库中是否存在指定角色rid的玩家数据|
|[mixed safe_load_or_create_user_sync(string account, string account_id, mixed client_info, map login_aux_data = {}, bool is_robot = false, string user_rid = nil)](./game_server.engine/daemons/UserD/safe_load_or_create_user_sync.md)|安全加载或创建玩家对象（异步阻塞模式）|
|[map list_users()](./game_server.engine/daemons/UserD/list_users.md)|调试接口: 输出所有玩家信息|
|[void drop_user(string rid)](./game_server.engine/daemons/UserD/drop_user.md)|调试接口：删除指定rid的角色数据|
|[void drop_all()](./game_server.engine/daemons/UserD/drop_all.md)|调试接口：删除所有角色数据|
|[void user_login_ok(object user)](./game_server.engine/daemons/UserD/user_login_ok.md)|执行玩家对象登录成功后的处理|
|[void user_lose_connect(object user)](./game_server.engine/daemons/UserD/user_lose_connect.md)|执行玩家对象断开客户端连接时的处理|
|[object get_last_login_user()](./game_server.engine/daemons/UserD/get_last_login_user.md)|调试接口: 获取最近的一个登录成功的玩家对象|
|[int get_users_num()](./game_server.engine/daemons/UserD/get_users_num.md)|获取所有已登录的玩家数量|
|[array get_all_users_ob()](./game_server.engine/daemons/UserD/get_all_users_ob.md)|获取所有玩家对象列表|
|[void disconnect_all_users(string reason = nil)](./game_server.engine/daemons/UserD/disconnect_all_users.md)|通知所有客户端登出并断开所有客户端连接|
|[void set_max_user_num(int num)](./game_server.engine/daemons/UserD/set_max_user_num.md)|设置最大在线人数限制|
|[int get_max_user_num()](./game_server.engine/daemons/UserD/get_max_user_num.md)|获取最大在线人数限制值|
|[void broadcast_sync_time()](./game_server.engine/daemons/UserD/broadcast_sync_time.md)|向所有玩家广播对时消息|
|[void broadcast_all_users(string msg, ...)](./game_server.engine/daemons/UserD/broadcast_all_users.md)|向所有玩家广播网络消息|
|[void iterate_all_users(function func)](./game_server.engine/daemons/UserD/iterate_all_users.md)|遍历所有玩家对象|
|[string dump_user_file(string user_rid, string file_name = nil)](./game_server.engine/daemons/UserD/dump_user_file.md)|保存指定角色rid的数据到目标文件|
|[map load_user_file(string file_name)](./game_server.engine/daemons/UserD/load_user_file.md)|从角色数据的存盘文件中加载玩家数据|
|[object safe_load_user_from_dbases(string user_rid, map dbases)](./game_server.engine/daemons/UserD/safe_load_user_from_dbases.md)|从实体数据集合中安全加载玩家（异步阻塞模式）|
|[string get_user_collection()](./game_server.engine/daemons/UserD/get_user_collection.md)|获取角色数据在mongo数据库里所属的集合名称|


### UserSaveD.gs
玩家存盘统计模块


|函数原型|函数作用|
| -- | -- |
|[void set_enable_speed_stat(bool enable)](./game_server.engine/daemons/UserSaveD/set_enable_speed_stat.md)|设置是否开启存盘速度统计|
|[bool is_enable_save_warning()](./game_server.engine/daemons/UserSaveD/is_enable_save_warning.md)|判断是否开启存盘警告|
|[void set_enable_save_warning(bool enable)](./game_server.engine/daemons/UserSaveD/set_enable_save_warning.md)|设置是否开启存盘警告|
|[void set_warning_save_frequency(int interval_ms, int limit_count, function callback = nil)](./game_server.engine/daemons/UserSaveD/set_warning_save_frequency.md)|设置存盘频率警告阈值|
|[void set_warning_save_cost_threshold(int ms, function callback = nil)](./game_server.engine/daemons/UserSaveD/set_warning_save_cost_threshold.md)|设置存盘耗时消耗警告阈值|
|[void set_warning_wait_cost_threshold(int ms, function callback = nil)](./game_server.engine/daemons/UserSaveD/set_warning_wait_cost_threshold.md)|设置存盘请求等待执行消耗警告阈值|
|[void notify_save_start(SaveStat stat)](./game_server.engine/daemons/UserSaveD/notify_save_start.md)|通知存盘统计开始|
|[void notify_save_stop(SaveStat stat)](./game_server.engine/daemons/UserSaveD/notify_save_stop.md)|通知存盘统计停止|
|[void top_speed(float seconds = 30, float interval = 1, float elasped_seconds = 0)](./game_server.engine/daemons/UserSaveD/top_speed.md)|输出玩家存盘速度统计|


### VersionD.gs
游戏服务器版本管理模块
* 本模块启动时加载配置表/etc/server_version.txt


|函数原型|函数作用|
| -- | -- |
|[string get_version()](./game_server.engine/daemons/VersionD/get_version.md)|获取版本号|
|[void set_version(string v)](./game_server.engine/daemons/VersionD/set_version.md)|设置版本号|
|[void set_enable_check_version(bool enable)](./game_server.engine/daemons/VersionD/set_enable_check_version.md)|设置是否开启版本号检查|
|[bool get_enable_check_version()](./game_server.engine/daemons/VersionD/get_enable_check_version.md)|判断是否开启版本号检查|
|[void load_version()](./game_server.engine/daemons/VersionD/load_version.md)|从版本号文件中载入版本号|
|[void set_check_version_handler(function handler)](./game_server.engine/daemons/VersionD/set_check_version_handler.md)|设置自定义的版本号检查处理函数|
|[bool check_version(string client_version)](./game_server.engine/daemons/VersionD/check_version.md)|检查客户端版本号是否和服务器版本号一致|


### engine.gs


|函数原型|函数作用|
| -- | -- |
|[void boot(map boot_para = {})](./game_server.engine/engine/boot.md)|启动引擎|
|[void set(mixed key, mixed val)](./game_server.engine/engine/set.md)|设置引擎参数|
|[mixed get(mixed key)](./game_server.engine/engine/get.md)|获取引擎的参数值|
|[mixed calc(mixed key, ...)](./game_server.engine/engine/calc.md)|获取或计算引擎的参数值|


### auth.gs
认证模块
* 认证模块
* 默认的简易认证模块，可以在游戏层实现并
* 通过LoginD.set_auth_mod来设置自定义认证模块


|函数原型|函数作用|
| -- | -- |
|[array check_auth(map auth_data)](./game_server.engine/mods/auth/auth/check_auth.md)|处理登录认证请求（检查登录token是否有效）|
|[string auth(string account, string pass_md5, map auth_args)](./game_server.engine/mods/auth/auth/auth.md)|处理客户端的获取登录token请求|


### log_analysis.gs
日志分析模块
* 分析玩家登录登出以及在线日志，统计玩家的留存情况


|函数原型|函数作用|
| -- | -- |
|[mixed get_output(string name, ...)](./game_server.engine/mods/log_analysis/log_analysis/get_output.md)|获取指定名称的日志分析结果|
|[void output_xlsx(string name, ...)](./game_server.engine/mods/log_analysis/log_analysis/output_xlsx.md)|获取指定名称的日志分析结果并输出到xlsx文件|
|[void output(string name, ...)](./game_server.engine/mods/log_analysis/log_analysis/output.md)|获取指定名称的日志分析结果并输出到指控制台|
|[void simple_output(string start_date, int days, int keep_days = 3, string blacklist_file = nil)](./game_server.engine/mods/log_analysis/log_analysis/simple_output.md)|输出基于账号统计的留存分析结果到控制台|
|[void simple_output_xlsx(string start_date, int days, int keep_days = 3, string blacklist_file = nil)](./game_server.engine/mods/log_analysis/log_analysis/simple_output_xlsx.md)|输出基于账号统计的留存分析结果到xlsx文件|
|[void simple_output_by_device_id(string start_date, int days, int keep_days = 3, string blacklist_file = nil)](./game_server.engine/mods/log_analysis/log_analysis/simple_output_by_device_id.md)|输出基于设备id统计的留存分析结果到控制台|
|[void simple_output_xlsx_by_device_id(string start_date, int days, int keep_days = 3, string blacklist_file = nil)](./game_server.engine/mods/log_analysis/log_analysis/simple_output_xlsx_by_device_id.md)|输出基于设备id统计的留存分析结果到xlsx文件|
|[void period_output(string start_date, int days, int keep_days = 3, mixed keep_periods = 240, string blacklist_file = nil)](./game_server.engine/mods/log_analysis/log_analysis/period_output.md)|输出基于账号统计的指定采样区间的留存分析结果到控制台|
|[void period_output_xlsx(string start_date, int days, int keep_days = 3, mixed keep_periods = 240, string blacklist_file = nil)](./game_server.engine/mods/log_analysis/log_analysis/period_output_xlsx.md)|输出基于账号统计的指定采样区间的留存分析结果到xlsx文件|
|[void period_output_by_device_id(string start_date, int days, int keep_days = 3, mixed keep_periods = 240, string blacklist_file = nil)](./game_server.engine/mods/log_analysis/log_analysis/period_output_by_device_id.md)|输出基于设备id统计的指定采样区间的留存分析结果到控制台|
|[void period_output_xlsx_by_device_id(string start_date, int days, int keep_days = 3, mixed keep_periods = 240, string blacklist_file = nil)](./game_server.engine/mods/log_analysis/log_analysis/period_output_xlsx_by_device_id.md)|输出基于设备id统计的指定采样区间的留存分析结果到xlsx文件|


### log_parser.gs
执行日志内容分析处理的模块
* 根据名称执行对应的日志分析功能


|函数原型|函数作用|
| -- | -- |
|[mixed invoke(string name, ...)](./game_server.engine/mods/log_analysis/log_parser/invoke.md)|执行指定名称的日志分析|
|[void output_xlsx(string name, mixed result)](./game_server.engine/mods/log_analysis/log_parser/output_xlsx.md)|将日志分析结果输出为.xlsx文件|
|[void output(string name, mixed result)](./game_server.engine/mods/log_analysis/log_parser/output.md)|将日志分析结果输出到控制台|


### mongo.gs
mongodb数据库功能模块
* 本模块启动时自动加载全局配置字段mongodb值指定的配置文件（如果没有指定则使用默认值/config/mongodb.json）
* mongodb数据库名称将自动带上由全局字段product_name值指定的前缀
* 默认必然有一个配置名称为"base"的数据库
* 数据库名称需要通过format_name方法生成数据库操作对象名称


|函数原型|函数作用|
| -- | -- |
|[void set_db_cfg(map db_cfg)](./game_server.engine/mods/mongo/mongo/set_db_cfg.md)|设置mongodb数据库配置|
|[string get_service_pool_name()](./game_server.engine/mods/mongo/mongo/get_service_pool_name.md)|获取预置协程池的名称|
|[void dispatch_service(function func)](./game_server.engine/mods/mongo/mongo/dispatch_service.md)|将数据库操作投递到预置的协程池中处理|
|[bool dispatch_service_sequential(int hash_value, function func)](./game_server.engine/mods/mongo/mongo/dispatch_service_sequential.md)|将操作派发到有序的协程池中处理|
|[map get_db_colls(string db_name)](./game_server.engine/mods/mongo/mongo/get_db_colls.md)|获取数据库所有集合词典|
|[string format_name(string db_name, string server_id = nil)](./game_server.engine/mods/mongo/mongo/format_name.md)|格式化数据库名称|
|[void start()](./game_server.engine/mods/mongo/mongo/start.md)|模块启动服务|
|[void restart()](./game_server.engine/mods/mongo/mongo/restart.md)|模块重启服务|
|[object get_client(string name)](./game_server.engine/mods/mongo/mongo/get_client.md)|通过格式化的数据库名称获取数据库连接对象|
|[mixed get_config(string key)](./game_server.engine/mods/mongo/mongo/get_config.md)|从名称为"base"的数据库集合configs中获取指定的键值|
|[bool set_config(string key, mixed val)](./game_server.engine/mods/mongo/mongo/set_config.md)|在名称为"base"的数据库集合configs中设置指定的键值|
|[object new_agent(map para = {})](./game_server.engine/mods/mongo/mongo/new_agent.md)|创建一个mongodb数据库操作代理对象|
|[object agent(string name)](./game_server.engine/mods/mongo/mongo/agent.md)|通过名称查找数据库操作代理对象|
|[object local_agent(string db_name)](./game_server.engine/mods/mongo/mongo/local_agent.md)|通过数据库名称查找本地数据库操作代理对象|
|[object base_agent()](./game_server.engine/mods/mongo/mongo/base_agent.md)|获取主数据库的操作代理对象|
|[void drop_all()](./game_server.engine/mods/mongo/mongo/drop_all.md)|调试接口: 丢弃所有数据库里的所有数据集合数据|


### MongoGameAgent.gs
mongodb数据库操作代理对象
* 持有一个指定名称的数据库连接连接对象


|函数原型|函数作用|
| -- | -- |
|[string get_name()](./game_server.engine/mods/mongo/MongoGameAgent/get_name.md)|获取名称|
|[object client()](./game_server.engine/mods/mongo/MongoGameAgent/client.md)|获取数据库连接对象|
|[bool is_write_disable()](./game_server.engine/mods/mongo/MongoGameAgent/is_write_disable.md)|判断是否禁止写入|
|[mixed eval(string script_name, ...)](./game_server.engine/mods/mongo/MongoGameAgent/eval.md)|执行指定名称的脚本|
|[bool is_entity_exist(string rid, string db_collection = "entity")](./game_server.engine/mods/mongo/MongoGameAgent/is_entity_exist.md)|判断指定的数据集合中是否存在指定rid的实体数据|
|[map load_data(map condition, string collection)](./game_server.engine/mods/mongo/MongoGameAgent/load_data.md)|获取指定数据集合中满足条件的单个数据|
|[array load_many_data(map condition, string collection)](./game_server.engine/mods/mongo/MongoGameAgent/load_many_data.md)|获取指定数据集合中满足条件的多个数据|
|[array load_many_data_fields(map condition, array fields, string collection)](./game_server.engine/mods/mongo/MongoGameAgent/load_many_data_fields.md)|获取指定数据集合中满足条件的多个数据，只返回指定字段|
|[bool save_data(map condition, map data, string collection)](./game_server.engine/mods/mongo/MongoGameAgent/save_data.md)|保存数据|
|[bool update_data(map condition, map update_data, string collection)](./game_server.engine/mods/mongo/MongoGameAgent/update_data.md)|更新数据|
|[map load_entity(map condition, string db_collection = "entity")](./game_server.engine/mods/mongo/MongoGameAgent/load_entity.md)|获取指定数据集合中满足条件的单个实体数据|
|[bool save_entity_dict_sync(map dbase_dict, function failure_callback = nil)](./game_server.engine/mods/mongo/MongoGameAgent/save_entity_dict_sync.md)|保存一组实体数据（同步操作）|
|[void save_entity_dict_async(map dbase_dict, function callback = nil, function failure_callback = nil)](./game_server.engine/mods/mongo/MongoGameAgent/save_entity_dict_async.md)|保存一组实体数据（异步非阻塞操作）|
|[bool save_entity_sync(map dbase, string db_collection = "entity")](./game_server.engine/mods/mongo/MongoGameAgent/save_entity_sync.md)|保存单个实体数据（同步操作）|
|[void save_entity_async(map dbase, function callback = nil, string db_collection = "entity")](./game_server.engine/mods/mongo/MongoGameAgent/save_entity_async.md)|保存单个实体数据（异步非阻塞操作）|
|[bool drop_entity_sync(string rid, string db_collection = "entity")](./game_server.engine/mods/mongo/MongoGameAgent/drop_entity_sync.md)|删除单个实体数据（同步操作）|
|[void drop_entity_async(string rid, function callback = nil, string db_collection = "entity")](./game_server.engine/mods/mongo/MongoGameAgent/drop_entity_async.md)|删除单个实体数据（异步操作）|
|[bool replace_many_dbases(map dict, function failure_callback = nil)](./game_server.engine/mods/mongo/MongoGameAgent/replace_many_dbases.md)|覆盖一组数据|
|[array load_entities_by_owner_rid(string rid, string db_collection = "entity")](./game_server.engine/mods/mongo/MongoGameAgent/load_entities_by_owner_rid.md)|获取指定数据集合中指定所有者rid的所有实体数据列表|
|[array load_partial_child_entities(string rid, array children_rids, string db_collection = "entity")](./game_server.engine/mods/mongo/MongoGameAgent/load_partial_child_entities.md)|获取指定数据集合中指定实体rid的指定子实体数据列表|
|[bool update_entity_field(string rid, map fields, string db_collection = "entity")](./game_server.engine/mods/mongo/MongoGameAgent/update_entity_field.md)|更新实体数据字段|
|[int new_id(string type)](./game_server.engine/mods/mongo/MongoGameAgent/new_id.md)|生成一个指定类型的唯一id值|


### FCmdHandlerBase.gs
客户端命令处理器的基础组件
* 所有客户端命令处理器都应该包含本组件
* 所有客户端命令处理器启动时都关联系统配置选项cmd_warning_execution_cost


|函数原型|函数作用|
| -- | -- |
|[string get_cmd()](./game_server.engine/mods/net/FCmdHandlerBase/get_cmd.md)|获取客户端命令名称|
|[bool verify_cmd(object conn_or_user)](./game_server.engine/mods/net/FCmdHandlerBase/verify_cmd.md)|虚函数: 验证连接对象或者玩家对象是否允许执行客户端命令|
|[object get_executor(object conn_or_user)](./game_server.engine/mods/net/FCmdHandlerBase/get_executor.md)|虚函数: 获取命令处理器执行的主体对象（将在主体对象的域上执行）|
|[int get_warning_execution_cost()](./game_server.engine/mods/net/FCmdHandlerBase/get_warning_execution_cost.md)|获取客户端命令执行耗时警告阈值|
|[void set_warning_execution_cost(int ms)](./game_server.engine/mods/net/FCmdHandlerBase/set_warning_execution_cost.md)|设置客户端命令执行耗时警告阈值|


### FMsgHandler.gs
网络服务端对象处理客户端消息的组件


|函数原型|函数作用|
| -- | -- |
|[mixed process_command(object conn_or_user, string cmd, array args)](./game_server.engine/mods/net/FMsgHandler/process_command.md)|处理客户端命令|
|[bool is_deactivated(string cmd)](./game_server.engine/mods/net/FMsgHandler/is_deactivated.md)|判断某个客户端命令是不是被停用了|
|[void deactivate_command(string cmd)](./game_server.engine/mods/net/FMsgHandler/deactivate_command.md)|停用指定的客户端命令处理器|
|[void reactivate_command(string cmd)](./game_server.engine/mods/net/FMsgHandler/reactivate_command.md)|启用指定的客户端命令处理器|
|[void reactivate_all_commands()](./game_server.engine/mods/net/FMsgHandler/reactivate_all_commands.md)|重新启用所有客户端命令处理器|
|[function get_process_command_func(object conn)](./game_server.engine/mods/net/FMsgHandler/get_process_command_func.md)|获取连接对象处理客户端命令的处理函数|


### FServerBase.gs
网络服务端基础组件


|函数原型|函数作用|
| -- | -- |
|[int get_client_heart()](./game_server.engine/mods/net/FServerBase/get_client_heart.md)|客户端连接心跳间隔时长（单位：秒）|
|[array list_connections()](./game_server.engine/mods/net/FServerBase/list_connections.md)|调试接口: 列出所有客户端连接信息|
|[void enable_debug(bool enable)](./game_server.engine/mods/net/FServerBase/enable_debug.md)|调试接口: 设置是否开启调试|
|[bool is_enable_debug(string cmd = nil)](./game_server.engine/mods/net/FServerBase/is_enable_debug.md)|调试接口: 判断指定的客户端命令调试是否开启|
|[void send_daemon()](./game_server.engine/mods/net/FServerBase/send_daemon.md)|发送协程的入口函数|


### FServerConnectionHeart.gs
客户端连接的心跳机制组件
* 提供检测客户端连接心跳的功能：当心跳间隔超过设定值时，判定为心跳丢失


|函数原型|函数作用|
| -- | -- |
|[void update_alive_time()](./game_server.engine/mods/net/FServerConnectionHeart/update_alive_time.md)|更新心跳时间|
|[void set_alive_cd(int alive_cd = 0)](./game_server.engine/mods/net/FServerConnectionHeart/set_alive_cd.md)|设置心跳超时时长（单位：秒）|
|[bool is_alive()](./game_server.engine/mods/net/FServerConnectionHeart/is_alive.md)|检测心跳是否存在|


### MsgStatD.gs
消息统计模块


|函数原型|函数作用|
| -- | -- |
|[bool cmd_stat_on()](./game_server.engine/mods/net/MsgStatD/cmd_stat_on.md)|获取消息统计开启状态|
|[void enable_cmd_stat(int log_interval)](./game_server.engine/mods/net/MsgStatD/enable_cmd_stat.md)|开启消息统计|
|[void disable_cmd_stat()](./game_server.engine/mods/net/MsgStatD/disable_cmd_stat.md)|关闭消息统计|
|[void stat_cmd(string cmd)](./game_server.engine/mods/net/MsgStatD/stat_cmd.md)|统计接收的消息|
|[void stat_send(string cmd, int size)](./game_server.engine/mods/net/MsgStatD/stat_send.md)|统计发送的消息|
|[void stat_field_update_broad_notify(string field, int size)](./game_server.engine/mods/net/MsgStatD/stat_field_update_broad_notify.md)|统计字段更新、广播通知|
|[map get_cmd_stat()](./game_server.engine/mods/net/MsgStatD/get_cmd_stat.md)|获取已接收消息的统计信息|


### net.gs
网络模块


|函数原型|函数作用|
| -- | -- |
|[object start_server(string name, int port, bool ws, int client_heart = 0, array cmd_dirs = nil)](./game_server.engine/mods/net/net/start_server.md)|启动服务器|
|[void stop_server(string name)](./game_server.engine/mods/net/net/stop_server.md)|关闭服务器|
|[void stop_all_servers()](./game_server.engine/mods/net/net/stop_all_servers.md)|关闭所有服务器|
|[object get_server(string name)](./game_server.engine/mods/net/net/get_server.md)|通过名称获取服务器对象|
|[void on_server_start(string name, function func)](./game_server.engine/mods/net/net/on_server_start.md)|响应指定名称的服务器启动回调函数|
|[void on_server_stop(string name, function func)](./game_server.engine/mods/net/net/on_server_stop.md)|响应指定名称的服务器停止回调函数|


### Baggage.gs
背包对象
* 背包对象是实体对象的一种


|函数原型|函数作用|
| -- | -- |
|[bool safe_lock()](./game_server.engine/objects/Baggage/safe_lock.md)|虚函数: 锁定背包|
|[bool safe_unlock()](./game_server.engine/objects/Baggage/safe_unlock.md)|虚函数: 解锁背包|
|[mixed safe_invoke(function func, ...)](./game_server.engine/objects/Baggage/safe_invoke.md)|虚函数: 在背包锁里安全执行指定的操作|
|[int need_capacity(map property_dbase)](./game_server.engine/objects/Baggage/need_capacity.md)|虚函数: 计算扣除可叠加在已有道具上的数量以外，容纳道具所需的空闲格子数|
|[array get_items_by_class_id(mixed class_id_or_alias)](./game_server.engine/objects/Baggage/get_items_by_class_id.md)|获取道具对象rid列表|
|[array get_item_obs_by_class_id(mixed class_id_or_alias)](./game_server.engine/objects/Baggage/get_item_obs_by_class_id.md)|获取道具对象列表|
|[array get_items(mixed class_id_or_alias)](./game_server.engine/objects/Baggage/get_items.md)|获取道具rid列表（和get_items_by_class_id()相同）|
|[array get_item_obs(mixed class_id_or_alias)](./game_server.engine/objects/Baggage/get_item_obs.md)|获取道具对象列表（和get_item_obs_by_class_id()相同）|
|[map get_item_amount_by_type(string item_type)](./game_server.engine/objects/Baggage/get_item_amount_by_type.md)|获取指定道具类型的道具数量信息|
|[array get_item_rids_by_type(string item_type)](./game_server.engine/objects/Baggage/get_item_rids_by_type.md)|获取指定道具类型的道具rid列表|
|[array get_item_obs_by_type(string item_type)](./game_server.engine/objects/Baggage/get_item_obs_by_type.md)|获取指定道具类型的道具对象列表|
|[array get_item_obs_by_condition(function condition_func)](./game_server.engine/objects/Baggage/get_item_obs_by_condition.md)|获取满足指定条件的道具对象列表|
|[int get_item_amount(mixed class_id_or_alias, string quality = nil)](./game_server.engine/objects/Baggage/get_item_amount.md)|获取指定品质的道具数量（允许道具class_id或别名）|
|[int get_item_amount_by_class_id(int class_id, string quality = nil)](./game_server.engine/objects/Baggage/get_item_amount_by_class_id.md)|获取指定品质的道具数量（允许道具class_id）|
|[bool cost_item(mixed class_id_or_alias, int amount, string reason)](./game_server.engine/objects/Baggage/cost_item.md)|扣除道具（通过道具class id或别名）|
|[bool cost_item_by_class_id(int class_id, int amount, string reason)](./game_server.engine/objects/Baggage/cost_item_by_class_id.md)|扣除道具（通过道具class id）|
|[bool cost_item_by_ob(object item_ob, int amount, string reason)](./game_server.engine/objects/Baggage/cost_item_by_ob.md)|扣除指定的道具|
|[bool cost_item_by_rid(string rid, int amount, string reason)](./game_server.engine/objects/Baggage/cost_item_by_rid.md)|扣除指定rid的道具|
|[bool cost_item_by_type(string item_type, int amount, string reason)](./game_server.engine/objects/Baggage/cost_item_by_type.md)|扣除指定道具类型的道具|
|[bool cost_item_amount(map item_amount, string reason)](./game_server.engine/objects/Baggage/cost_item_amount.md)|扣除一批道具|
|[bool cost_item_by_condition(function condition_func, int amount, string reason)](./game_server.engine/objects/Baggage/cost_item_by_condition.md)|扣除满足指定条件的道具|
|[map obtain_item(mixed item_info, string reason)](./game_server.engine/objects/Baggage/obtain_item.md)|虚函数: 获得道具|
|[map get_item_amount_dict(mixed item_list_or_dict)](./game_server.engine/objects/Baggage/get_item_amount_dict.md)|获取一组道具的数量|
|[bool cost_item_amount_dict(map item_amount_dict, string reason)](./game_server.engine/objects/Baggage/cost_item_amount_dict.md)|扣除一组道具|
|[bool cost_item_amount_quality_dict(map item_amount_quality_dict, string reason)](./game_server.engine/objects/Baggage/cost_item_amount_quality_dict.md)|扣除一组指定品质的道具|


### Curve.gs
曲线对象


|函数原型|函数作用|
| -- | -- |
|[void load_curve(string file)](./game_server.engine/objects/Curve/load_curve.md)|加载曲线配置文件|
|[void set_curves(array curves)](./game_server.engine/objects/Curve/set_curves.md)|设置一组曲线值|
|[int get_curve_length(string name)](./game_server.engine/objects/Curve/get_curve_length.md)|获取指定名称的曲线数量|
|[array get_curve(string name)](./game_server.engine/objects/Curve/get_curve.md)|获取指定名称的曲线数据列表|
|[mixed get_curve_val(string name, int index)](./game_server.engine/objects/Curve/get_curve_val.md)|获取曲线值|


### Item.gs
道具对象
* 道具对象是实体对象的一种


|函数原型|函数作用|
| -- | -- |
|[string FEntity.desc()](./game_server.engine/objects/Item/FEntity.desc.md)|虚函数: 获取道具对象的描述|
|[int get_amount()](./game_server.engine/objects/Item/get_amount.md)|获取数量|
|[int get_ro_amount()](./game_server.engine/objects/Item/get_ro_amount.md)|获取数量（parallel方法）|
|[bool can_be_zero_amount()](./game_server.engine/objects/Item/can_be_zero_amount.md)|判断道具能否数量为0|
|[int cost_all(string reason)](./game_server.engine/objects/Item/cost_all.md)|扣除所有数量|
|[void cost_amount(int count, string reason)](./game_server.engine/objects/Item/cost_amount.md)|扣除指定数量|
|[int get_combinable()](./game_server.engine/objects/Item/get_combinable.md)|获取可叠加数量上限值|
|[bool is_full_combined()](./game_server.engine/objects/Item/is_full_combined.md)|判断数量是不是已经堆叠到上限值了|
|[string get_quality()](./game_server.engine/objects/Item/get_quality.md)|获取品质|
|[int get_quality_index()](./game_server.engine/objects/Item/get_quality_index.md)|获取品质的索引值|
|[int get_sell_price()](./game_server.engine/objects/Item/get_sell_price.md)|获取售价（不应该有这个方法）|
|[void drop_item(string reason)](./game_server.engine/objects/Item/drop_item.md)|丢弃道具|
|[int change_amount(int amount, string reason)](./game_server.engine/objects/Item/change_amount.md)|变更道具数量|


### Login.gs
登录对象
* 登录对象可以持有客户端网络连接对象
* 登录对象，处理登录过程，支持排队逻辑
* 连接创建后，先绑定登录对象
* 登录对象和连接对象处于一个域


|函数原型|函数作用|
| -- | -- |
|[string desc()](./game_server.engine/objects/Login/desc.md)|获取描述信息|
|[bool is_login_ob()](./game_server.engine/objects/Login/is_login_ob.md)|检查是不是一个登录对象|
|[bool load_chars_in(object mongo_agent = nil)](./game_server.engine/objects/Login/load_chars_in.md)|载入所有角色列表|
|[array get_char_list()](./game_server.engine/objects/Login/get_char_list.md)|获取所有角色列表（需要先执行载入所有角色列表）|
|[bool check_char_existed(string rid)](./game_server.engine/objects/Login/check_char_existed.md)|检查角色是否存在|
|[string get_first_char()](./game_server.engine/objects/Login/get_first_char.md)|获取第一个角色rid|
|[array fetch_char_fields_in(object mongo_agent, array char_list, array fields, function func)](./game_server.engine/objects/Login/fetch_char_fields_in.md)|获取一组角色的指定字段的数据列表|
|[void notify_login_ok(string user_rid)](./game_server.engine/objects/Login/notify_login_ok.md)|登录成功时的后处理|
|[void set_login_seq(int seq)](./game_server.engine/objects/Login/set_login_seq.md)|设置登录请求序号|
|[int get_login_seq()](./game_server.engine/objects/Login/get_login_seq.md)|获取登录请求序号|
|[void FComm.send_raw(mixed data)](./game_server.engine/objects/Login/FComm.send_raw.md)|虚函数: 发送消息（已经组织好的消息数据）|
|[void notify_login_queue_state(int handled_seq)](./game_server.engine/objects/Login/notify_login_queue_state.md)|通知消息:更新登录排队的位置|
|[bool FClientConnectionHolder.prev_bind_connection(object conn)](./game_server.engine/objects/Login/FClientConnectionHolder.prev_bind_connection.md)|虚函数: 绑定客户端连接对象时的前处理|
|[void FClientConnectionHolder.post_unbind_connection(object prev_conn)](./game_server.engine/objects/Login/FClientConnectionHolder.post_unbind_connection.md)|虚函数: 和客户端连接对象解绑时的后处理|


### Room.gs
房间对象
* 房间对象是实体对象的一种


|函数原型|函数作用|
| -- | -- |
|[bool is_room()](./game_server.engine/objects/Room/is_room.md)|判断是不是一个房间对象|
|[string FEntity.desc()](./game_server.engine/objects/Room/FEntity.desc.md)|虚函数: 获取描述信息|
|[mixed get_room_cfg(string key)](./game_server.engine/objects/Room/get_room_cfg.md)|获取配置值|
|[void FEntity.post_factory_create(bool new_create)](./game_server.engine/objects/Room/FEntity.post_factory_create.md)|虚函数: EntityFactroy创建房间对象（不包括子对象）时的后处理|
|[void FEntity.post_factory_fully_create(bool new_create)](./game_server.engine/objects/Room/FEntity.post_factory_fully_create.md)|虚函数: EntityFactroy完整创建房间对象（包括子对象）时的后处理|
|[void FEntityPrevClose.prev_close()](./game_server.engine/objects/Room/FEntityPrevClose.prev_close.md)|虚函数:房间对象析构前的处理函数|
|[int entity_count()](./game_server.engine/objects/Room/entity_count.md)|获取已进入房间的实体数量|
|[void add_entity(object ent)](./game_server.engine/objects/Room/add_entity.md)|虚函数: 向房间里增加一个实体对象|
|[array get_entities()](./game_server.engine/objects/Room/get_entities.md)|虚函数: 获取房间里所有实体对象列表|
|[void iterate_entities(function func)](./game_server.engine/objects/Room/iterate_entities.md)|遍历房间里的所有实体对象|
|[string entity_can_enter_room(object ent, map pos)](./game_server.engine/objects/Room/entity_can_enter_room.md)|虚函数:房间对象是否允许实体对象进入|
|[string entity_can_leave_room(object ent)](./game_server.engine/objects/Room/entity_can_leave_room.md)|虚函数: 检查房间对象是否允许实体对象离开|
|[bool entity_leave_room(object ent)](./game_server.engine/objects/Room/entity_leave_room.md)|虚函数: 执行实体对象离开房间时的处理|
|[string entity_can_move_in_room(object ent, map pos)](./game_server.engine/objects/Room/entity_can_move_in_room.md)|虚函数: 检查房间对象是否允许实体对象移动|
|[void send_appear_to(object ent, object other, map pos, map appearance, map dyn_appearance)](./game_server.engine/objects/Room/send_appear_to.md)|虚函数:向实体对象发送另一个实体对象出现在实体对象视野里消息|
|[void send_disappear_to(object ent, object other)](./game_server.engine/objects/Room/send_disappear_to.md)|虚函数:向实体对象发送另一个实体对象从实体对象视野消失消息|
|[void send_enter_room_to(object ent)](./game_server.engine/objects/Room/send_enter_room_to.md)|虚函数:向实体对象发送已进入房间消息|
|[void send_leave_room_to(object ent)](./game_server.engine/objects/Room/send_leave_room_to.md)|虚函数:向实体对象发送已离开房间消息|
|[void send_sync_vision_to(object ent)](./game_server.engine/objects/Room/send_sync_vision_to.md)|虚函数:向实体对象发送开始同步视野的消息（为指定实体对象同步视野时的前处理）|
|[void post_room_receive_entity(object ent)](./game_server.engine/objects/Room/post_room_receive_entity.md)|虚函数: 房间对象添加实体对象时的后处理|
|[void pre_entity_enter_room(object ent)](./game_server.engine/objects/Room/pre_entity_enter_room.md)|虚函数: 实体对象进入房间时的前处理|
|[void post_entity_enter_room(object ent)](./game_server.engine/objects/Room/post_entity_enter_room.md)|虚函数: 实体对象进入房间时的后处理|
|[void pre_room_send_entity(object ent)](./game_server.engine/objects/Room/pre_room_send_entity.md)|虚函数: 房间对象移除实体对象时的前处理|
|[void pre_entity_leave_room(object ent)](./game_server.engine/objects/Room/pre_entity_leave_room.md)|虚函数: 实体对象离开房间时的前处理|
|[void post_room_move_entity(object ent, map prev_pos, array lost_entities, array new_entities, array keep_entities)](./game_server.engine/objects/Room/post_room_move_entity.md)|虚函数: 房间对象移动实体对象时的后处理|
|[void post_entity_move_in_room(object ent, map prev_pos, array lost_entities, array new_entities, array keep_entities)](./game_server.engine/objects/Room/post_entity_move_in_room.md)|虚函数: 实体对象在房间对象里移动时的后处理|
|[void broadcast_to_all(string msg, ...)](./game_server.engine/objects/Room/broadcast_to_all.md)|虚函数: 向房间内的所有实体对象广播消息|
|[void iterate_vision_entities(object ent, function func)](./game_server.engine/objects/Room/iterate_vision_entities.md)|虚函数: 遍历指定实体对象视野内的所有实体对象|
|[void sync_vision(object ent)](./game_server.engine/objects/Room/sync_vision.md)|虚函数: 为指定的实体对象同步视野|
|[void clear_room(bool drop = false)](./game_server.engine/objects/Room/clear_room.md)|清空房间里的所有实体对象|


### User.gs
玩家对象
* 玩家对象是实体对象的一种
* 玩家对象可以持有客户端网络连接对象


|函数原型|函数作用|
| -- | -- |
|[void FEntity.heartbeat()](./game_server.engine/objects/User/FEntity.heartbeat.md)|虚函数: 执行一次心跳|
|[void check_heart()](./game_server.engine/objects/User/check_heart.md)|检测客户端连接心跳，心跳丢失时主动断开客户端连接（本接口需要主动调用才起效）|
|[void load_self()](./game_server.engine/objects/User/load_self.md)|加载自己|
|[void unload_self()](./game_server.engine/objects/User/unload_self.md)|卸载自己|
|[string get_account_id()](./game_server.engine/objects/User/get_account_id.md)|获取数字id账号|
|[string get_account()](./game_server.engine/objects/User/get_account.md)|获取账号|
|[string get_device_id()](./game_server.engine/objects/User/get_device_id.md)|获取设备id|
|[map get_client_info()](./game_server.engine/objects/User/get_client_info.md)|获取客户端信息|
|[void update_client_info(map client_info)](./game_server.engine/objects/User/update_client_info.md)|更新客户端信息|
|[object get_baggage(string baggage_name = nil)](./game_server.engine/objects/User/get_baggage.md)|获取指定名称的包裹|
|[bool is_logoutable()](./game_server.engine/objects/User/is_logoutable.md)|判断是否可以登出|
|[void append_exception_tag(mixed tag)](./game_server.engine/objects/User/append_exception_tag.md)|追加异常标签|
|[void clear_exception_tag(mixed tag)](./game_server.engine/objects/User/clear_exception_tag.md)|清除指定的异常标签|
|[bool contains_exception_tag(mixed tag)](./game_server.engine/objects/User/contains_exception_tag.md)|是否包含指定名称的异常标签|
|[bool is_exception_user()](./game_server.engine/objects/User/is_exception_user.md)|判断是否处于异常状态|
|[void clear_exception()](./game_server.engine/objects/User/clear_exception.md)|清除异常状态|
|[void drop_user()](./game_server.engine/objects/User/drop_user.md)|调试接口:不可逆的销毁自己（登出游戏并且清除角色数据）|
|[void delete_user()](./game_server.engine/objects/User/delete_user.md)|调试接口:可逆的销毁自己（标记为销毁并且登出游戏）|
|[bool is_user()](./game_server.engine/objects/User/is_user.md)|判断是不是玩家对象|
|[void disconnect()](./game_server.engine/objects/User/disconnect.md)|主动断开客户端连接|
|[bool FClientConnectionHolder.prev_bind_connection(object conn)](./game_server.engine/objects/User/FClientConnectionHolder.prev_bind_connection.md)|虚函数: 绑定客户端连接对象时的前处理|
|[void FClientConnectionHolder.post_unbind_connection(object prev_conn)](./game_server.engine/objects/User/FClientConnectionHolder.post_unbind_connection.md)|虚函数: 解除绑定客户端连接对象时的后处理|
|[void enable_auto_save(bool enable)](./game_server.engine/objects/User/enable_auto_save.md)|设置是否开启自动保存|
|[bool is_auto_save_enabled()](./game_server.engine/objects/User/is_auto_save_enabled.md)|判断是否开启自动保存|
|[bool FSave.save_sync()](./game_server.engine/objects/User/FSave.save_sync.md)|执行一次保存（异步阻塞模式）|
|[void FSave.save_async(function callback = nil)](./game_server.engine/objects/User/FSave.save_async.md)|执行一次保存（异步非阻塞模式）|
|[void try_auto_save(int duration)](./game_server.engine/objects/User/try_auto_save.md)|尝试执行一次自动保存|
|[void notify_save_success()](./game_server.engine/objects/User/notify_save_success.md)|保存成功时的后处理|
|[int get_last_save_success_time()](./game_server.engine/objects/User/get_last_save_success_time.md)|获取最近一次保存成功时的时间|
|[void send_user_init()](./game_server.engine/objects/User/send_user_init.md)|发送玩家初始化消息|
|[bool is_loading()](./game_server.engine/objects/User/is_loading.md)|判断是否处于加载状态|
|[void set_loading(bool loading)](./game_server.engine/objects/User/set_loading.md)|设置是否处于加载状态|
|[void logout(function callback = nil)](./game_server.engine/objects/User/logout.md)|执行登出操作|
|[array on_relogin(LoginContext context)](./game_server.engine/objects/User/on_relogin.md)|执行角色重新登录时的后处理|
|[void FEntity.send_raw(mixed data)](./game_server.engine/objects/User/FEntity.send_raw.md)|虚函数：发送消息（已经组织好的消息数据）|
|[void FEntity.broadcast_raw(mixed data)](./game_server.engine/objects/User/FEntity.broadcast_raw.md)|虚函数：广播消息（已经组织好的消息数据）|
|[void send_directly(string msg, ...)](./game_server.engine/objects/User/send_directly.md)|无视所有策略，通过客户端连接对象直接发送消息|
|[void add_statistics(string key, mixed delta)](./game_server.engine/objects/User/add_statistics.md)|增加统计数据值|
|[mixed get_statistics(string key)](./game_server.engine/objects/User/get_statistics.md)|获取统计数据值|
|[void set_statistics(string key, mixed value)](./game_server.engine/objects/User/set_statistics.md)|设置统计数据值|
|[void notify_save_start(SaveStat stat)](./game_server.engine/objects/User/notify_save_start.md)|开始存盘耗时统计时的处理|
|[void notify_save_stop(SaveStat stat)](./game_server.engine/objects/User/notify_save_stop.md)|停止存盘耗时统计时的处理|
|[void send_all_dynamic_entity()](./game_server.engine/objects/User/send_all_dynamic_entity.md)|向客户端同步所有动态创建的实体模板信息|


### EfunExt.gs
type function扩展文件
* 用来实现自定义的type function


|函数原型|函数作用|
| -- | -- |
|[map map.merge(map m1, map m2)](./game_server.engine/utils/EfunExt/map.merge.md)|合并词典|
|[string string.capitalize(string str)](./game_server.engine/utils/EfunExt/string.capitalize.md)|文本首字母大写化|


### ExcelToJson.gs
通过xlsx配置文件生成json配置文件的功能模块
* 主要是生成json格式的配置文件给客户端使用
* 目前本模块作用几乎没有了，客户端已经可以直接使用xlsx配置文件了
* 未来可能移除


|函数原型|函数作用|
| -- | -- |
|[bool need_skip(string file_name)](./game_server.engine/utils/ExcelToJson/need_skip.md)|判断是否为需要跳过的文件|
|[void transform_all_configs(string output_dir = "OUTPUT_DIR")](./game_server.engine/utils/ExcelToJson/transform_all_configs.md)|为所有配置文件生成对应的json文件|
|[void export_to_json_file(string json_path, mixed json_data)](./game_server.engine/utils/ExcelToJson/export_to_json_file.md)|将json数据以可读的格式写入json文件|


### Functions.gs
脚本类型的全局函数实现文件
* 用来实现自定义的通用的脚本类型的全局函数


|函数原型|函数作用|
| -- | -- |
|[mixed WAIT_POST(object fu)](./game_server.engine/utils/Functions/WAIT_POST.md)|等待post调用结束，方便书写|
|[string get_chinese_num(int n)](./game_server.engine/utils/Functions/get_chinese_num.md)|获取中文数字（零到十）|
|[int new_cookie()](./game_server.engine/utils/Functions/new_cookie.md)|生成一个cookie值|
|[int char_size(int c)](./game_server.engine/utils/Functions/char_size.md)|获取字符长度（字节）|
|[array utf8_len(string str)](./game_server.engine/utils/Functions/utf8_len.md)|获取UTF8编码字符串里的字符数量|
|[string utf8_sub(string str, int start, int n)](./game_server.engine/utils/Functions/utf8_sub.md)|获取UTF8编码字符串的子串|
|[int today_hms_time(int hour, int minute = 0, int second = 0)](./game_server.engine/utils/Functions/today_hms_time.md)|获取今天指定时分秒的时间值|
|[int this_week_hms_time(int wday, int hour, int minute = 0, int second = 0)](./game_server.engine/utils/Functions/this_week_hms_time.md)|获取本周指定天时分秒的时间值|
|[map random_select_by_weight(array arr, string weight_key = "weight")](./game_server.engine/utils/Functions/random_select_by_weight.md)|根据权重表随机选择，所有权重为负数的都变成0|
|[array random_sample(int n, int m)](./game_server.engine/utils/Functions/random_sample.md)|随机采样|
|[array random_sample_arr(array arr, int m)](./game_server.engine/utils/Functions/random_sample_arr.md)|从数组中随机采样m个数据，保证每个选中的概率为m/n|
|[mixed assure_invoke_script(string script, ...)](./game_server.engine/utils/Functions/assure_invoke_script.md)|执行指定名称的游戏脚本函数（游戏脚本函数不存在时抛出异常）|
|[mixed invoke_script(string script, ...)](./game_server.engine/utils/Functions/invoke_script.md)|执行指定名称的游戏脚本函数（游戏脚本函数不存在时不抛出异常）|
|[mixed invoke_any_script(array scripts, ...)](./game_server.engine/utils/Functions/invoke_any_script.md)|执行任一游戏脚本函数|
|[void ASSURE_DOMAIN_LV(int lv)](./game_server.engine/utils/Functions/ASSURE_DOMAIN_LV.md)|确认当前域的优先级不超过目标值|
|[object new_component(string file, map m = {}, domain d = nil)](./game_server.engine/utils/Functions/new_component.md)|新创建一个动态组件对象实例|
|[object load_component(string file, map m = {}, domain d = nil)](./game_server.engine/utils/Functions/load_component.md)|加载创建一个动态组件对象实例|
|[void assure_has_function(object mod, string func_name)](./game_server.engine/utils/Functions/assure_has_function.md)|确认对象上存在指定名称的接口函数|
|[bool FAULT(mixed reason)](./game_server.engine/utils/Functions/FAULT.md)|抛出异常并返回false|
|[array SUCCEED(mixed result = nil)](./game_server.engine/utils/Functions/SUCCEED.md)|生成包含结果的二元组成功值|
|[array FAIL(mixed reason = nil)](./game_server.engine/utils/Functions/FAIL.md)|生成包含失败原因的二元组失败值|
|[array FAIL_TIP(mixed reason)](./game_server.engine/utils/Functions/FAIL_TIP.md)|生成包含失败原因的二元组失败提示值|
|[bool IS_FAIL(mixed result)](./game_server.engine/utils/Functions/IS_FAIL.md)|判断是不是一个二元组失败值或者失败提示值|
|[string __L(mixed id, string default_text = nil)](./game_server.engine/utils/Functions/__L.md)|获取指定id的本地化文本|


### MathUtil.gs
数学相关的扩展函数


|函数原型|函数作用|
| -- | -- |
|[bool is_number(mixed val)](./game_server.engine/utils/MathUtil/is_number.md)|判断是不是一个数字|
|[map array_to_pos(array p)](./game_server.engine/utils/MathUtil/array_to_pos.md)|数组转换为2坐标位置|
|[array pos_to_array(map p)](./game_server.engine/utils/MathUtil/pos_to_array.md)|将2坐标位置转换为数组|
|[float pos_distance(map a, map b)](./game_server.engine/utils/MathUtil/pos_distance.md)|计算两个位置距离|
|[float pos_distance_pow(map a, map b)](./game_server.engine/utils/MathUtil/pos_distance_pow.md)|两个位置距离的平方|
|[map array_to_world_pos(array p)](./game_server.engine/utils/MathUtil/array_to_world_pos.md)|数组转换为3坐标位置|
|[array world_pos_to_array(map p)](./game_server.engine/utils/MathUtil/world_pos_to_array.md)|将3坐标位置转换为数组|
|[float world_pos_distance(map a, map b)](./game_server.engine/utils/MathUtil/world_pos_distance.md)|计算两个3坐标位置距离|
|[float world_pos_distance_pow(map a, map b)](./game_server.engine/utils/MathUtil/world_pos_distance_pow.md)|计算两个3坐标位置距离的平方|
|[mixed vector3_dot(map a, map b)](./game_server.engine/utils/MathUtil/vector3_dot.md)|计算三维向量点积|
|[float vec2_magnitude_distance(float x1, float y1, float x2, float y2)](./game_server.engine/utils/MathUtil/vec2_magnitude_distance.md)|两个二维点之间距离的平方|
|[float pos2_magnitude_distance(map pos1, map pos2)](./game_server.engine/utils/MathUtil/pos2_magnitude_distance.md)|两个二维点之间距离的平方（x,z）|
|[float vec2_distance(float x1, float y1, float x2, float y2)](./game_server.engine/utils/MathUtil/vec2_distance.md)|两个二维点间的距离|
|[float pos2_distance(map pos1, map pos2)](./game_server.engine/utils/MathUtil/pos2_distance.md)|两个二维点间的距离（x,z）|
|[bool pos2_dist_lessthan(map pos1, map pos2, mixed dist)](./game_server.engine/utils/MathUtil/pos2_dist_lessthan.md)|判断两个二维点距离是否效于等于指定距离值|
|[map vec2_lerp(map pos_begin, map pos_end, float lerp_val)](./game_server.engine/utils/MathUtil/vec2_lerp.md)|计算两个二维点之间的插值坐标（x,z）|
|[map vec3_lerp(map pos_begin, map pos_end, float lerp_val)](./game_server.engine/utils/MathUtil/vec3_lerp.md)| 计算两个三维点之间的插值坐标|
|[map pos3(mixed x, mixed y, mixed z)](./game_server.engine/utils/MathUtil/pos3.md)|生成3D坐标|
|[map pos2(mixed x, mixed z)](./game_server.engine/utils/MathUtil/pos2.md)|生成2D坐标（x,z）|
|[int random_one()](./game_server.engine/utils/MathUtil/random_one.md)|随机-1或者1|
|[int select_by_weight(array weights, float select_val)](./game_server.engine/utils/MathUtil/select_by_weight.md)|根据权重在权重array中选择一个返回索引|
|[array random_select_multiple_by_weight(map weight_table, int num)](./game_server.engine/utils/MathUtil/random_select_multiple_by_weight.md)|从权重表里随机返回多个值|


### ScriptUtil.gs
全局脚本函数


|函数原型|函数作用|
| -- | -- |
|[string file2domain(string file_name, string identifier = "DOMAIN")](./game_server.engine/utils/ScriptUtil/file2domain.md)|获取文件名对应的域名|
|[string get_pure_name(string obfile)](./game_server.engine/utils/ScriptUtil/get_pure_name.md)|获取纯文件名（不带路径和扩展名）|
|[void load_static_objects_in(string path)](./game_server.engine/utils/ScriptUtil/load_static_objects_in.md)|加载目录下所有脚本对象|
|[void destruct_static_objects_in(string path)](./game_server.engine/utils/ScriptUtil/destruct_static_objects_in.md)|销毁目录下所有脚本对象|
|[void compile_scripts_in(string path = "/", bool recursively = true, bool force_recompile = false)](./game_server.engine/utils/ScriptUtil/compile_scripts_in.md)|编译指定目录下的所有脚本|
|[array find_scripts(string path, bool recursively = false)](./game_server.engine/utils/ScriptUtil/find_scripts.md)|获取指定目录下的所有脚本文件（.gs或者.o，打包文件的.o会被以.gs形式返回）|


## 类

### HeartbeatBase
自定义心跳的基础类

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|interval|int|0|可选| 心跳间隔|
|last_timing|int|0|可选| 最近一次心跳时机|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[bool is_passive_heartbeat()](./game_server.engine/components/FHeartbeat/HeartbeatBase.is_passive_heartbeat.md)|是不是被动心跳|
|[void start(HeartbeatBase self, object ob, int interval)](./game_server.engine/components/FHeartbeat/HeartbeatBase.start.md)|开启心跳|
|[void stop(object ob)](./game_server.engine/components/FHeartbeat/HeartbeatBase.stop.md)|停止心跳|
|[void heartbeat(HeartbeatBase self, object ob, int heartbeat_timing)](./game_server.engine/components/FHeartbeat/HeartbeatBase.heartbeat.md)|执行心跳|

### TimeBaseHeartbeat

> 继承自 HeartbeatBase

固定时间间隔的主动心跳

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[bool is_passive_heartbeat()](./game_server.engine/components/FHeartbeat/TimeBaseHeartbeat.is_passive_heartbeat.md)|是不是被动心跳|
|[void start(object ob, int interval)](./game_server.engine/components/FHeartbeat/TimeBaseHeartbeat.start.md)|开启心跳|
|[void stop(object ob)](./game_server.engine/components/FHeartbeat/TimeBaseHeartbeat.stop.md)|停止心跳|
|[void heartbeat(object ob, int heartbeat_timing)](./game_server.engine/components/FHeartbeat/TimeBaseHeartbeat.heartbeat.md)|执行心跳|

### TimeBasePassiveHeartbeat

> 继承自 HeartbeatBase

基于父节点心跳的固定时间间隔的被动心跳

心跳间隔最好是父节点心跳间隔的整数倍

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[void start(object ob, int interval)](./game_server.engine/components/FHeartbeat/TimeBasePassiveHeartbeat.start.md)|开启心跳|
|[void heartbeat(object ob, int heartbeat_timing)](./game_server.engine/components/FHeartbeat/TimeBasePassiveHeartbeat.heartbeat.md)|执行心跳|

### CounterBasePassiveHeartbeat

> 继承自 HeartbeatBase

以父节点心跳次数为计数的被动心跳

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|counter|int|0|可选| 当前计数|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[void heartbeat(object ob, int heartbeat_timing)](./game_server.engine/components/FHeartbeat/CounterBasePassiveHeartbeat.heartbeat.md)|执行心跳|

### SaveStat
存盘耗时统计

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|ob|object|nil|可选| 统计对象|
|start_ms|int|0|可选| 开始时间|
|finish_ms|int|0|可选| 结束时间|
|invoke_ms|int|0|可选| 执行时间|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[void start()](./game_server.engine/components/FSave/SaveStat.start.md)|开始统计|
|[void stop()](./game_server.engine/components/FSave/SaveStat.stop.md)|停止统计|

### TimedTask
定时执行的任务

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|func|function|nil|可选| 执行函数|
|exec_time|int|0|可选| 执行时间点|
|invoke_times|int|0|可选| 已执行次数|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[int calc_exec_time(int now)](./game_server.engine/components/FTimedTask/TimedTask.calc_exec_time.md)|计算当前时间下任务的执行时间点|
|[int calc_next_exec_time(int now)](./game_server.engine/components/FTimedTask/TimedTask.calc_next_exec_time.md)|计算任务的下一次执行时间点|
|[void exec(int now)](./game_server.engine/components/FTimedTask/TimedTask.exec.md)|执行任务|
|[bool update(int now)](./game_server.engine/components/FTimedTask/TimedTask.update.md)|更新任务状态|

### DayTask

> 继承自 TimedTask

每天定时执行的任务

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|hour|int|0|可选| 小时|
|minute|int|0|可选| 分钟|
|second|int|0|可选| 秒|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[int calc_exec_time(int now)](./game_server.engine/components/FTimedTask/DayTask.calc_exec_time.md)|计算当天的执行时间点|
|[int calc_next_exec_time(int now)](./game_server.engine/components/FTimedTask/DayTask.calc_next_exec_time.md)|计算下一次执行时间点|

### WeekTask

> 继承自 TimedTask

每周定时执行的任务

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|wday|int|0|可选| 星期几(0-6, 0表示周日)|
|hour|int|0|可选| 小时|
|minute|int|0|可选| 分钟|
|second|int|0|可选| 秒|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[int calc_exec_time(int now)](./game_server.engine/components/FTimedTask/WeekTask.calc_exec_time.md)|计算当周的执行时间点|
|[int calc_next_exec_time(int now)](./game_server.engine/components/FTimedTask/WeekTask.calc_next_exec_time.md)|计算下一次执行时间点|

### FixedTask

> 继承自 TimedTask

固定间隔时长执行的任务

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|fixed_seconds|int|0|可选| 固定间隔时长（单位：秒）|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[int calc_exec_time(int now)](./game_server.engine/components/FTimedTask/FixedTask.calc_exec_time.md)|计算当前时间对应的执行时间点|
|[int calc_next_exec_time(int now)](./game_server.engine/components/FTimedTask/FixedTask.calc_next_exec_time.md)|计算下一次执行时间点|

### AutoTimeoutQueue
带有自动超时功能的队列

队列中每个元素都有一个时间戳，超过时间阈值的队列元素会被自动抛弃

队列会自动扩容（不能超过安全上限）

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|data_queue|CircularQueue|nil|可选| 存放数据的循环队列|
|time_queue|CircularQueue|nil|可选| 存放时间戳的循环队列|
|timeout|int|0|可选| 超时时长|
|size|int|0|可选| 队列当前大小|
|max_size|int|0|可选| 队列最大容量|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[mixed peek(int offset = 0)](./game_server.engine/components/FUserFastRelogin/AutoTimeoutQueue.peek.md)|查看队列中指定位置的元素|
|[void auto_enqueue(array data)](./game_server.engine/components/FUserFastRelogin/AutoTimeoutQueue.auto_enqueue.md)|自动入队列|
|[void clean_timeout()](./game_server.engine/components/FUserFastRelogin/AutoTimeoutQueue.clean_timeout.md)|清理超时元素|

### FastReloginData
快速重连机制使用的数据结构

主要是当前缓存的网络消息

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|msg_seq|int|1|可选| 已缓存的最大网络消息序号|
|lock|share_value|nil|可选| 保护快速重连数据的锁|
|seconds|int|0|可选| 缓存时长（单位：秒）|
|cache|AutoTimeoutQueue|nil|可选| 缓存网络消息的队列|

#### 成员方法

|函数原型|函数作用|
| -- | -- |

### EntityCreatorBase
实体创建器的基础类

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|dbase|map|nil|可选| 实体数据|
|d|domain|nil|可选| 实体所在的域|
|runtime|map|nil|可选| 运行时数据(记录创建过程中的临时数据)|
|success|bool|false|可选| 创建是否成功|
|entity|mixed|nil|可选| 创建的实体对象|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[void set_runtime(string key, mixed val)](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.set_runtime.md)|设置运行时数据|
|[mixed get_runtime(string key)](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.get_runtime.md)|获取运行时数据|
|[void set_to_dbase(string key, mixed val)](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.set_to_dbase.md)|设置实体数据数据|
|[mixed get_from_dbase(string key)](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.get_from_dbase.md)|获取实体数据值|
|[void delete_from_dbase(string key)](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.delete_from_dbase.md)|删除实体数据值|
|[bool check_domain()](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.check_domain.md)|检查创建器中域值是否合法|
|[bool update_integrity()](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.update_integrity.md)|更新实体数据的完整性|
|[bool pre_create()](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.pre_create.md)|执行创建时的前处理|
|[object create()](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.create.md)|执行创建|
|[void post_create()](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.post_create.md)|执行创建时的后处理|
|[void post_fail()](./game_server.engine/daemons/EntityFactory/EntityCreatorBase.post_fail.md)|创建失败时的后处理|

### LightEntityCreator

> 继承自 EntityCreatorBase

轻量级实体创建器

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|type|string|nil|可选||
|id|string|nil|可选||

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[bool update_integrity()](./game_server.engine/daemons/EntityFactory/LightEntityCreator.update_integrity.md)|更新实体数据的完整性|
|[object create()](./game_server.engine/daemons/EntityFactory/LightEntityCreator.create.md)|执行创建|

### EntityCreator

> 继承自 EntityCreatorBase

实体创建器

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|class_id_or_alias|mixed|nil|可选| 实体的class_id或者别名|
|load_child_func|function|nil|可选| 加载子对象的函数|
|load_partner_func|function|nil|可选| 加载伙伴对象的函数|
|partner_obs|array|nil|可选| 伴生的伙伴对象列表|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[bool update_integrity()](./game_server.engine/daemons/EntityFactory/EntityCreator.update_integrity.md)|更新实体数据的完整性|
|[bool pre_create()](./game_server.engine/daemons/EntityFactory/EntityCreator.pre_create.md)|执行创建时的前处理|
|[object create()](./game_server.engine/daemons/EntityFactory/EntityCreator.create.md)|执行创建|
|[void load_child_entities()](./game_server.engine/daemons/EntityFactory/EntityCreator.load_child_entities.md)|加载所有子对象|
|[void load_partner_entities()](./game_server.engine/daemons/EntityFactory/EntityCreator.load_partner_entities.md)|加载所有伙伴对象|
|[void post_create()](./game_server.engine/daemons/EntityFactory/EntityCreator.post_create.md)|执行创建时的后处理|
|[void post_fail()](./game_server.engine/daemons/EntityFactory/EntityCreator.post_fail.md)|执行创建失败时的处理|

### Field
字段

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|name|string|nil|可选| 字段名称|
|privileges|map|nil|可选| 字段权限词典<br/> key: 字段权限<br/> value: 字段权限检查函数或者true值|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[bool contains_privilege(string privilege)](./game_server.engine/daemons/FieldsD/Field.contains_privilege.md)|是否包含指定名称的权限|
|[bool check_privilege(string privilege, ...)](./game_server.engine/daemons/FieldsD/Field.check_privilege.md)|检查是否满足指定名称的权限的条件|
|[void add_privileges(mixed privileges)](./game_server.engine/daemons/FieldsD/Field.add_privileges.md)|增加一组权限|
|[void remove_privilege(string privilege)](./game_server.engine/daemons/FieldsD/Field.remove_privilege.md)|移除指定名称的权限|
|[void remove_privileges(array privileges)](./game_server.engine/daemons/FieldsD/Field.remove_privileges.md)|移除一组权限|

### FieldMask
字段掩码

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|enabled_privileges|map|nil|可选| 可用的所有权限词典<br/> key: 字段名称<br/> value: 可用的权限词典<br/>        key: 权限名称<br/>        value: true|
|disabled_fields|map|nil|可选| 不可用的所有字段词典<br/> key: 字段名称<br/> value: true|
|disabled_privieges|map|nil|可选| 不可用的所有权限词典<br/> key: 字段名称<br/> value: 不可用的权限词典<br/>        key: 权限名称<br/>        value: true|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[void reset()](./game_server.engine/daemons/FieldsD/FieldMask.reset.md)||
|[bool is_disabled(string field_name, string privilege)](./game_server.engine/daemons/FieldsD/FieldMask.is_disabled.md)||
|[void disable(string field_name, string privilege = nil)](./game_server.engine/daemons/FieldsD/FieldMask.disable.md)|屏蔽字段的权限|
|[void enable(string field_name, string privilege = nil)](./game_server.engine/daemons/FieldsD/FieldMask.enable.md)|启用字段的权限|

### FieldSet
字段集合

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|dict|map|nil|可选| 字段词典<br/> key: 字段名称<br/> value: 字段（Field实例）|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[void add_field(Field f)](./game_server.engine/daemons/FieldsD/FieldSet.add_field.md)|增加字段|
|[void remove_field(string field_name)](./game_server.engine/daemons/FieldsD/FieldSet.remove_field.md)|移除字段|
|[void iterate_field(function func, ...)](./game_server.engine/daemons/FieldsD/FieldSet.iterate_field.md)|遍历字段|
|[Field get_field(string field_name)](./game_server.engine/daemons/FieldsD/FieldSet.get_field.md)|通过名称获取字段|
|[map get_fields()](./game_server.engine/daemons/FieldsD/FieldSet.get_fields.md)|获取所有字段词典|
|[bool contains_field_privilege(string field_name, string privilege)](./game_server.engine/daemons/FieldsD/FieldSet.contains_field_privilege.md)|判断是否包含指定名称的字段的指定权限|

### TypeComponents
字段类型集合

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|type_components|map|nil|可选| 对象类型的组件列表集合<br/> key: 字段类型<br/> value: 对象组件列表|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[void set_components(string type, array components)](./game_server.engine/daemons/FieldsD/TypeComponents.set_components.md)|设置字段类型的对象组件列表|
|[array get_ob_field_types(string component_name)](./game_server.engine/daemons/FieldsD/TypeComponents.get_ob_field_types.md)|通过组件名称获取字段类型列表|

### TypeFields
字段类型集合

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|type_dict|map|nil|可选| 字段类型集合<br/> key: 字段类型名称<br/> value: FieldSet实例<br/> { type : { name : Field } }|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[array get_types()](./game_server.engine/daemons/FieldsD/TypeFields.get_types.md)|获取所有字段类型列表|
|[void add_field(string type, Field f)](./game_server.engine/daemons/FieldsD/TypeFields.add_field.md)|为指定的字段类型添加一个字段|
|[void remove_field(string type, string field_name)](./game_server.engine/daemons/FieldsD/TypeFields.remove_field.md)|移除指定的字段类型中的字段|
|[void iterate_field(function func)](./game_server.engine/daemons/FieldsD/TypeFields.iterate_field.md)|遍历所有字段|
|[void iterate_field_by_type(string type, function func)](./game_server.engine/daemons/FieldsD/TypeFields.iterate_field_by_type.md)|遍历指定名称字段类型的所有字段|
|[Field get_field(string type, string field_name)](./game_server.engine/daemons/FieldsD/TypeFields.get_field.md)|获取指定字段类型名称的指定字段|
|[FieldSet get_fields(string type)](./game_server.engine/daemons/FieldsD/TypeFields.get_fields.md)|获取指定名称的字段类型的字段集合|
|[void set_fields(string type, FieldSet fields)](./game_server.engine/daemons/FieldsD/TypeFields.set_fields.md)|设置指定字段类型的字段集合|
|[void delete_fields(string type)](./game_server.engine/daemons/FieldsD/TypeFields.delete_fields.md)|删除指定字段类型的字段集合|

### LoginContext
登录时使用的数据结构

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|account|string|nil|可选| 登录账号|
|account_id|string|nil|可选| 登录数字id账号|
|user_rid|string|nil|可选| 登录角色rid|
|login_aux_data|map|nil|可选| 登录辅助信息(服务器生成的)|
|client_info|map|nil|可选| 客户端信息(主要指的设备信息这些信息)|
|client_login_aux_data|mixed|nil|可选| 其它客户端提供的登录辅助信息|
|fast_relogin|mixed|nil|可选| 快速重连时附带的信息|
|runtime_co|mixed|nil|可选| 执行登录时使用的协程|
|runtime|map|nil|可选| 登录运行时信息<br/> 目前包括:<br/> 1.实际登录的角色rid<br/> 2.处理结果<br/> 3.失败原因<br/> 4.当前登录锁名称|
|stat|LoginCostStat|nil|可选| 登录耗时统计信息|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[string desc()](./game_server.engine/daemons/LoginD/LoginContext.desc.md)|获取登录数据描述信息|
|[void bind_runtime_co()](./game_server.engine/daemons/LoginD/LoginContext.bind_runtime_co.md)|绑定登录执行协程|
|[void set_runtime(string key, mixed value)](./game_server.engine/daemons/LoginD/LoginContext.set_runtime.md)|设置登录运行时数据|
|[mixed get_runtime(string key)](./game_server.engine/daemons/LoginD/LoginContext.get_runtime.md)|获取登录运行时数据|
|[void on_begin()](./game_server.engine/daemons/LoginD/LoginContext.on_begin.md)|登录开始时的处理|
|[void on_exec()](./game_server.engine/daemons/LoginD/LoginContext.on_exec.md)|登录执行时的处理|
|[void on_end()](./game_server.engine/daemons/LoginD/LoginContext.on_end.md)|登录结束时的处理|

### LoginCostStat
登录各环节耗时统计

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|dict|map|nil|可选| 所有统计数据|
|stack|map|nil|可选| 当前正在统计的|
|stacks|array|nil|可选| 暂存的统计数据|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[map new_stack(string name, map stack = nil)](./game_server.engine/daemons/LoginD/LoginCostStat.new_stack.md)||
|[void set_stack(map stack)](./game_server.engine/daemons/LoginD/LoginCostStat.set_stack.md)||
|[void push(string name)](./game_server.engine/daemons/LoginD/LoginCostStat.push.md)||
|[void pop()](./game_server.engine/daemons/LoginD/LoginCostStat.pop.md)||
|[void add_cost(string cost_name)](./game_server.engine/daemons/LoginD/LoginCostStat.add_cost.md)|添加一个统计|
|[mixed get_stat_value(string name, string key)](./game_server.engine/daemons/LoginD/LoginCostStat.get_stat_value.md)|获取指定名称的统计数据的键值|

### LoginRequestBase
登录请求基础类

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|args|array|nil|可选| 参数列表|
|invoke_domain|domain|nil|可选| 目标函数执行时绑定的参数域|
|invoke_func|function|nil|可选| 目标执行函数|
|post_invoke_func|function|nil|可选| 目标执行函数的后处理函数(无域限制)|
|service_id|int|-1|可选| 服务id值(用于关联服务协程)|
|is_priority|bool|false|可选| 是否为高优先级|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[bool validate()](./game_server.engine/daemons/LoginQueueD/LoginRequestBase.validate.md)|验证是不是一个合法的登录请求|
|[string get_service_name()](./game_server.engine/daemons/LoginQueueD/LoginRequestBase.get_service_name.md)|获取请求对应的服务名称|
|[function gen_service_func()](./game_server.engine/daemons/LoginQueueD/LoginRequestBase.gen_service_func.md)|获取请求对应的服务函数|
|[mixed invoke()](./game_server.engine/daemons/LoginQueueD/LoginRequestBase.invoke.md)|执行登录请求|
|[void post_invoke(mixed invoke_result)](./game_server.engine/daemons/LoginQueueD/LoginRequestBase.post_invoke.md)|执行登录请求时的后处理|

### LoginRequest

> 继承自 LoginRequestBase

普通优先级的登录请求

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|seq|int|-1|可选| 排队队列分配的序号|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[bool validate()](./game_server.engine/daemons/LoginQueueD/LoginRequest.validate.md)|验证是否为合法的登录请求|
|[void post_invoke(mixed invoke_result)](./game_server.engine/daemons/LoginQueueD/LoginRequest.post_invoke.md)|执行登录请求时的后处理|

### PriorityLoginRequest

> 继承自 LoginRequestBase

高优先级登录请求

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |

#### 成员方法

|函数原型|函数作用|
| -- | -- |

### EngineParameters
引擎参数词典

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|para|map|nil|可选| 参数词典|

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[void init(map para)](./game_server.engine/engine/EngineParameters.init.md)|使用已有词典数据初始化|
|[void set_para(string key, mixed value)](./game_server.engine/engine/EngineParameters.set_para.md)|设置参数|
|[mixed get_para(string key)](./game_server.engine/engine/EngineParameters.get_para.md)|获取参数值|
|[mixed calc_para(string key, ...)](./game_server.engine/engine/EngineParameters.calc_para.md)|获取或者计算参数值（参数值为function类型时执行计算）|

### CircularQueue
循环队列，用来处理固定大小的缓冲区

#### 成员变量

|变量名|类型|初始值|须初始化|描述|
| -- | -- | -- | -- | -- |
|list|array|nil|可选||
|head|int|0|可选||
|tail|int|0|可选||
|size|int|0|可选||

#### 成员方法

|函数原型|函数作用|
| -- | -- |
|[bool is_queue_full()](./game_server.engine/mods/net/net/CircularQueue.is_queue_full.md)|判断队列是否满|
|[bool is_queue_empty()](./game_server.engine/mods/net/net/CircularQueue.is_queue_empty.md)|判断队列是否为空|
|[int get_queue_size()](./game_server.engine/mods/net/net/CircularQueue.get_queue_size.md)|获取队列大小|
|[bool enqueue(mixed value)](./game_server.engine/mods/net/net/CircularQueue.enqueue.md)|入队|
|[mixed dequeue()](./game_server.engine/mods/net/net/CircularQueue.dequeue.md)|出队|
|[array dequeue_n(int count)](./game_server.engine/mods/net/net/CircularQueue.dequeue_n.md)|出队n个|
|[void drop_n(int count)](./game_server.engine/mods/net/net/CircularQueue.drop_n.md)|丢弃n个|
|[mixed peek(int offset = 0)](./game_server.engine/mods/net/net/CircularQueue.peek.md)|获取队列头部元素(不删除)|
|[void resize(int size)](./game_server.engine/mods/net/net/CircularQueue.resize.md)|调整队列大小|
|[int next_index(int n, int size)](./game_server.engine/mods/net/net/CircularQueue.next_index.md)||


## 样例
```cpp

// 启动引擎
engine.boot({
    "cfg_path" : "/config/config.json"
});

// 安全关机
SystemD.shutdown();

简介​

组件接口​

auth.gs​

debug_login.gs​

exit_login_queue.gs​

gm.gs​

list_users.gs​

login.gs​

post_login.gs​

query_server_info.gs​

request.gs​

run_command.gs​

FAttrib.gs​

FClientConnectionHolder.gs​

FComm.gs​

FComponentBase.gs​

FComponents.gs​

FCookieProvider.gs​

FCookieSubscriber.gs​

FCoPoolSerial0.gs​

FEntity.gs​

FEntityAppearance.gs​

FEntityAttrib.gs​

FEntityContainer.gs​

FEntityPrevClose.gs​

FEntityProfile.gs​

FEntityRelativeQuery.gs​

FEventEmitter.gs​

FFields.gs​

FHeartbeat.gs​

FInRoom.gs​

FLightEntity.gs​

FLockable.gs​

FLookField.gs​

FNode.gs​

FSave.gs​

FSendNotify.gs​

FService.gs​

FTick.gs​

FTimedTask.gs​

FUserCmd.gs​

FUserFastRelogin.gs​

AttribD.gs​

CurveD.gs​

DomainD.gs​

EntityFactory.gs​

FieldsD.gs​

GameSettingsD.gs​

GlobalFunctionD.gs​

GmD.gs​

HeartbeatD.gs​

InvokeScriptD.gs​

ItemD.gs​

LocalizedTextD.gs​

LogD.gs​

简介