├── README.md
├── .gitignore
├── update.md
├── js
    ├── visitor.js
    ├── example.js
    ├── testcase.js
    └── 帮助.txt
└── LICENSE


/README.md:
--------------------------------------------------------------------------------
 1 | # BDSJSRunner-Release
 2 | Win版MC服务端下JS运行插件成品
 3 | 
 4 | 代码请移步腾讯云查看完整源码，详见
 5 | https://mzgl.coding.net/public/BDSJSRunner/BDSJSRunner/git/files
 6 | 
 7 | #### Commercial License
 8 | GPL
 9 | 
10 | 未经许可禁止商业用途和分发。
11 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | 


--------------------------------------------------------------------------------
/update.md:
--------------------------------------------------------------------------------
 1 | # 更新日志
 2 | 
 3 | #### 2020-04-16
 4 | 
 5 | 适配版本至1.14.60.5
 6 | 
 7 | 修复一个修改引入的设定能力值导致程序崩溃的问题；
 8 | 
 9 | 修复能力设定时权限设置不正确
10 | 
11 | 添加js测试用例到仓库
12 | 
13 | #### 2020-04-27
14 | 
15 | 添加玩家物品数据化及相关操作方法；小幅优化玩家装备列表
16 | 
17 | #### 2020-04-28
18 | 
19 | 小幅优化放置方块事件使可拦截，添加命令方块更新监听，爆炸事件监听
20 | 
21 | #### 2020-04-29
22 | 
23 | 小幅优化属性设置方法，提供玩家效果列表操作相关方法
24 | 
25 | #### 2020-04-30
26 | 
27 | 添加设置指令描述方法
28 | 
29 | 小幅优化爆炸监听传参
30 | 
31 | #### 2020-05-02
32 | 
33 | 添加命令方块（矿车）执行指令监听
34 | 
35 | #### 2020-05-03
36 | 
37 | 添加自定义bossbar显示相关功能
38 | 
39 | #### 2020-05-14
40 | 
41 | 添加结构导入导出方法
42 | 
43 | #### 2020-05-18
44 | 
45 | 调整优化结构导入导出功能，小幅优化nbt相关操作内存占用
46 | 
47 | #### 2020-05-22
48 | 
49 | 添加自定义侧边栏相关方法，小幅优化延时操作稳定性
50 | 
51 | #### 2020-06-12
52 | 
53 | 剔除一个引起崩服的非玩家属性
54 | 
55 | #### 2020-06-20
56 | 
57 | 修复一个背包含焰火之星时nbt解密崩服问题
58 | 
59 | #### 2020-06-24
60 | 
61 | 适配版本至1.16.0.2
62 | 
63 | #### 2020-06-25
64 | 
65 | 小幅优化放入取出事件监听；完善基本属性默认值与临时值设定方法
66 | 
67 | #### 2020-06-26
68 | 
69 | 修复一个放入取出可能导致开箱卡死的问题
70 | 
71 | #### 2020-06-29
72 | 
73 | 剔除可能引起崩服的容器放入取出事件监听，修复玩家伤害事件无法拦截的问题，添加玩家权限和游戏模式设定相关方法
74 | 
75 | #### 2020-06-30
76 | 
77 | 适配版本至1.16.1.2；添加NPC指令执行事件监听
78 | 
79 | #### 2020-07-01
80 | 
81 | 修订帮助文件错误示例
82 | 
83 | #### 2020-07-03
84 | 
85 | 小幅优化GUI 兼容无按钮情况


--------------------------------------------------------------------------------
/js/visitor.js:
--------------------------------------------------------------------------------
  1 | // 文件名：visitor
  2 | // 功能：提供后台visitor命令 强制玩家降级权限为访客
  3 | 
  4 | 
  5 | /******************************** 预处理设置区 ********************************/
  6 | 
  7 | var FUCTION_EXLOG = 'FUCTION_EXLOG';
  8 | 
  9 | let _VISITOR_OFF = false;
 10 | 
 11 | // 使用一个共享函数
 12 | let examplelog = null;
 13 | 
 14 | // 打印调试信息
 15 | function _VISITOR_PR(e) {
 16 | 	if (!_VISITOR_OFF) {
 17 | 		if (examplelog != null)
 18 | 			examplelog(e);
 19 | 		else {
 20 | 			let f = getShareData(FUCTION_EXLOG);
 21 | 			examplelog = (f != null) ? f :
 22 | 				function (e) {
 23 | 					log('[visitor]' + e);
 24 | 				};
 25 | 			examplelog(e);
 26 |         }
 27 | 	}
 28 | }
 29 | 
 30 | // tellraw 回传消息
 31 | function _visitor_tellrawmsg(pname, msg) {
 32 | 	let rawtxt = {};
 33 | 	rawtxt.rawtext = [];
 34 | 	let text = {};
 35 | 	text.text = msg;
 36 | 	rawtxt.rawtext.push(text);
 37 | 	runcmd('tellraw ' + '"' + pname + '" ' + JSON.stringify(rawtxt));
 38 | }
 39 | 
 40 | // 将玩家名写入权限配置文件，并更新权限
 41 | function _visitor_permission(pname) {
 42 | 	let plstr = getOnLinePlayers();
 43 | 	if (plstr != null) {
 44 | 		let xuid = "";
 45 | 		jpl = JSON.parse(plstr);
 46 | 		if (jpl != null) {
 47 | 			for (let i = 0; i < jpl.length; i++) {
 48 | 				let jp = jpl[i];
 49 | 				if (jp.playername == pname) {	// 找到
 50 | 					xuid = jp.xuid;
 51 | 					break;
 52 | 				}
 53 | 			}
 54 | 		}
 55 | 		if (xuid != "") {
 56 | 			// 将此xuid加入到权限配置文件中
 57 | 			let pelstr = fileReadAllText('permissions.json');
 58 | 			let pel = [];
 59 | 			let finded = false;
 60 | 			if (pelstr != null && pelstr != "") {
 61 | 				pel = JSON.parse(pelstr);	// 获取老的权限配置信息
 62 | 			}
 63 | 			for (let i = 0; i < pel.length; i++) {
 64 | 				let jpe = pel[i];
 65 | 				if (jpe.xuid == xuid) {		// 找到
 66 | 					jpe.permission = "visitor";
 67 | 					finded = true;
 68 | 					break;
 69 | 				}
 70 | 			}
 71 | 			if (!finded) {	// 未能找到旧配置信息，将新增信息
 72 | 				let j = {};
 73 | 				j.permission = "visitor";
 74 | 				j.xuid = xuid;
 75 | 				pel.push(j);
 76 | 			}
 77 | 			fileWriteAllText('permissions.json', JSON.stringify(pel));	// 保存新配置
 78 | 			setTimeout(function () {
 79 | 				runcmd("permission reload");	// 重载权限配置
 80 | 				_visitor_tellrawmsg(pname, "您已被降级权限为访客。");
 81 | 			}, 10);
 82 | 			return;
 83 | 		}
 84 | 	}
 85 | 	_VISITOR_PR("未能正确降级玩家" + pname + "，请检查该玩家是否在线。");
 86 | }
 87 | 
 88 | // 解析字符串
 89 | function _visitor_trans(cmd) {
 90 | 	let rcmd = cmd.trim();
 91 | 	if (rcmd == "")		// 空白字符串 不作处理
 92 | 		return true;
 93 | 	let cmdstrs = rcmd.split(' ');
 94 | 	if (cmdstrs.length > 0) {
 95 | 		if (cmdstrs[0] == 'visitor') {	// 进入命令
 96 | 			let playername = rcmd.substr(7).trim();
 97 | 			_visitor_permission(playername);
 98 | 			return false;
 99 | 		}
100 | 	}
101 | 	return true;
102 | }
103 | 
104 | /******************************** 监听器设置区 ********************************/
105 | 
106 | // 待管理多监听器
107 | var _visitor_ofs = {};
108 | 
109 | // 服务器指令回调
110 | setBeforeActListener('onServerCmd', function (e) {
111 | 	let je = JSON.parse(e);
112 | 	let r = _visitor_trans(je.cmd);
113 | 	if (!r)
114 | 		return false;	// 直接拦截
115 | 	return true;
116 | });
117 | 
118 | _VISITOR_PR('visitor 已加载。用法：visitor [玩家名]');


