mm_logic 0.0.0-stage → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1,3 +1,83 @@
1
- # Temporary Holding Version
1
+ # mm_logic
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ 游戏逻辑规则模块。以具名处理函数为单位注册与执行游戏规则,仅做纯逻辑计算,不直接读写游戏数据;数据读写由 `mm_datas` 提供,循环调度由 `mm_system` 负责。
4
+
5
+ ## 安装
6
+
7
+ ```bash
8
+ npm install mm_logic
9
+ ```
10
+
11
+ ## 快速开始
12
+
13
+ ```js
14
+ const { logicAdmin } = require('mm_logic');
15
+
16
+ const logic = logicAdmin('battle');
17
+
18
+ // 方式一:运行时注册处理函数
19
+ const rule = logic.add({ name: 'damage', title: '伤害计算' });
20
+ rule.register('calc', async (params) => {
21
+ return Math.max(1, params.attack - params.defense);
22
+ });
23
+
24
+ const damage = await logic.run('damage', 'calc', { attack: 30, defense: 8 });
25
+ // 22
26
+
27
+ // 方式二:配置主脚本,脚本导出的函数按名称自动注册
28
+ logic.add({ name: 'level', main: './rules/level.js' });
29
+ await logic.run('level', 'upgrade', { level: 8 });
30
+ ```
31
+
32
+ ## 脚本规范
33
+
34
+ 主脚本导出函数即逻辑处理方法,`main` 为默认入口:
35
+
36
+ ```js
37
+ module.exports = {
38
+ async main(params, options, logic) {
39
+ return null;
40
+ },
41
+ async upgrade(params, options, logic) {
42
+ return (params.level || 0) + 1;
43
+ }
44
+ };
45
+ ```
46
+
47
+ ## API
48
+
49
+ ### logicAdmin(scope, config)
50
+
51
+ 获取指定作用域的逻辑管理器,同一作用域共享同一实例,缺省 `os`。
52
+
53
+ ### LogicManager
54
+
55
+ | 方法 | 说明 |
56
+ | --- | --- |
57
+ | `add(config)` | 注册逻辑规则,`config.name` 必填,可选 `main`/`state` |
58
+ | `del(name)` | 停止并注销逻辑规则 |
59
+ | `reload(name)` | 重启逻辑规则 |
60
+ | `run(name, action, params, options)` | 执行指定规则的处理方法,规则不存在或未启用返回 `null` |
61
+
62
+ ### Logic
63
+
64
+ | 方法 | 说明 |
65
+ | --- | --- |
66
+ | `register(name, handler)` | 注册处理方法,签名 `(params, options, logic) => *` |
67
+ | `unregister(name)` | 注销处理方法 |
68
+ | `has(name)` / `list()` | 判断/列出处理方法 |
69
+ | `load()` | 加载 `main` 脚本并注册导出函数 |
70
+ | `run(action, params, options)` | 执行处理方法,缺省执行 `main` |
71
+ | `main(params, options)` | 执行默认入口 |
72
+
73
+ ## 工具
74
+
75
+ - `logic`:规则清单、详情、执行、登记、注销、重启;`run` 传 `name` + `method` + `params`
76
+ - `logic_admin`:逻辑管理器实例池的 `list`/`inspect`/`del`/`clear`
77
+
78
+ ## 测试与示例
79
+
80
+ ```bash
81
+ npm test
82
+ npm run example
83
+ ```
@@ -0,0 +1,32 @@
1
+ 'use strict';
2
+
3
+ const { logicAdmin } = require('..');
4
+
5
+ /**
6
+ * 逻辑规则示例:注册伤害规则并执行
7
+ * @returns {Promise<void>} 示例完成
8
+ */
9
+ async function main() {
10
+ const logic = logicAdmin('demo');
11
+
12
+ const rule = logic.add({ name: 'battle', title: '战斗规则' });
13
+ rule.register('damage', async (params) => {
14
+ const attack = Number(params.attack) || 0;
15
+ const defense = Number(params.defense) || 0;
16
+ return Math.max(1, attack - defense);
17
+ });
18
+
19
+ const damage = await logic.run('battle', 'damage', { attack: 30, defense: 12 });
20
+ console.log('伤害值:', damage);
21
+
22
+ logic.add({ name: 'level', title: '升级规则', main: './rule.js', dir: __dirname });
23
+ console.log('升级后等级:', await logic.run('level', 'upgrade', { level: 8 }));
24
+
25
+ await logic.del('battle');
26
+ await logic.del('level');
27
+ }
28
+
29
+ main().catch((err) => {
30
+ console.error(err);
31
+ process.exitCode = 1;
32
+ });
@@ -0,0 +1,21 @@
1
+ 'use strict';
2
+
3
+ /**
4
+ * 示例逻辑脚本:默认入口返回传入值
5
+ * @param {object} params 逻辑输入参数
6
+ * @returns {*} 原值
7
+ */
8
+ async function main(params) {
9
+ return params.value;
10
+ }
11
+
12
+ /**
13
+ * 示例逻辑脚本:等级加一
14
+ * @param {object} params 逻辑输入参数
15
+ * @returns {number} 升级后的等级
16
+ */
17
+ async function upgrade(params) {
18
+ return (Number(params.level) || 0) + 1;
19
+ }
20
+
21
+ module.exports = { main, upgrade };
package/index.js ADDED
@@ -0,0 +1,11 @@
1
+ 'use strict';
2
+
3
+ const Logic = require('./lib/logic');
4
+ const Manager = require('./lib/manager');
5
+ const admin_module = require('./lib/admin');
6
+
7
+ module.exports = {
8
+ Logic,
9
+ Manager,
10
+ ...admin_module
11
+ };
package/lib/admin.js ADDED
@@ -0,0 +1,22 @@
1
+ 'use strict';
2
+
3
+ const { reg } = require('mm_admin');
4
+ const Manager = require('./manager');
5
+
6
+ /**
7
+ * 逻辑管理器实例池(Admin 工厂)
8
+ */
9
+ let admin = reg('mm_logic');
10
+ admin.setClass(Manager);
11
+
12
+ /**
13
+ * 获取指定作用域的逻辑管理器
14
+ * @param {string} [scope='os'] 作用域名称,同一作用域共享同一实例
15
+ * @param {object} [config] 管理器配置,仅在首次创建实例时生效
16
+ * @returns {Manager} 逻辑管理器实例
17
+ */
18
+ function logicAdmin(scope, config) {
19
+ return admin.get(scope || 'os', config);
20
+ }
21
+
22
+ module.exports = { admin, logicAdmin };
@@ -0,0 +1,8 @@
1
+ {
2
+ "scope": "${scope || 'os'}",
3
+ "name": "${name || 'demo'}",
4
+ "title": "${title || '逻辑规则'}",
5
+ "description": "${description || '描述逻辑规则'}",
6
+ "state": 1,
7
+ "main": "./index.js"
8
+ }
package/lib/logic.js ADDED
@@ -0,0 +1,205 @@
1
+ 'use strict';
2
+
3
+ const Mod = require('mm_machine').Mod;
4
+ const { hasFile, fullname } = require('mm_files');
5
+
6
+ /**
7
+ * 逻辑规则驱动
8
+ * @description 以具名处理函数为单位注册游戏规则,仅负责纯逻辑计算,不直接读写游戏数据
9
+ * @class
10
+ * @augments {Mod}
11
+ */
12
+ class Logic extends Mod {
13
+ /**
14
+ * 配置参数
15
+ * @type {object}
16
+ */
17
+ static config = {
18
+ /**
19
+ * 名称
20
+ * @type {string}
21
+ */
22
+ name: '',
23
+ /**
24
+ * 标题
25
+ * @type {string}
26
+ */
27
+ title: '逻辑规则',
28
+ /**
29
+ * 描述
30
+ * @type {string}
31
+ */
32
+ description: '这是游戏逻辑规则',
33
+ /**
34
+ * 状态 0未启用,1启用
35
+ * @type {number}
36
+ */
37
+ state: 1,
38
+ /**
39
+ * 主脚本文件(可选,导出函数按名称注册为逻辑处理方法)
40
+ * @type {string}
41
+ */
42
+ main: '',
43
+ /**
44
+ * 驱动目录
45
+ * @type {string}
46
+ */
47
+ dir: ''
48
+ };
49
+
50
+ /**
51
+ * 构造函数
52
+ * @param {object} config 配置项
53
+ * @param {object} parent 父级管理器
54
+ */
55
+ constructor(config, parent) {
56
+ super({ ...Logic.config, ...config });
57
+ this.parent = parent || null;
58
+ this._loaded = false;
59
+ this._handlers = new Map();
60
+ }
61
+ }
62
+
63
+ /**
64
+ * 获取驱动目录
65
+ * @returns {string} 驱动目录
66
+ */
67
+ Logic.prototype.getDir = function () {
68
+ return this.config.dir || (this.parent && this.parent.config.dir) || '';
69
+ };
70
+
71
+ /**
72
+ * 获取主脚本完整路径
73
+ * @returns {string|null} 脚本路径,未配置主脚本时返回 null
74
+ * @private
75
+ */
76
+ Logic.prototype._getScriptFile = function () {
77
+ let main = this.config.main;
78
+ if (!main) {
79
+ return null;
80
+ }
81
+ return fullname(main, this.getDir());
82
+ };
83
+
84
+ /**
85
+ * 脚本是否已加载
86
+ * @returns {boolean} 是否已加载
87
+ */
88
+ Logic.prototype.isLoaded = function () {
89
+ return this._loaded;
90
+ };
91
+
92
+ /**
93
+ * 加载主脚本,导出函数按名称注册为逻辑处理方法
94
+ * @returns {object|null} 加载的模块对象,文件不存在或加载失败返回 null
95
+ */
96
+ Logic.prototype.load = function () {
97
+ let file = this._getScriptFile();
98
+ if (!file || !hasFile(file)) {
99
+ return null;
100
+ }
101
+ let mod = require(file);
102
+ if (mod) {
103
+ for (let key in mod) {
104
+ if (typeof mod[key] === 'function') {
105
+ this._handlers.set(key, mod[key]);
106
+ }
107
+ }
108
+ }
109
+ this._loaded = true;
110
+ return mod;
111
+ };
112
+
113
+ /**
114
+ * 注册逻辑处理方法
115
+ * @param {string} name 处理方法名
116
+ * @param {Function} handler 处理函数,签名 (params, options, logic) => *
117
+ * @returns {object} 当前实例
118
+ */
119
+ Logic.prototype.register = function (name, handler) {
120
+ if (!name || typeof name !== 'string') {
121
+ throw new TypeError('逻辑处理方法名(name)必须是非空字符串');
122
+ }
123
+ if (typeof handler !== 'function') {
124
+ throw new TypeError('逻辑处理函数(handler)必须是函数');
125
+ }
126
+ this._handlers.set(name, handler);
127
+ return this;
128
+ };
129
+
130
+ /**
131
+ * 注销逻辑处理方法
132
+ * @param {string} name 处理方法名
133
+ * @returns {boolean} 是否存在并删除成功
134
+ */
135
+ Logic.prototype.unregister = function (name) {
136
+ return this._handlers.delete(name);
137
+ };
138
+
139
+ /**
140
+ * 判断逻辑处理方法是否存在
141
+ * @param {string} name 处理方法名
142
+ * @returns {boolean} 是否存在
143
+ */
144
+ Logic.prototype.has = function (name) {
145
+ return this._handlers.has(name);
146
+ };
147
+
148
+ /**
149
+ * 获取全部逻辑处理方法名
150
+ * @returns {Array<string>} 方法名数组
151
+ */
152
+ Logic.prototype.list = function () {
153
+ return Array.from(this._handlers.keys());
154
+ };
155
+
156
+ /**
157
+ * 执行逻辑处理
158
+ * @param {string|object} [action='main'] 处理方法名;传入对象时视为参数并执行 main
159
+ * @param {object} [params={}] 逻辑输入参数
160
+ * @param {object} [options={}] 运行上下文
161
+ * @returns {*} 处理结果,方法不存在时返回 null
162
+ */
163
+ Logic.prototype.run = async function (action, params, options) {
164
+ let action_name = action;
165
+ let params_obj = params;
166
+ if (typeof action !== 'string') {
167
+ params_obj = action;
168
+ options = params;
169
+ action_name = 'main';
170
+ }
171
+ if (!this._loaded && this.config.main) {
172
+ this.load();
173
+ }
174
+ let handler = this._handlers.get(action_name);
175
+ if (typeof handler !== 'function') {
176
+ return null;
177
+ }
178
+ return await handler.call(this, params_obj || {}, options || {}, this);
179
+ };
180
+
181
+ /**
182
+ * 执行默认逻辑入口
183
+ * @param {object} [params={}] 逻辑输入参数
184
+ * @param {object} [options={}] 运行上下文
185
+ * @returns {*} 处理结果
186
+ */
187
+ Logic.prototype.main = async function (params, options) {
188
+ return await this.run('main', params, options);
189
+ };
190
+
191
+ /**
192
+ * 初始化时按需加载主脚本
193
+ * @returns {Promise<void>} 初始化完成
194
+ * @private
195
+ */
196
+ Logic.prototype._init = async function () {
197
+ if (this.config.main) {
198
+ this.load();
199
+ }
200
+ };
201
+
202
+ /**
203
+ * @module 导出逻辑规则驱动类
204
+ */
205
+ module.exports = Logic;
package/lib/manager.js ADDED
@@ -0,0 +1,155 @@
1
+ 'use strict';
2
+
3
+ const Manager = require('mm_machine').Manager;
4
+ const Logic = require('./logic');
5
+
6
+ /**
7
+ * 逻辑规则管理器
8
+ * @class
9
+ * @augments {Manager}
10
+ */
11
+ class LogicManager extends Manager {
12
+ /**
13
+ * 配置参数
14
+ * @type {object}
15
+ */
16
+ static config = {
17
+ /**
18
+ * 名称
19
+ * @type {string}
20
+ */
21
+ name: '',
22
+ /**
23
+ * 标题
24
+ * @type {string}
25
+ */
26
+ title: '逻辑管理',
27
+ /**
28
+ * 描述
29
+ * @type {string}
30
+ */
31
+ description: '这是游戏逻辑规则管理器'
32
+ };
33
+
34
+ /**
35
+ * 构造函数
36
+ * @param {object} config 配置参数
37
+ * @param {object} parent 父级模块
38
+ */
39
+ constructor(config, parent) {
40
+ super({ ...LogicManager.config, ...config }, parent);
41
+ }
42
+ }
43
+
44
+ /**
45
+ * 逻辑规则驱动类
46
+ * @type {object}
47
+ */
48
+ LogicManager.prototype.Drive = Logic;
49
+
50
+ /**
51
+ * 初始化桥接
52
+ * @returns {Promise<void>} 初始化完成
53
+ * @private
54
+ */
55
+ LogicManager.prototype._init = async function () {
56
+ await this.onInit();
57
+ };
58
+
59
+ /**
60
+ * 启动桥接
61
+ * @returns {Promise<void>} 启动完成
62
+ * @private
63
+ */
64
+ LogicManager.prototype._start = async function () {
65
+ await this.onStart();
66
+ };
67
+
68
+ /**
69
+ * 停止桥接
70
+ * @returns {Promise<void>} 停止完成
71
+ * @private
72
+ */
73
+ LogicManager.prototype._stop = async function () {
74
+ await this.onStop();
75
+ };
76
+
77
+ /**
78
+ * 注册一个逻辑规则驱动
79
+ * @param {object} config 驱动配置,必须包含 name
80
+ * @returns {object} 逻辑规则实例
81
+ */
82
+ LogicManager.prototype.add = function (config) {
83
+ let drive = new this.Drive({ scope: this.config.name, ...config }, this);
84
+ this.set(drive.config.name, drive);
85
+ return drive;
86
+ };
87
+
88
+ /**
89
+ * 注销一个逻辑规则驱动(先停止再删除)
90
+ * @param {string} name 逻辑规则名称
91
+ * @returns {Promise<boolean>} 是否删除成功
92
+ */
93
+ LogicManager.prototype.del = async function (name) {
94
+ let drive = this.get(name);
95
+ if (drive) {
96
+ await drive.stop();
97
+ }
98
+ return await Manager.prototype.del.call(this, name);
99
+ };
100
+
101
+ /**
102
+ * 重启一个逻辑规则驱动
103
+ * @param {string} name 逻辑规则名称
104
+ * @returns {Promise<boolean>} 是否执行成功
105
+ */
106
+ LogicManager.prototype.reload = async function (name) {
107
+ let drive = this.get(name);
108
+ if (!drive) {
109
+ this.log('warn', '逻辑规则不存在,无法重启', name);
110
+ return false;
111
+ }
112
+ try {
113
+ await drive.stop();
114
+ await this._initDrive(drive);
115
+ await drive.start();
116
+ return true;
117
+ } catch (err) {
118
+ this.log('warn', '逻辑规则重启失败', name, err);
119
+ return false;
120
+ }
121
+ };
122
+
123
+ /**
124
+ * 初始化驱动实例
125
+ * @param {object} drive 驱动实例
126
+ * @returns {Promise<void>} 初始化完成
127
+ * @private
128
+ */
129
+ LogicManager.prototype._initDrive = async function (drive) {
130
+ await drive.init();
131
+ };
132
+
133
+ /**
134
+ * 执行指定逻辑规则
135
+ * @param {string} name 逻辑规则名称
136
+ * @param {string} [action='main'] 逻辑处理方法名
137
+ * @param {object} [params={}] 逻辑输入参数
138
+ * @param {object} [options={}] 运行上下文
139
+ * @returns {*} 逻辑处理结果,规则不存在或未启用时返回 null
140
+ */
141
+ LogicManager.prototype.run = async function (name, action, params, options) {
142
+ let drive = this.get(name);
143
+ if (!drive || drive.config.state !== 1) {
144
+ return null;
145
+ }
146
+ if (!drive.isLoaded() && drive.config.main) {
147
+ drive.load();
148
+ }
149
+ return await drive.run(action, params, options);
150
+ };
151
+
152
+ /**
153
+ * @module 导出逻辑管理器类
154
+ */
155
+ module.exports = LogicManager;
@@ -0,0 +1,15 @@
1
+ 'use strict';
2
+
3
+ /**
4
+ * 逻辑规则脚本模板
5
+ * 导出的每个函数都会按名称注册为逻辑处理方法,main 为默认入口
6
+ * @param {object} params 逻辑输入参数
7
+ * @param {object} options 运行上下文
8
+ * @param {object} logic 逻辑规则实例
9
+ * @returns {*} 逻辑处理结果
10
+ */
11
+ async function main(params, options, logic) {
12
+ return null;
13
+ }
14
+
15
+ module.exports = { main };
package/package.json CHANGED
@@ -1,6 +1,40 @@
1
1
  {
2
- "name": "mm_logic",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
2
+ "name": "mm_logic",
3
+ "version": "1.0.1",
4
+ "description": "游戏逻辑规则模块:以具名处理函数为单位注册与执行游戏规则,支持脚本加载、排序与生命周期管理,基于 mm_machine,内置管理器池",
5
+ "main": "index.js",
6
+ "files": [
7
+ "index.js",
8
+ "lib",
9
+ "tool",
10
+ "example"
11
+ ],
12
+ "keywords": [
13
+ "mm_mod",
14
+ "mm_infra",
15
+ "game",
16
+ "logic",
17
+ "rule",
18
+ "游戏逻辑"
19
+ ],
20
+ "layer": "action",
21
+ "group": "mode",
22
+ "author": "邱文武",
23
+ "license": "ISC",
24
+ "repository": {
25
+ "type": "git",
26
+ "url": "git+https://gitee.com/qiuwenwu91/mm_logic.git"
27
+ },
28
+ "dependencies": {
29
+ "mm_admin": "^1.1.0",
30
+ "mm_files": "^1.4.0",
31
+ "mm_machine": "^6.0.0"
32
+ },
33
+ "engines": {
34
+ "node": ">=18.0.0"
35
+ },
36
+ "scripts": {
37
+ "test": "node test.js",
38
+ "example": "node example/index.js"
39
+ }
40
+ }
@@ -0,0 +1,85 @@
1
+ 'use strict';
2
+
3
+ const { logicAdmin } = require('../../index.js');
4
+
5
+ /**
6
+ * 生成逻辑规则摘要
7
+ * @param {object} drive 逻辑规则实例
8
+ * @returns {object} 摘要信息
9
+ */
10
+ function summary(drive) {
11
+ const config = drive.config;
12
+ return {
13
+ name: config.name,
14
+ title: config.title,
15
+ description: config.description,
16
+ state: config.state,
17
+ sort: config.sort,
18
+ main: config.main,
19
+ methods: drive.list()
20
+ };
21
+ }
22
+
23
+ /**
24
+ * 游戏逻辑规则工具
25
+ * @param {object} params 参数:action/scope/name/method/params/config
26
+ * @param {object} ctx 执行上下文
27
+ * @returns {Promise<object>} 执行结果
28
+ */
29
+ async function main(params, ctx) {
30
+ const p = params || {};
31
+ const action = p.action || 'list';
32
+ const scope = p.scope || 'os';
33
+ const done = (data) => {
34
+ if (ctx) ctx.output = data;
35
+ return data;
36
+ };
37
+ try {
38
+ const manager = logicAdmin(scope);
39
+ if (action === 'list') {
40
+ const list = manager.values().map((drive) => summary(drive));
41
+ return done({ code: 0, msg: '获取成功', action, scope, count: list.length, list });
42
+ }
43
+ if (action === 'get') {
44
+ const drive = p.name ? manager.get(p.name) : null;
45
+ return done({
46
+ code: drive ? 0 : 10001,
47
+ msg: drive ? '获取成功' : '逻辑规则不存在',
48
+ action,
49
+ scope,
50
+ name: p.name,
51
+ config: drive ? summary(drive) : null
52
+ });
53
+ }
54
+ if (action === 'has') {
55
+ return done({ code: 0, msg: '查询成功', action, scope, name: p.name, exists: manager.has(p.name) });
56
+ }
57
+ if (action === 'add') {
58
+ if (!p.config || !p.config.name) {
59
+ throw new TypeError('config.name 不能为空');
60
+ }
61
+ const drive = manager.add(p.config);
62
+ return done({ code: 0, msg: '注册成功', action, scope, config: summary(drive) });
63
+ }
64
+ if (action === 'del') {
65
+ const ok = await manager.del(p.name);
66
+ return done({ code: 0, msg: ok ? '删除成功' : '逻辑规则不存在', action, scope, name: p.name, ok });
67
+ }
68
+ if (action === 'reload') {
69
+ const ok = await manager.reload(p.name);
70
+ return done({ code: 0, msg: ok ? '重启成功' : '重启失败', action, scope, name: p.name, ok });
71
+ }
72
+ if (action === 'run') {
73
+ if (!p.name) {
74
+ throw new TypeError('name 不能为空');
75
+ }
76
+ const result = await manager.run(p.name, p.method || 'main', p.params || {});
77
+ return done({ code: 0, msg: '执行成功', action, scope, name: p.name, method: p.method || 'main', result });
78
+ }
79
+ return done({ code: 10001, msg: '不支持的操作: ' + action });
80
+ } catch (error) {
81
+ return done({ code: 10000, msg: '执行失败:' + error.message, error: { name: error.name, message: error.message } });
82
+ }
83
+ }
84
+
85
+ module.exports = { main };
@@ -0,0 +1,94 @@
1
+ {
2
+ "name": "logic",
3
+ "title": "游戏逻辑规则执行",
4
+ "description": "基于 mm_logic 的逻辑规则能力:列出/查询已登记的逻辑规则、按名称执行指定处理函数、判断处理函数是否存在、登记/注销/重启逻辑规则。适用场景:按规则名结算战斗伤害、执行升级/掉落等游戏规则、检查规则是否已装载、在指定作用域内装配或释放规则脚本。工作流提示:run 传 name 与 method(缺省 main),params 为规则输入;add 传 config(须含 name,可选 main 脚本路径);get/has/del/reload 传 name。",
5
+ "category": "游戏逻辑",
6
+ "group": "logic",
7
+ "type": "function",
8
+ "main": "./index.js",
9
+ "params": {
10
+ "type": "object",
11
+ "properties": {
12
+ "action": {
13
+ "type": "string",
14
+ "description": "操作类型: list(规则清单)/get(规则详情)/has(处理方法是否存在)/add(登记规则)/del(注销规则)/reload(重启规则)/run(执行规则)",
15
+ "enum": [
16
+ "list",
17
+ "get",
18
+ "has",
19
+ "add",
20
+ "del",
21
+ "reload",
22
+ "run"
23
+ ],
24
+ "default": "list"
25
+ },
26
+ "scope": {
27
+ "type": "string",
28
+ "description": "作用域,缺省 os",
29
+ "default": "os"
30
+ },
31
+ "name": {
32
+ "type": "string",
33
+ "description": "逻辑规则名称(get/has/del/reload/run 使用)"
34
+ },
35
+ "method": {
36
+ "type": "string",
37
+ "description": "逻辑处理方法名(run 可选),缺省 main",
38
+ "default": "main"
39
+ },
40
+ "params": {
41
+ "type": "object",
42
+ "description": "逻辑输入参数(run 可选)"
43
+ },
44
+ "config": {
45
+ "type": "object",
46
+ "description": "逻辑规则配置对象(add 必填且须含 name)"
47
+ }
48
+ },
49
+ "required": [
50
+ "action"
51
+ ]
52
+ },
53
+ "returns": {
54
+ "type": "object",
55
+ "properties": {
56
+ "code": {
57
+ "type": "number",
58
+ "description": "0 表示成功,1xxxx 表示业务/执行异常"
59
+ },
60
+ "msg": {
61
+ "type": "string",
62
+ "description": "结果描述"
63
+ },
64
+ "count": {
65
+ "type": "number",
66
+ "description": "规则数量(list)"
67
+ },
68
+ "list": {
69
+ "type": "array",
70
+ "description": "规则摘要清单(list)"
71
+ },
72
+ "config": {
73
+ "type": "object",
74
+ "description": "规则摘要(get/add)"
75
+ },
76
+ "exists": {
77
+ "type": "boolean",
78
+ "description": "是否存在(has)"
79
+ },
80
+ "ok": {
81
+ "type": "boolean",
82
+ "description": "操作是否成功(del/reload)"
83
+ },
84
+ "result": {
85
+ "description": "逻辑处理结果(run)"
86
+ },
87
+ "error": {
88
+ "type": "object",
89
+ "description": "异常对象 { name, message }"
90
+ }
91
+ }
92
+ },
93
+ "handler": "manager"
94
+ }
@@ -0,0 +1,37 @@
1
+ 'use strict';
2
+
3
+ const { admin } = require('../../index.js');
4
+
5
+ /**
6
+ * 管理逻辑管理器实例池
7
+ * @param {object} params 参数:action/scope
8
+ * @param {object} ctx 执行上下文
9
+ * @returns {Promise<object>} 执行结果
10
+ */
11
+ async function main(params, ctx) {
12
+ const p = params || {};
13
+ const action = p.action || 'list';
14
+ const scope = p.scope || 'os';
15
+ const done = (data) => {
16
+ if (ctx) ctx.output = data;
17
+ return data;
18
+ };
19
+ try {
20
+ if (action === 'list') {
21
+ const scopes = [...admin.keys()];
22
+ return done({ code: 0, msg: '获取成功', action, count: scopes.length, scopes });
23
+ }
24
+ if (action === 'inspect') {
25
+ const exists = admin.has(scope);
26
+ const instance = exists ? admin.get(scope) : null;
27
+ return done({ code: 0, msg: exists ? '获取成功' : '实例不存在', action, scope, exists, config: instance && instance.config ? instance.config : null });
28
+ }
29
+ if (action === 'del') return done({ code: 0, msg: '删除成功', action, scope, ok: admin.del(scope) });
30
+ if (action === 'clear') { admin.clear(); return done({ code: 0, msg: '实例池已清空', action }); }
31
+ return done({ code: 10001, msg: '不支持的操作: ' + action });
32
+ } catch (error) {
33
+ return done({ code: 10000, msg: '执行失败:' + error.message, error: { name: error.name, message: error.message } });
34
+ }
35
+ }
36
+
37
+ module.exports = { main };
@@ -0,0 +1,71 @@
1
+ {
2
+ "name": "logic_admin",
3
+ "title": "逻辑管理器实例池管理",
4
+ "description": "管理 mm_logic 的逻辑管理器实例池:列出作用域、查看指定作用域的实例配置、删除或清空实例。适用场景:排查某作用域是否已装配逻辑管理器、释放不再使用的规则作用域。参数:action=list/inspect/del/clear,scope 缺省 os。",
5
+ "category": "游戏逻辑",
6
+ "group": "logic",
7
+ "type": "function",
8
+ "main": "./index.js",
9
+ "params": {
10
+ "type": "object",
11
+ "properties": {
12
+ "action": {
13
+ "type": "string",
14
+ "description": "操作类型: list(实例池清单)/inspect(实例详情)/del(删除实例)/clear(清空实例池)",
15
+ "enum": [
16
+ "list",
17
+ "inspect",
18
+ "del",
19
+ "clear"
20
+ ],
21
+ "default": "list"
22
+ },
23
+ "scope": {
24
+ "type": "string",
25
+ "description": "作用域,缺省 os",
26
+ "default": "os"
27
+ }
28
+ },
29
+ "required": [
30
+ "action"
31
+ ]
32
+ },
33
+ "returns": {
34
+ "type": "object",
35
+ "properties": {
36
+ "code": {
37
+ "type": "number",
38
+ "description": "0 表示成功,1xxxx 表示业务/执行异常"
39
+ },
40
+ "msg": {
41
+ "type": "string",
42
+ "description": "结果描述"
43
+ },
44
+ "count": {
45
+ "type": "number",
46
+ "description": "作用域数量(list)"
47
+ },
48
+ "scopes": {
49
+ "type": "array",
50
+ "description": "作用域清单(list)"
51
+ },
52
+ "exists": {
53
+ "type": "boolean",
54
+ "description": "实例是否存在(inspect)"
55
+ },
56
+ "config": {
57
+ "type": "object",
58
+ "description": "实例配置(inspect)"
59
+ },
60
+ "ok": {
61
+ "type": "boolean",
62
+ "description": "操作是否成功(del)"
63
+ },
64
+ "error": {
65
+ "type": "object",
66
+ "description": "异常对象 { name, message }"
67
+ }
68
+ }
69
+ },
70
+ "handler": "manager"
71
+ }