--------------------------------------------------------------------------------
/js/example.js:
--------------------------------------------------------------------------------
  1 | // 文件名：example.js
  2 | // 文件功能：示例简单的监控信息
  3 | 
  4 | function examplelog(e) {
  5 | 	log('{' + e);
  6 | }
  7 | // 设置一个共享函数以供其它js文件调用
  8 | setShareData('FUCTION_EXLOG', examplelog);
  9 | 
 10 | // 待写入文本队列
 11 | var flogs = [];
 12 | 
 13 | // 取文本队列中文本并写入 使用延时方式调用此方法
 14 | function saveOneLog() {
 15 | 	let x = flogs.shift();
 16 | 	if (x != null) {
 17 | 		fileWriteLine('jslog.txt', x);
 18 | 	}
 19 | }
 20 | 
 21 | // 匿名方式设置攻击事件前监听器
 22 | setBeforeActListener('onAttack', function (e) {
 23 | 	var je = JSON.parse(e);
 24 | 	var str = '[测试]' + ' 玩家 ' + je.playername + ' 即将发动攻击。';
 25 | 	examplelog(str);
 26 | 	// 事件内随时可进行mc指令执行
 27 | 	runcmd('title ' + je.playername + ' actionbar （测试）举起手来！');
 28 | 	// 事件内随时可保存信息至外部文件
 29 | 	flogs.push(str);
 30 | 	setTimeout(saveOneLog, 1);
 31 | 	// 事件内随时可读取外部信息文件或执行外部脚本
 32 | 	// var outcmd = fileReadAllText('outjs.js');
 33 | 	// runScript(outcmd);
 34 | 	return true;	// 如果返回false，则表示拦截该事件的执行
 35 | });
 36 | 
 37 | // 匿名方式设置攻击事件后监听器
 38 | setAfterActListener('onAttack', function (e) {
 39 | 	var je = JSON.parse(e);
 40 | 	var sp = JSON.stringify(je.XYZ);
 41 | 	var tnow = TimeNow();
 42 | 	var str = '[' + tnow + ' AfterAttack] ' + '玩家 ' + je.playername + ' 在 ' +
 43 | 		je.dimension + ' ' + sp + ' 处攻击了 ' + je.actortype + '。';
 44 | 	examplelog(str);
 45 | 	flogs.push(str);
 46 | 	setTimeout(saveOneLog, 1);
 47 | });
 48 | 
 49 | // 命名函数，监听使用物品前事件
 50 | //function beforeOnUseItem(e){
 51 | //	var je = JSON.parse(e);
 52 | //	log(je.playername + '想要使用物品');
 53 | //	return true;	// 此处或可添加坐标判断实现禁使用物品操作
 54 | //}
 55 | // 设置使用物品前事件监听器
 56 | //setBeforeActListener('onUseItem', beforeOnUseItem);
 57 | 
 58 | 
 59 | // 命名函数，监听使用物品后事件
 60 | function afterUseItem(e) {
 61 | 	var je = JSON.parse(e);
 62 | 	if (je.result) {
 63 | 		var tnow = TimeNow();
 64 | 		var str = '[' + tnow + ' AfterUseItem] ' + '玩家 ' + je.playername +
 65 | 			' 于(' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ')位置' +
 66 | 			(!je.isstand ? ' 悬空地' : '') + ' 在 ' + je.dimension +
 67 | 			' (' + je.position.x + ',' + je.position.y + ',' + je.position.z + ') 处使用了 '
 68 | 			+ je.itemname + ' 物品。';
 69 | 		examplelog(str);
 70 | 		flogs.push(str);
 71 | 		setTimeout(saveOneLog, 1);
 72 | 	}
 73 | }
 74 | // 设置使用物品后事件监听器
 75 | setAfterActListener('onUseItem', afterUseItem);
 76 | 
 77 | // 放置方块后回调
 78 | setAfterActListener('onPlacedBlock', function (e) {
 79 | 	var je = JSON.parse(e);
 80 | 	if (je.result) {
 81 | 		var tnow = TimeNow();
 82 | 		var str = '[' + tnow + ' AfterPlaceBlock] ' + '玩家 ' + je.playername +
 83 | 			' 于(' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ')位置' +
 84 | 			(!je.isstand ? ' 悬空地' : '') + ' 在 ' + je.dimension +
 85 | 			' (' + je.position.x + ',' + je.position.y + ',' + je.position.z + ') 处放置了 '
 86 | 			+ je.blockname + ' 方块。';
 87 | 		examplelog(str);
 88 | 		flogs.push(str);
 89 | 		setTimeout(saveOneLog, 1);
 90 |     }
 91 | });
 92 | 
 93 | // 破坏方块后触发回调
 94 | setAfterActListener('onDestroyBlock', function (e) {
 95 | 	var je = JSON.parse(e);
 96 | 	if (je.result) {
 97 | 		var tnow = TimeNow();
 98 | 		var str = '[' + tnow + ' AfterDestroyBlock] ' + '玩家 ' + je.playername +
 99 | 			' 于(' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ')位置' +
100 | 			(!je.isstand ? ' 悬空地' : '') + ' 在 ' + je.dimension +
101 | 			' (' + je.position.x + ',' + je.position.y + ',' + je.position.z + ') 处破坏了 '
102 | 			+ je.blockname + ' 方块。';
103 | 		examplelog(str);
104 | 		flogs.push(str);
105 | 		setTimeout(saveOneLog, 1);
106 | 	}
107 | });
108 | 
109 | 
110 | // 开箱前回调
111 | setBeforeActListener('onStartOpenChest', function (e) {
112 | 	var je = JSON.parse(e);
113 | 	var tnow = TimeNow();
114 | 	var str = '[' + tnow + ' BeforeOpenChest] ' + '玩家 ' + je.playername +
115 | 		' 于(' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ')位置' +
116 | 		(!je.isstand ? ' 悬空地' : '') + ' 试图在 ' + je.dimension +
117 | 		' (' + je.position.x + ',' + je.position.y + ',' + je.position.z + ') 处打开箱子。';
118 | 	examplelog(str);
119 | 	flogs.push(str);
120 | 	setTimeout(saveOneLog, 1);
121 | 	return true;	// 此处或可添加坐标判断实现锁箱操作
122 | });
123 | 
124 | 
125 | // 开桶前回调
126 | setBeforeActListener('onStartOpenBarrel', function (e) {
127 | 	var je = JSON.parse(e);
128 | 	var tnow = TimeNow();
129 | 	var str = '[' + tnow + ' BeforeOpenBarrel] ' + '玩家 ' + je.playername +
130 | 		' 于(' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ')位置' +
131 | 		(!je.isstand ? ' 悬空地' : '') + ' 试图在 ' + je.dimension +
132 | 		' (' + je.position.x + ',' + je.position.y + ',' + je.position.z + ') 处打开木桶。';
133 | 	examplelog(str);
134 | 	flogs.push(str);
135 | 	setTimeout(saveOneLog, 1);
136 | 	return true;	// 此处或可添加坐标判断实现锁桶操作
137 | });
138 | 
139 | 
140 | // 放入取出物品后回调
141 | setAfterActListener('onSetSlot', function (e) {
142 | 	var je = JSON.parse(e);
143 | 	var tnow = TimeNow();
144 | 	var str = '[' + tnow + ' AfterSetSlot] ' + '玩家 ' + je.playername +
145 | 		' 于(' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ')位置' +
146 | 		(!je.isstand ? ' 悬空地' : '') + ' 在 ' + je.dimension +
147 | 		' (' + je.position.x + ',' + je.position.y + ',' + je.position.z + ') 处的 ' +
148 | 		je.blockname + ' 内的第 ' + je.slot + ' 槽内 ' +
149 | 		(je.itemcount > 0 ? '放入了 ' + je.itemcount + ' 个 ' + je.itemname + ' 物品。' :
150 | 			'取出了物品。');
151 | 	examplelog(str);
152 | 	flogs.push(str);
153 | 	setTimeout(saveOneLog, 1);
154 | });
155 | 
156 | 
157 | // 关箱后回调
158 | setAfterActListener('onStopOpenChest', function (e) {
159 | 	var je = JSON.parse(e);
160 | 	var tnow = TimeNow();
161 | 	var str = '[' + tnow + ' AfterStopOpenChest] ' + '玩家 ' + je.playername +
162 | 		' 于(' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ')位置' +
163 | 		(!je.isstand ? ' 悬空地' : '') + ' 在 ' + je.dimension +
164 | 		' (' + je.position.x + ',' + je.position.y + ',' + je.position.z + ') 处关闭了箱子。';
165 | 	examplelog(str);
166 | 	flogs.push(str);
167 | 	setTimeout(saveOneLog, 1);
168 | });
169 | 
170 | 
171 | // 关桶后回调
172 | setAfterActListener('onStopOpenBarrel', function (e) {
173 | 	var je = JSON.parse(e);
174 | 	var tnow = TimeNow();
175 | 	var str = '[' + tnow + ' AfterStopOpenBarrel] ' + '玩家 ' + je.playername +
176 | 		' 于(' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ')位置' +
177 | 		(!je.isstand ? ' 悬空地' : '') + ' 在 ' + je.dimension +
178 | 		' (' + je.position.x + ',' + je.position.y + ',' + je.position.z + ') 处关闭了木桶。';
179 | 	examplelog(str);
180 | 	flogs.push(str);
181 | 	setTimeout(saveOneLog, 1);
182 | });
183 | 
184 | 
185 | // 切换维度回调
186 | setAfterActListener('onChangeDimension', function (e) {
187 | 	var je = JSON.parse(e);
188 | 	if (je.result) {
189 | 		var tnow = TimeNow();
190 | 		var str = '[' + tnow + ' AfterChangeDimension] ' + '玩家 ' + je.playername +
191 | 			(!je.isstand ? ' 悬空地' : '') + ' 切换维度至 ' + je.dimension +
192 | 			' (' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ') 处。';
193 | 		examplelog(str);
194 | 		flogs.push(str);
195 | 		setTimeout(saveOneLog, 1);
196 | 	}
197 | });
198 | 
199 | 
200 | // 生物死亡信息回调
201 | setAfterActListener('onMobDie', function (e) {
202 | 	var je = JSON.parse(e);
203 | 	if (je.mobname != "") {
204 | 		var tnow = TimeNow();
205 | 		var str = '[' + tnow + ' DeathInfo] ' + je.mobname + ' 被 ' + je.srcname + ' 杀死了';
206 | 		examplelog(str);
207 | 		flogs.push(str);
208 | 		setTimeout(saveOneLog, 1);
209 |     }
210 | });
211 | 
212 | // 生物受伤监听
213 | setAfterActListener('onMobHurt', function (e) {
214 | 	var je = JSON.parse(e);
215 | 	if (je.mobname != "" && je.result) {
216 | 		var tnow = TimeNow();
217 | 		var str = '[' + tnow + ' HurtInfo] ' + je.mobname + ' 受到来自 ' + je.srcname + ' 的 ' + je.dmcount + ' 点伤害，类型' + je.dmtype;
218 | 		examplelog(str);
219 | 	}
220 | });
221 | 
222 | // 玩家重生回调
223 | setAfterActListener('onRespawn', function (e) {
224 | 	var je = JSON.parse(e);
225 | 	var tnow = TimeNow();
226 | 	var str = '[' + tnow + ' AfterRespawn] 玩家 ' + je.playername + ' 已于 ' + je.dimension +
227 | 		' (' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ') 处重生。';
228 | 	examplelog(str);
229 | 	flogs.push(str);
230 | 	setTimeout(saveOneLog, 1);
231 | });
232 | 
233 | 
234 | // 玩家输入文本回调
235 | setBeforeActListener('onInputText', function (e) {
236 | 	var je = JSON.parse(e);
237 | 	examplelog('<' + je.playername + '> ' + je.msg);
238 | 	return true;
239 | });
240 | 
241 | 
242 | // 玩家输入指令回调
243 | setBeforeActListener('onInputCommand', function (e) {
244 | 	let je = JSON.parse(e);
245 | 	examplelog('<' + je.playername + '> ' + je.cmd);
246 | 	return true;
247 | });
248 | 
249 | 
250 | // 聊天回调
251 | setAfterActListener('onChat', function (e) {
252 | 	var je = JSON.parse(e);
253 | 	if (je.chatstyle != "title") {
254 | 		var tnow = TimeNow();
255 | 		var str = '[' + tnow + ' Chat] ' + je.playername +
256 | 			(je.target != '' ? ' 悄悄地对 ' + je.target : '') +
257 | 			' 说: ' + je.msg;
258 | 		examplelog(str);
259 | 		flogs.push(str);
260 | 		setTimeout(saveOneLog, 1);
261 | 	}
262 | });
263 | 
264 | // 玩家修改命令块回调
265 | setBeforeActListener('onCommandBlockUpdate', function (e) {
266 | 	var je = JSON.parse(e);
267 | 	var tnow = TimeNow();
268 | 	var str = '[' + tnow + ' AfterCommandBlockUpdate] ' + '玩家 ' + je.playername +
269 | 		' 于(' + je.XYZ.x + ',' + je.XYZ.y + ',' + je.XYZ.z + ')位置' +
270 | 		(!je.isstand ? ' 悬空地' : '') + ' 在 ' + je.dimension +
271 | 		' (' + je.position.x + ',' + je.position.y + ',' + je.position.z + ') 处试图修改 '
272 | 		+ (je.isblock ? '命令块' : '命令矿车') + ' 的指令为 ' + je.cmd + '。';
273 | 	examplelog(str);
274 | 	flogs.push(str);
275 | 	setTimeout(saveOneLog, 1);
276 | 	return true;	// 此处或可拦截命令块更改命令
277 | });
278 | 
279 | setBeforeActListener('onLevelExplode', function (e) {
280 | 	var je = JSON.parse(e);
281 | 	var tnow = TimeNow();
282 | 	var str = '[' + tnow + ' BeforeExplode] ' + je.dimension + ' 的(' +
283 | 		je.position.x + ',' + je.position.y + ',' + je.position.z + ')位置 试图发生由 ' +
284 | 		je.entity + ' 引发的爆炸。';
285 | 	examplelog(str);
286 | 	flogs.push(str);
287 | 	setTimeout(saveOneLog, 1);
288 | 	return true;	// 此处或可拦截爆炸事件
289 | });
290 | 
291 | // 服务器指令回调
292 | //setBeforeActListener('onServerCmd', function (e) {
293 | //	let je = JSON.parse(e);
294 | //	return true;	// 此处或可拦截后台输入的指令
295 | //});
296 | 
297 | // 命令方块指令回调
298 | //setBeforeActListener('onBlockCmd', function (e) {
299 | //	let je = JSON.parse(e);
300 | //	return true;	// 此处或可拦截命令方块及命令方块矿车指令的执行
301 | //});
302 | 
303 | // NPC指令回调
304 | //setBeforeActListener('onNpcCmd', function (e) {
305 | //	let je = JSON.parse(e);
306 | //	return true;	// 此处或可拦截NPC指令的执行
307 | //});
308 | 
309 | // 服务器指令执行输出回调
310 | //setBeforeActListener('onServerCmdOutput', function (e) {
311 | //	let je = JSON.parse(e);
312 | //	return true;	// 此处或可拦截后台指令输出信息
313 | //});
314 | 
315 | // 玩家选择GUI菜单回调
316 | //setBeforeActListener('onFormSelect', function (e) {
317 | //	let je = JSON.parse(e);
318 | //	return true;
319 | //});
320 | 
321 | // 装载名字回调
322 | //setAfterActListener('onLoadName', function (e) {
323 | //	var je = JSON.parse(e);
324 | //	log(je.playername + '已装载入游戏，xuid=' + je.xuid);
325 | //});
326 | 
327 | // 玩家离开游戏回调
328 | //setAfterActListener('onPlayerLeft', function (e) {
329 | //	let je = JSON.parse(e);
330 | //	log(je.playername + '已离开游戏，xuid=' + je.xuid);
331 | //});
332 | 
333 | // 玩家移动回调
334 | //setAfterActListener('onMove', function (e) {
335 | //	var je = JSON.parse(e);
336 | //	// 此处或可根据玩家位置设置移动监听
337 | //});
338 | 
339 | // 执行一条远程http请求
340 | //request('http://localhost:8088/farcmd.ashx', 'GET', 'user=administrator&password=654321&cmd=me 你好', function (e) {
341 | //	log(e);
342 | //});
343 | 
344 | examplelog('example 已装载至文件末尾');


--------------------------------------------------------------------------------
/js/testcase.js:
--------------------------------------------------------------------------------
  1 | // 文件名：testcase
  2 | // 文件功能：测试附加功能是否正常
  3 | 
  4 | /******************************** 预处理设置区 ********************************/
  5 | 
  6 | // 表单事件处理器
  7 | var formcallback = {};
  8 | // 表单超时计时器
  9 | var timeouts = {};
 10 | 
 11 | // 临时状态
 12 | var tmpeff = "";
 13 | // 临时侧边栏计数器
 14 | var sidecount = {};
 15 | 
 16 | function getUuid(p) {
 17 | 	let pl = getOnLinePlayers();
 18 | 	if (pl != null) {
 19 | 		let jpl = JSON.parse(pl);
 20 | 		if (jpl != null) {
 21 | 			for (let i = 0, l = jpl.length; i < l; i++) {
 22 | 				let jp = jpl[i];
 23 | 				if (jp.playername == p)	// 找到
 24 | 					return jp.uuid;
 25 |             }
 26 |         }
 27 | 	}
 28 | 	return null;
 29 | }
 30 | 
 31 | const strtest = ['后台指令tell', '前缀/去前缀名', '穿墙能力开/关', '传送至梦之故里大厅', '跨维传送至末地祭坛', '模拟喊话', '模拟执行me指令',
 32 | 	'查询当前状态至后台', '读当前属性值至后台', '临时攻击+10,生命+2,附命+2,抗飞+1,等级+5,食物+2', '读属性上限值至后台', '攻限+10,命限+10,食限+10',
 33 | 	'读当前选中物品至后台', '给32个白桦木', '给1个附魔叉', '替换副手为一个叉子', '保存玩家所有物品列表至pit.json并清空',
 34 | 	'读pit.json到当前玩家', '读玩家当前效果列表到后台', '设置玩家临时存储的效果列表', '显示欢迎一个血条', '清除欢迎血条',
 35 | 	'显示一个带统计的自定义侧边栏', '移除自定义侧边栏', '读当前权限与游戏模式至后台', '切换op/visitor，生存/生存观察者模式',
 36 | 	'导出当前位置+长宽高x10的结构到st1.json','读结构st1.json到当前位置'];
 37 | 
 38 | // 定义前缀、取消前缀
 39 | function cusName(p) {
 40 | 	const pre = '[前缀]';
 41 | 	let i = p.indexOf(pre);
 42 | 	if (i > -1) {
 43 | 		return p.substring(pre.length);
 44 | 	}
 45 | 	return pre + p;
 46 | }
 47 | 
 48 | // 针对某玩家进行测试
 49 | function testcasefunc(p) {
 50 | 	let uuid = getUuid(p);
 51 | 	if (uuid != null) {
 52 | 		// 即将进入测试环节
 53 | 		let ghandle = sendSimpleForm(uuid, '测试用例', '请在30秒内做出选择测试项：', JSON.stringify(strtest));
 54 | 		let strhandle = "" + ghandle;
 55 | 		timeouts[strhandle] = Date.now();	// 设置一个计时器
 56 | 		formcallback[strhandle] = function (e) {
 57 | 			timeouts[strhandle] = null;	// 撤计时器
 58 | 			delete timeouts[strhandle];
 59 | 			switch (e.selected) {
 60 | 				case "0":
 61 | 					runcmd('tell "' + p + '" 你好 js');
 62 | 					break;
 63 | 				case "1":
 64 | 					reNameByUuid(uuid, cusName(p));
 65 | 					break;
 66 | 				case "2":
 67 | 					{
 68 | 						let sa = getPlayerAbilities(uuid);
 69 | 						if (sa != null) {
 70 | 							let ja = JSON.parse(sa);
 71 | 							let cja = {};
 72 | 							cja.noclip = !ja.noclip;
 73 | 							setPlayerAbilities(uuid, JSON.stringify(cja));
 74 |                         }
 75 | 					}
 76 | 					break;
 77 | 				case "3":
 78 | 					transferserver(uuid, 'www.xiafox.com', 19132);
 79 | 					break;
 80 | 				case "4":
 81 | 					teleport(uuid, 10, 99, 10, 2);
 82 | 					break;
 83 | 				case "5":
 84 | 					talkAs(uuid, '你好 js');
 85 | 					break;
 86 | 				case "6":
 87 | 					runcmdAs(uuid, '/me 你好 js');
 88 | 					break;
 89 | 				case "7":
 90 | 					{
 91 | 						let ope = selectPlayer(uuid);
 92 | 						if (ope != null) {
 93 | 							let opje = JSON.parse(ope);
 94 | 							var str = '玩家 ' + opje.playername + ' 已于 ' + opje.dimension +
 95 | 								' (' + opje.XYZ.x + ',' + opje.XYZ.y + ',' + opje.XYZ.z + ') 处被查询，当前生命值为'
 96 | 								+ opje.health + '。';
 97 | 							logout(str);
 98 |                         }
 99 | 					}
100 | 					break;
101 | 				case "8":
102 | 					logout(getPlayerAttributes(uuid));
103 | 					break;
104 | 				case "9":
105 | 					{
106 | 						let sa = getPlayerAttributes(uuid);
107 | 						if (sa != null) {
108 | 							let ja = JSON.parse(sa);
109 | 							let cja = {};
110 | 							cja.attack_damage = ja.attack_damage + 10;
111 | 							cja.absorption = ja.absorption + 2;
112 | 							cja.health = ja.health + 2;
113 | 							cja.knockback_resistance = ja.knockback_resistance + 1;
114 | 							cja.level = ja.level + 5;
115 | 							cja.hunger = ja.hunger + 2;
116 | 							// setPlayerAttributes(uuid, JSON.stringify(cja));	// 过期方法，不推荐
117 | 							setPlayerTempAttributes(uuid, JSON.stringify(cja));
118 | 						}
119 |                     }
120 | 					break;
121 | 				case "10":
122 | 					logout(getPlayerMaxAttributes(uuid));
123 | 					break;
124 | 				case "11":
125 | 					{
126 | 						let sa = getPlayerMaxAttributes(uuid);
127 | 						if (sa != null) {
128 | 							let ja = JSON.parse(sa);
129 | 							let cja = {};
130 | 							cja.maxattack_damage = ja.maxattack_damage + 10;
131 | 							cja.maxhealth = ja.maxhealth + 10;
132 | 							cja.maxhunger = ja.maxhunger + 10;
133 | 							setPlayerMaxAttributes(uuid, JSON.stringify(cja));
134 | 						}
135 | 					}
136 | 					break;
137 | 				case "12":
138 | 					logout(getPlayerSelectedItem(uuid));
139 | 					break;
140 | 				case "13":
141 | 						addPlayerItem(uuid, 17, 2, 32);
142 | 						break;
143 | 				case "14":
144 | 					{
145 | 						// tt - TAG_TYPE		标签数据类型，总计11种类型
146 | 						// tv - TAG_VALUE		标签值，由类型决定
147 | 						// ck - Compound_KEY	nbt关键字，字符串类型
148 | 						// cv - Compound_VALUE	nbt值，总是为一个TAG
149 | 						let jitem = {
150 | 							"tt": 10, "tv": [
151 | 								{ "ck": "Count", "cv": { "tt": 1, "tv": 1 } },
152 | 								{ "ck": "Damage", "cv": { "tt": 2, "tv": 0 } },
153 | 								{ "ck": "Name", "cv": { "tt": 8, "tv": "minecraft:trident" } },
154 | 								{ "ck": "tag", "cv": { "tt": 10, "tv": [
155 | 										{ "ck": "ench", "cv": { "tt": 9, "tv": [
156 | 											{ "tt": 10, "tv": [
157 | 														{ "ck": "id", "cv": { "tt": 2, "tv": 10 } },
158 | 														{ "ck": "lvl", "cv": { "tt": 2, "tv": 9999 } }]
159 | 											}]}
160 | 										}]}
161 | 								}]
162 | 						};
163 | 						addPlayerItemEx(uuid, JSON.stringify(jitem));
164 |                     }
165 | 					break;
166 | 				case "15":
167 | 					{
168 | 						let jtem = {
169 | 							"Offhand": { "tt": 9, "tv": [
170 | 									{ "tt": 10, "tv": [
171 | 											{ "ck": "Count", "cv": { "tt": 1, "tv": 1 } },
172 | 											{ "ck": "Damage", "cv": { "tt": 2, "tv": 0 } },
173 | 											{ "ck": "Name", "cv": { "tt": 8, "tv": "minecraft:trident" } },
174 | 											{ "ck": "tag", "cv": { "tt": 10, "tv": [
175 | 														{ "ck": "ench", "cv": {
176 | 																"tt": 9, "tv": [
177 | 																	{ "tt": 10, "tv": [
178 | 																			{ "ck": "id", "cv": { "tt": 2, "tv": 7 } },
179 | 																			{ "ck": "lvl", "cv": { "tt": 2, "tv": 8888 } }]
180 | 																	}]}
181 | 														}]}
182 | 											}]
183 | 									}]}
184 | 						};
185 | 						setPlayerItems(uuid, JSON.stringify(jtem));
186 |                     }
187 | 					break;
188 | 				case "16":
189 | 					{
190 | 						let its = getPlayerItems(uuid);
191 | 						fileWriteAllText('pit.json', its);
192 | 						// 此处使用空气填充末影箱
193 | 						let sair = '{"tt":10,"tv":[{"ck":"Count","cv":{"tt":1,"tv":0}},{"ck":"Damage","cv":{"tt":2,"tv":0}},{"ck":"Name","cv":{"tt":8,"tv":""}},{"ck":"Slot","cv":{"tt":1,"tv":0}}]}';
194 | 						//let air = { "tt": 10, "tv": [{ "ck": "Count", "cv": { "tt": 1, "tv": 0 } }, { "ck": "Damage", "cv": { "tt": 2, "tv": 0 } }, { "ck": "Name", "cv": { "tt": 8, "tv": "" } }, { "ck": "Slot", "cv": { "tt": 1, "tv": 0 } }] };
195 | 						let endc = {};
196 | 						endc.EnderChestInventory = {};
197 | 						endc.EnderChestInventory.tt = 9;	// Type ListTag
198 | 						endc.EnderChestInventory.tv = [];
199 | 						for (let i = 0; i < 27; i++) {
200 | 							let mair = JSON.parse(sair);
201 | 							if (mair.tv[3].ck == "Slot") {		// 此处需修改并应用
202 | 								mair.tv[3].cv.tv = i;
203 |                             }
204 | 							endc.EnderChestInventory.tv.push(mair);
205 | 						}
206 | 						setPlayerItems(uuid, JSON.stringify(endc));
207 | 						runcmd('clear "' + p + '"');
208 | 					}
209 | 					break;
210 | 				case "17":
211 | 					{
212 | 						let its = fileReadAllText('pit.json');
213 | 						if (its != null) {
214 | 							setPlayerItems(uuid, its);
215 |                         }
216 |                     }
217 | 					break;
218 | 				case "18":
219 | 					{
220 | 						let efs = getPlayerEffects(uuid);
221 | 						tmpeff = efs;
222 | 						log(efs);
223 | 					}
224 | 					break;
225 | 				case "19":
226 | 					{
227 | 						setPlayerEffects(uuid, tmpeff);
228 | 					}
229 | 					break;
230 | 				case "20":
231 | 					setPlayerBossBar(uuid, '欢迎使用JSRunner自定义血条！', Math.random());
232 | 					break;
233 | 				case "21":
234 | 					removePlayerBossBar(uuid);
235 | 					break;
236 | 				case "22":
237 | 					if (sidecount[uuid] == null) {
238 | 						sidecount[uuid] = 0;
239 | 					}
240 | 					++sidecount[uuid];
241 | 					let list = [];
242 | 					list.push("第" + sidecount[uuid] + "次打开侧边栏    ");
243 | 					list.push("这是第二行 ");
244 | 					list.push("这是下一行 ");
245 | 					list.push("属性：[待填写] ");
246 | 					list.push("§e颜色自拟 ");
247 | 					setPlayerSidebar(uuid, p + '的侧边栏', JSON.stringify(list));
248 | 					break;
249 | 				case "23":
250 | 					removePlayerSidebar(uuid);
251 | 					break;
252 | 				case "24":
253 | 					log(getPlayerPermissionAndGametype(uuid));
254 | 					break;
255 | 				case "25":
256 | 					let st = getPlayerPermissionAndGametype(uuid);
257 | 					let t = JSON.parse(st);
258 | 					if (t != null) {
259 | 						if (t.gametype == 0) {
260 | 							t.gametype = 3;
261 | 						} else {
262 | 							t.gametype = 0;
263 | 						}
264 | 						if (t.permission == 0) {
265 | 							t.permission = 2;
266 | 						} else
267 | 							t.permission = 0;
268 | 						setPlayerPermissionAndGametype(uuid, JSON.stringify(t));
269 |                     }
270 | 					break;
271 | 				case "26":
272 | 					{
273 | 						let posa = e.XYZ;
274 | 						let posb = {};
275 | 						posa.x = Number.parseInt(posa.x);
276 | 						posa.y = Number.parseInt(posa.y);
277 | 						posa.z = Number.parseInt(posa.z);
278 | 						posb.x = posa.x + 10;
279 | 						posb.y = posa.y + 10;
280 | 						posb.z = posa.z + 10;
281 | 						let data = getStructure(e.dimensionid, JSON.stringify(posa), JSON.stringify(posb), false, true);
282 | 						fileWriteAllText('st1.json', data);
283 |                     }
284 | 					break;
285 | 				case "27":
286 | 					{
287 | 						let data = fileReadAllText('st1.json');
288 | 						setStructure(data, e.dimensionid, JSON.stringify(e.XYZ), 0, true, true);
289 |                     }
290 | 					break;
291 | 				case "null":
292 | 					log('玩家' + p + '取消了选择测试项。');
293 | 					break;
294 | 			}
295 | 			formcallback[strhandle] = null;		// 撤回调处理
296 | 			delete formcallback[strhandle];
297 | 		};
298 | 		setTimeout(function () {	// 超时检测
299 | 			if (timeouts[strhandle] != null) {
300 | 				let nat = Date.now();
301 | 				log('当前待选择时间：' + nat + ',预设时间：' + timeouts[strhandle]);
302 | 				if (nat - timeouts[strhandle] > 30000) {
303 | 					// 超时
304 | 					log('玩家' + p + '的表单已超时, fid=' + strhandle);
305 | 					releaseForm(ghandle);
306 | 					formcallback[strhandle] = null;
307 | 					delete formcallback[strhandle];
308 | 					timeouts[strhandle] = null;
309 | 					delete timeouts[strhandle];
310 | 				}
311 | 			}
312 | 		}, 31000);
313 |     }
314 | }
315 | 
316 | function _testcase_trans(c, p) {
317 | 	let dc = c.trim();
318 | 	if (dc == '/testcase') {		// 进入检测环节
319 | 		setTimeout('testcasefunc("' + p + '")', 100);
320 | 		return false;
321 | 	}
322 | 	return true;
323 | }
324 | 
325 | function resolve(e) {
326 | 	if (formcallback[e.formid] != null) {
327 | 		formcallback[e.formid](e);
328 |     }
329 | }
330 | 
331 | /******************************** 监听器设置区 ********************************/
332 | 
333 | // 设置GUI接收监听器
334 | setAfterActListener('onFormSelect', function (e) {
335 | 	let je = JSON.parse(e);
336 | 	resolve(je);
337 | });
338 | 
339 | setBeforeActListener('onInputCommand', function (e) {
340 |     let je = JSON.parse(e);
341 | 	let r = _testcase_trans(je.cmd, je.playername);
342 | 	if (!r)
343 | 		return false;	// 直接拦截
344 | 	return true;
345 | });
346 | 
347 | // 注册指令
348 | setCommandDescribe('testcase', '测试附加功能是否正常');
349 | 
350 | log('testcase 已加载。用法(仅限玩家)：/testcase');


--------------------------------------------------------------------------------
/js/帮助.txt:
--------------------------------------------------------------------------------
  1 | 一、说明：
  2 | 
  3 |  本插件平台使用v8引擎作为js解释执行工具。全程采用监听器注册机制以完成特定事件的处理。
  4 | 
  5 | 二、API接口定义：
  6 | 
  7 | /******************************** JSAPI说明部分 ********************************/
  8 | 
  9 | // 函数名：fileReadAllText
 10 | // 功能：文件输入流读取一个文本
 11 | // 参数个数：1个
 12 | // 参数类型：字符串
 13 | // 参数详解：fname - 文件名（相对BDS位置）
 14 | // 返回值：字符串
 15 | [例] let t = fileReadAllText('outjs.js')
 16 | 
 17 | // 函数名：fileWriteAllText
 18 | // 功能：文件输出流全新写入一个字符串
 19 | // 参数个数：2个
 20 | // 参数类型：字符串，字符串
 21 | // 参数详解：fname - 文件名（相对BDS位置），content - 文本内容
 22 | // 返回值：是否写成功
 23 | [例] let w = fileWriteAllText('jslog.txt', '测试字符')
 24 | 
 25 | // 函数名：fileWriteLine
 26 | // 功能：文件输出流追加一行字符串
 27 | // 参数个数：2个
 28 | // 参数类型：字符串，字符串
 29 | // 参数详解：fname - 文件名（相对BDS位置），content - 追加内容
 30 | // 返回值：是否写成功
 31 | [例] let w = fileWriteLine('jslog.txt', '下一行测试字符')
 32 | 
 33 | // 函数名：log
 34 | // 功能：标准输出流打印消息
 35 | // 参数个数：1个
 36 | // 参数类型：字符串
 37 | // 参数详解：待输出至标准流字符串
 38 | [例] log('你好 js')
 39 | 
 40 | // 函数名：logout
 41 | // 功能：发送一条命令输出消息（可被拦截）
 42 | // 参数个数：1个
 43 | // 参数类型：字符串
 44 | // 参数详解：cmdout - 待发送的命令输出字符串
 45 | [例] logout('执行结果=正确')
 46 | 
 47 | // 函数名：TimeNow
 48 | // 功能：返回一个当前时间的字符串
 49 | // 参数个数：0个
 50 | // 返回值：字符串
 51 | [例] let t = TimeNow()
 52 | 
 53 | // 函数名：setShareData
 54 | // 功能：存入共享数据
 55 | // 参数个数：2个
 56 | // 参数类型：字符串，数据/函数对象
 57 | // 参数详解：key - 关键字，value - 共享数据
 58 | [例] setShareData('TEXT_HELLO', '你好 js')
 59 | 
 60 | // 函数名：getShareData
 61 | // 功能：获取共享数据
 62 | // 参数个数：1个
 63 | // 参数类型：字符串
 64 | // 参数详解：key - 关键字
 65 | // 返回值：共享数据
 66 | [例] let t = getShareData('TEXT_HELLO')
 67 | 
 68 | // 函数名：removeShareData
 69 | // 功能：删除共享数据
 70 | // 参数个数：1个
 71 | // 参数类型：字符串
 72 | // 参数详解：key - 关键字
 73 | // 返回值：旧数据
 74 | [例] let oldt = removeShareData('TEXT_HELLO')
 75 | 
 76 | // 函数名：setCommandDescribe
 77 | // 功能：设置一个全局指令说明
 78 | // 参数个数：2个
 79 | // 参数类型：字符串，字符串
 80 | // 参数详解：cmd - 命令，description - 命令说明
 81 | // 备注：延期注册的情况，可能不会改变客户端界面
 82 | [例] setCommandDescribe('testcase', '这是一个测试用例指令说明')
 83 | 
 84 | // 函数名：setBeforeActListener
 85 | // 功能：注册玩家事件加载前监听器
 86 | // 参数个数：2个
 87 | // 参数类型：字符串，函数对象
 88 | // 参数详解：key - 注册用关键字，func - 供事件触发时的回调函数对象
 89 | [例] setBeforeActListener('onChat', function (e){ log(e) })
 90 | 
 91 | // 函数名：removeBeforeActListener
 92 | // 功能：移除玩家事件监听器
 93 | // 参数个数：1个
 94 | // 参数类型：字符串
 95 | // 参数详解：key - 注册用关键字
 96 | // 返回值：旧的监听器
 97 | [例] let oldfunc = removeBeforeActListener('onChat')
 98 | 
 99 | // 函数名：getBeforeActListener
100 | // 功能：获取玩家事件监听器
101 | // 参数个数：1个
102 | // 参数类型：字符串
103 | // 参数详解：key - 注册用关键字
104 | // 返回值：当前设置的监听器
105 | [例] let func = getBeforeActListener('onInputText')
106 | 
107 | // 函数名：setAfterActListener
108 | // 功能：注册玩家事件加载后监听器
109 | // 参数个数：2个
110 | // 参数类型：字符串，函数对象
111 | // 参数详解：key - 注册用关键字，func - 供事件触发时的回调函数对象
112 | [例] setAfterActListener('onChat', function (e){ log(e) })
113 | 
114 | // 函数名：removeAfterActListener
115 | // 功能：移除玩家事件加载后监听器
116 | // 参数个数：1个
117 | // 参数类型：字符串
118 | // 参数详解：key - 注册用关键字
119 | // 返回值：旧监听器
120 | [例] let oldfunc = removeAfterActListener('onChat')
121 | 
122 | // 函数名：getAfterActListener
123 | // 功能：获取玩家事件加载后监听器
124 | // 参数个数：1个
125 | // 参数类型：字符串
126 | // 参数详解：key - 注册用关键字
127 | // 返回值：当前设置的监听器
128 | [例] let func = getAfterActListener('onChat')
129 | 
130 | // 函数名：runScript
131 | // 功能：使用全局环境执行一段脚本命令并返回结果
132 | // 参数个数：1个
133 | // 参数类型：字符串
134 | // 参数详解：script - 语法正确的一段脚本文本
135 | // 返回值：脚本执行结果
136 | [例] runScript('log("你好 js")')
137 | 
138 | // 函数名：runcmd
139 | // 功能：执行后台指令
140 | // 参数个数：1个
141 | // 参数类型：字符串
142 | // 参数详解：cmd - 语法正确的MC指令
143 | // 返回值：是否正常执行
144 | [例] let r = runcmd('me 你好 js')
145 | 
146 | // 函数名：getOnLinePlayers
147 | // 功能：获取在线玩家列表
148 | // 参数个数：0个
149 | // 返回值：玩家列表的Json字符串
150 | [例] let v = getOnLinePlayers()
151 | 
152 | // 函数名：getStructure
153 | // 功能：获取一个结构
154 | // 参数个数：5个
155 | // 参数类型：整型，字符串，字符串，布尔型，布尔型
156 | // 参数详解：dimensionid - 地图维度，posa - 坐标JSON字符串，posb - 坐标JSON字符串，exent - 是否导出实体，exblk - 是否导出方块
157 | // 返回值：结构json字符串
158 | [例] let d = getStructure(0, '{"x":0, "y":4, "z":0}', '{"x":10, "y":14, "z":10}', false, true)
159 | 
160 | // 函数名：setStructure
161 | // 功能：设置一个结构到指定位置
162 | // 参数个数：6个
163 | // 参数类型：字符串，整型，字符串，整型，布尔型，布尔型
164 | // 参数详解：strnbt - 结构JSON字符串，dimensionid - 地图维度，posa - 起始点坐标JSON字符串，rot - 旋转类型，exent - 是否导入实体，exblk - 是否导入方块
165 | // 返回值：是否设置成功
166 | [例] let r = setStructure(fileReadAllText('data.json'), 0, '{"x":0, "y":4, "z":0}', 0, true, true)
167 | 
168 | // 函数名：reNameByUuid
169 | // 功能：重命名一个指定的玩家名
170 | // 参数个数：2个
171 | // 参数类型：字符串，字符串
172 | // 参数详解：uuid - 在线玩家的uuid字符串，newName - 新的名称
173 | // 返回值：是否命名成功
174 | // （备注：该函数可能不会变更客户端实际显示名）
175 | [例] let r = reNameByUuid('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '请叫我LiuXiaohua')
176 | 
177 | // 函数名：getPlayerAbilities
178 | // 功能：获取玩家能力表
179 | // 参数个数：1个
180 | // 参数类型：字符串
181 | // 参数详解：uuid - 在线玩家的uuid字符串
182 | // 返回值：能力json字符串
183 | [例] let a = getPlayerAbilities('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
184 | 
185 | // 函数名：setPlayerAbilities
186 | // 功能：设置玩家能力表
187 | // 参数个数：2个
188 | // 参数类型：字符串，字符串
189 | // 参数详解：uuid - 在线玩家的uuid字符串，newAbilities - 新能力json数据字符串
190 | // 返回值：是否设置成功
191 | // （备注：该函数可能不会变更客户端实际显示能力）
192 | [例] let r = setPlayerAbilities('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '{"opencontainers": false}')
193 | 
194 | // 函数名：getPlayerAttributes
195 | // 功能：获取玩家属性表
196 | // 参数个数：1个
197 | // 参数类型：字符串
198 | // 参数详解：uuid - 在线玩家的uuid字符串
199 | // 返回值：属性json字符串
200 | [例] let t = getPlayerAttributes('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
201 | 
202 | // 函数名：setPlayerAttributes
203 | // 功能：设置玩家属性默认值表
204 | // 参数个数：2个
205 | // 参数类型：字符串，字符串
206 | // 参数详解：uuid - 在线玩家的uuid字符串，newAttributes - 新属性默认值json数据字符串
207 | // 返回值：是否设置成功
208 | // （备注：该函数可能不会变更客户端实际显示值；该函数可能导致玩家死后重生不会恢复初始属性）
209 | [例] let r = setPlayerAttributes('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '{"attack_damage": 9999}')
210 | 
211 | // 函数名：setPlayerTempAttributes
212 | // 功能：设置玩家属性临时值表
213 | // 参数个数：2个
214 | // 参数类型：字符串，字符串
215 | // 参数详解：uuid - 在线玩家的uuid字符串，newTempAttributes - 新属性临时值json数据字符串
216 | // 返回值：是否设置成功
217 | // （备注：该函数可能不会变更客户端实际显示值）
218 | [例] let r = setPlayerTempAttributes('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '{"hunger": 10}')
219 | 
220 | // 函数名：getPlayerMaxAttributes
221 | // 功能：获取玩家属性上限值表
222 | // 参数个数：1个
223 | // 参数类型：字符串
224 | // 参数详解：uuid - 在线玩家的uuid字符串
225 | // 返回值：属性上限值json字符串
226 | [例] let m = getPlayerMaxAttributes('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
227 | 
228 | // 函数名：setPlayerMaxAttributes
229 | // 功能：设置玩家属性上限值表
230 | // 参数个数：2个
231 | // 参数类型：字符串，字符串
232 | // 参数详解：uuid - 在线玩家的uuid字符串，newMaxAttributes - 新属性上限值json数据字符串
233 | // 返回值：是否设置成功
234 | // （备注：该函数可能不会变更客户端实际显示值）
235 | [例] let r = setPlayerMaxAttributes('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '{"maxhealth": 200}')
236 | 
237 | // 函数名：getPlayerItems
238 | // 功能：获取玩家所有物品列表
239 | // 参数个数：1个
240 | // 参数类型：字符串
241 | // 参数详解：uuid - 在线玩家的uuid字符串
242 | // 返回值：物品列表json字符串
243 | [例] let t = getPlayerItems('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
244 | 
245 | // 函数名：getPlayerSelectedItem
246 | // 功能：获取玩家当前选中项信息
247 | // 参数个数：1个
248 | // 参数类型：字符串
249 | // 参数详解：uuid - 在线玩家的uuid字符串
250 | // 返回值：当前选中项信息json字符串
251 | [例] let i = getPlayerSelectedItem('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
252 | 
253 | // 函数名：setPlayerItems
254 | // 功能：设置玩家所有物品列表
255 | // 参数个数：2个
256 | // 参数类型：字符串，字符串
257 | // 参数详解：uuid - 在线玩家的uuid字符串，newItems - 新物品列表json数据字符串
258 | // 返回值：是否设置成功
259 | // （备注：特定条件下可能不会变更游戏内实际物品）
260 | [例] let r = setPlayerItems('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9','{"Offhand":{"tt":9,"tv":[{"tt":10,"tv":[{"ck":"Count","cv":{"tt":1,"tv":1}},{"ck":"Damage","cv":{"tt":2,"tv":0}},{"ck":"Name","cv":{"tt":8,"tv":"minecraft:trident"}},{"ck":"tag","cv":{"tt":10,"tv":[{"ck":"ench","cv":{"tt":9,"tv":[{"tt":10,"tv":[{"ck":"id","cv":{"tt":2,"tv":7}},{"ck":"lvl","cv":{"tt":2,"tv":8888}}]}]}}]}}]}]}}')
261 | 
262 | // 函数名：addPlayerItemEx
263 | // 功能：增加玩家一个物品
264 | // 参数个数：2个
265 | // 参数类型：字符串，字符串
266 | // 参数详解：uuid - 在线玩家的uuid字符串，item - 物品json数据字符串
267 | // 返回值：是否添加成功
268 | // （备注：特定条件下可能不会变更游戏内实际物品）
269 | [例] let r = setPlayerItems('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '{"tt":10,"tv":[{"ck":"Count","cv":{"tt":1,"tv":1}},{"ck":"Damage","cv":{"tt":2,"tv":0}},{"ck":"Name","cv":{"tt":8,"tv":"minecraft:trident"}},{"ck":"tag","cv":{"tt":10,"tv":[{"ck":"ench","cv":{"tt":9,"tv":[{"tt":10,"tv":[{"ck":"id","cv":{"tt":2,"tv":10}},{"ck":"lvl","cv":{"tt":2,"tv":9999}}]}]}}]}}]}')
270 | 
271 | // 函数名：addPlayerItem
272 | // 功能：增加玩家一个物品
273 | // 参数个数：4个
274 | // 参数类型：字符串
275 | // 参数详解：uuid - 在线玩家的uuid字符串，id - 物品id值，aux - 物品特殊值，count - 数量
276 | // 返回值：是否增加成功
277 | // （备注：特定条件下可能不会变更游戏内实际物品）
278 | [例] let r = addPlayerItem('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', 9, 0, 32)
279 | 
280 | // 函数名：getPlayerEffects
281 | // 功能：获取玩家所有效果列表
282 | // 参数个数：1个
283 | // 参数类型：字符串
284 | // 参数详解：uuid - 在线玩家的uuid字符串
285 | // 返回值：效果列表json字符串
286 | [例] let e = getPlayerEffects('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
287 | 
288 | // 函数名：setPlayerEffects
289 | // 功能：设置玩家所有效果列表
290 | // 参数个数：2个
291 | // 参数类型：字符串，字符串
292 | // 参数详解：uuid - 在线玩家的uuid字符串，newEffects - 新效果列表json数据字符串
293 | // 返回值：是否设置成功
294 | [例] let r = setPlayerEffects('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '{"tt":9,"tv":[{"tt":10,"tv":[{"ck":"Ambient","cv":{"tt":1,"tv":0}},{"ck":"Amplifier","cv":{"tt":1,"tv":0}},{"ck":"DisplayOnScreenTextureAnimation","cv":{"tt":1,"tv":0}},{"ck":"Duration","cv":{"tt":3,"tv":3461}},{"ck":"DurationEasy","cv":{"tt":3,"tv":3461}},{"ck":"DurationHard","cv":{"tt":3,"tv":3461}},{"ck":"DurationNormal","cv":{"tt":3,"tv":3461}},{"ck":"Id","cv":{"tt":1,"tv":16}},{"ck":"ShowParticles","cv":{"tt":1,"tv":1}}]}]}')
295 | 
296 | // 函数名：setPlayerBossBar
297 | // 功能：设置玩家自定义血条
298 | // 参数个数：3个
299 | // 参数类型：字符串，字符串，浮点型
300 | // 参数详解：uuid - 在线玩家的uuid字符串，title - 血条标题，percent - 血条百分比
301 | // 返回值：是否设置成功
302 | [例] let r = setPlayerBossBar('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '欢迎来到梦之故里', 1.00)
303 | 
304 | // 函数名：removePlayerBossBar
305 | // 功能：清除玩家自定义血条
306 | // 参数个数：1个
307 | // 参数类型：字符串
308 | // 参数详解：uuid - 在线玩家的uuid字符串
309 | // 返回值：是否清除成功
310 | [例] let r = removePlayerBossBar('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
311 | 
312 | // 函数名：setPlayerSidebar
313 | // 功能：设置玩家自定义侧边栏临时计分板
314 | // 参数个数：3个
315 | // 参数类型：字符串，字符串，字符串
316 | // 参数详解：uuid - 在线玩家的uuid字符串，title - 侧边栏标题，list - 列表字符串数组
317 | // 返回值：是否设置成功
318 | // （注：列表总是从第1行开始，总计不超过15行）
319 | [例] let r = setPlayerSidebar('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '自定义侧边栏', '["第一行", "第二行", "我在哪行?    "]')
320 | 
321 | // 函数名：removePlayerSidebar
322 | // 功能：清除玩家自定义侧边栏
323 | // 参数个数：1个
324 | // 参数类型：字符串
325 | // 参数详解：uuid - 在线玩家的uuid字符串
326 | // 返回值：是否清除成功
327 | [例] let r = removePlayerSidebar('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
328 | 
329 | // 函数名：getPlayerPermissionAndGametype
330 | // 功能：获取玩家权限与游戏模式
331 | // 参数个数：1个
332 | // 参数类型：字符串
333 | // 参数详解：uuid - 在线玩家的uuid字符串
334 | // 返回值：权限与模式的json字符串
335 | [例] let t = getPlayerPermissionAndGametype('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
336 | 
337 | // 函数名：setPlayerPermissionAndGametype
338 | // 功能：设置玩家权限与游戏模式
339 | // 参数个数：2个
340 | // 参数类型：字符串，字符串
341 | // 参数详解：uuid - 在线玩家的uuid字符串，newModes - 新权限或模式json数据字符串
342 | // 返回值：是否设置成功
343 | // （备注：特定条件下可能不会变更游戏内实际能力）
344 | [例] let r = setPlayerPermissionAndGametype('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '{"gametype" : 3}')
345 | 
346 | // 函数名：selectPlayer
347 | // 功能：查询在线玩家基本信息
348 | // 参数个数：1个
349 | // 参数类型：字符串
350 | // 参数详解：uuid - 在线玩家的uuid字符串
351 | // 返回值：玩家基本信息json字符串
352 | [例] let e = selectPlayer('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9')
353 | 
354 | // 函数名：transferserver
355 | // 功能：传送玩家至指定服务器
356 | // 参数个数：3个
357 | // 参数类型：字符串，字符串，整型
358 | // 参数详解：uuid - 在线玩家的uuid字符串，addr - 待传服务器，port - 端口
359 | // 返回值：是否传送成功
360 | [例] let t = transferserver('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', 'www.xiafox.com', 19132)
361 | 
362 | // 函数名：teleport
363 | // 功能：传送玩家至指定坐标和维度
364 | // 参数个数：5个
365 | // 参数类型：字符串，浮点型，浮点型，浮点型，整型
366 | // 参数详解：uuid - 在线玩家的uuid字符串，X - x，Y - y，Z - z，dimensionid - 维度ID
367 | // 返回值：是否传送成功
368 | [例] let t = teleport('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', 10, 99, 10, 2)
369 | 
370 | // 函数名：talkAs
371 | // 功能：模拟玩家发送一个文本
372 | // 参数个数：2个
373 | // 参数类型：字符串，字符串
374 | // 参数详解：uuid - 在线玩家的uuid字符串，msg - 待模拟发送的文本
375 | // 返回值：是否发送成功
376 | [例] let t = talkAs('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '你好 js')
377 | 
378 | // 函数名：runcmdAs
379 | // 功能：模拟玩家执行一个指令
380 | // 参数个数：2个
381 | // 参数类型：字符串，字符串
382 | // 参数详解：uuid - 在线玩家的uuid字符串，cmd - 待模拟执行的指令
383 | // 返回值：是否发送成功
384 | [例] let t = runcmdAs('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '/me 你好 js')
385 | 
386 | // 函数名：sendSimpleForm
387 | // 功能：向指定的玩家发送一个简单表单
388 | // 参数个数：4个
389 | // 参数类型：字符串，字符串，字符串，字符串
390 | // 参数详解：uuid - 在线玩家的uuid字符串，title - 表单标题，content - 内容，buttons - 按钮文本数组字符串
391 | // 返回值：创建的表单id，为 0 表示发送失败
392 | [例] let fid = sendSimpleForm('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '致命选项', '请选择：', '["生存","死亡","求助"]')
393 | 
394 | // 函数名：sendModalForm
395 | // 功能：向指定的玩家发送一个模式对话框
396 | // 参数个数：5个
397 | // 参数类型：字符串，字符串，字符串，字符串，字符串
398 | // 参数详解：uuid - 在线玩家的uuid字符串，title - 表单标题，content - 内容，button1 按钮1标题（点击该按钮selected为true），button2 按钮2标题（点击该按钮selected为false）
399 | // 返回值：创建的表单id，为 0 表示发送失败
400 | [例] let fid = sendModalForm('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '没有第三个选项', '请选择：', '生存', '死亡')
401 | 
402 | // 函数名：sendCustomForm
403 | // 功能：向指定的玩家发送一个自定义表单
404 | // 参数个数：2个
405 | // 参数类型：字符串，字符串
406 | // 参数详解：uuid - 在线玩家的uuid字符串，json - 自定义表单的json字符串（要使用自定义表单类型，参考nk、pm格式或minebbs专栏）
407 | // 返回值：创建的表单id，为 0 表示发送失败
408 | [例] let fid = sendCustomForm('8f976e22-78bc-3fe1-8ee5-cf5ff56347b9', '{"content":[{"type":"label","text":"这是一个文本标签"},{"placeholder":"水印文本","default":"","type":"input","text":""},{"default":true,"type":"toggle","text":"开关~或许是吧"},{"min":0.0,"max":10.0,"step":2.0,"default":3.0,"type":"slider","text":"游标滑块！？"},{"default":1,"steps":["Step 1","Step 2","Step 3"],"type":"step_slider","text":"矩阵滑块？!"},{"default":1,"options":["Option 1","Option 2","Option 3"],"type":"dropdown","text":"如你所见，下拉框"}], "type":"custom_form","title":"这是一个自定义窗体"}')
409 | 
410 | // 函数名：releaseForm
411 | // 功能：放弃一个表单
412 | // 参数个数：1个
413 | // 参数类型：整型
414 | // 参数详解：formid - 表单id
415 | // 返回值：是否释放成功
416 | //（备注：已被接收到的表单会被自动释放）
417 | [例] let r = releaseForm(1000)
418 | 
419 | // 函数名：request
420 | // 功能：发起一个远程HTTP请求
421 | // 参数个数：4个
422 | // 参数类型：字符串，字符串，字符串，函数对象
423 | // 参数详解：urlpath - 远程接口路径，mode - 访问方式，params - 附加数据，func - 获取结果回调
424 | [例] request('http://www.baidu.com', 'GET', 'name=act', function(e){})
425 | 
426 | // 函数名：setTimeout
427 | // 功能：延时执行一条指令
428 | // 参数个数：2个
429 | // 参数类型：字符串/函数，整型
430 | // 参数详解：code - 待延时执行的指令字符串/函数对象，millisec - 延时毫秒数
431 | [例] setTimeout('log("你好 js")', 1000)
432 | 
433 | 三、注册机制:
434 | 
435 | /******************************** 注册接口及回调数据说明 ********************************/
436 | 
437 | 注册范例：
438 | 
439 | [例] setBeforeActListener(key, function(e){})
440 | 
441 | key - 关键字
442 | "onUseItem" - 使用物品回调
443 | e - 回传数据
444 |  playername - 玩家名字
445 |  dimension - 玩家所在维度
446 |  dimensionid - 玩家所在维度ID
447 |  isstand - 玩家是否双脚着地/悬空
448 |  XYZ - 玩家所处位置
449 |  position - 操作方块所在位置
450 |  itemid - 物品id
451 |  itemaux - 物品特殊值
452 |  itemname - 物品名称
453 |  result - 原事件操作是否成功(仅限After事件)
454 | 
455 | 其中，对于注册Before事件的函数返回值决定了是否拦截该事件（非全部）。
456 | 其它关键字类推。
457 | 
458 |  "onServerCmd" - 后台指令监听
459 |  "onServerCmdOutput" - 后台指令输出信息监听
460 |  "onFormSelect" - 玩家选择GUI表单监听
461 |  "onUseItem" - 使用物品监听
462 |  "onMove" - 移动监听
463 |  "onAttack" - 攻击监听
464 |  "onPlacedBlock" - 放置方块监听
465 |  "onDestroyBlock" - 破坏方块监听
466 |  "onStartOpenChest" - 开箱监听
467 |  "onStartOpenBarrel" - 开桶监听
468 |  "onChangeDimension" - 切换维度监听
469 |  "onLoadName" - 加载名字监听
470 |  "onPlayerLeft" - 离开游戏监听
471 |  "onStopOpenChest" - 关箱监听
472 |  "onStopOpenBarrel" - 关桶监听
473 |  "onSetSlot" - 放入取出物品监听
474 |  "onMobDie" - 生物死亡监听
475 |  "onMobHurt" - 生物受伤监听
476 |  "onRespawn" - 玩家重生监听
477 |  "onInputText" - 玩家输入文本监听
478 |  "onInputCommand" - 玩家输入指令监听
479 |  "onBlockCmd" - 命令方块(矿车)执行指令监听
480 |  "onNpcCmd" - NPC执行指令监听
481 |  "onCommandBlockUpdate" - 玩家更新命令方块监听
482 |  "onLevelExplode" - 爆炸监听
483 |  "onChat" - 聊天监听
484 |  


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <http://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <http://www.gnu.org/philosophy/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------