Dove/Eustia
14
2
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

_codelab

Browse Source
This commit is contained in:
草莓 2024-11-29 12:33:31 +08:00
commit 3baf33379d
10 changed files with 692 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
_codelab/L1.md Normal file
View File

@ -0,0 +1,57 @@
# 第一章：伤害计算函数（getDamageInfo）
要求：读懂脚本编辑 - 伤害计算函数（getDamageInfo）的全部脚本代码（无需理解支援的实现）。
回答如下几个问题：
1. 如下几个局部变量分别是什么意义？
`mon_atk`, `init_damage`, `per_damage`, `hero_per_damage`, `turn`, `damage`
2. 如何理解下面这几句话？
`if (core.hasSpecial(mon_special, 2)) per_damage = mon_atk;`
`var turn = Math.ceil(mon_hp / hero_per_damage);`
`var damage = init_damage + (turn - 1) * per_damage + turn * counterDamage;`
3. 负伤在哪里实现的？
依次实现如下几个怪物属性（仅允许修改`getDamageInfo`函数）：
1. **闪避（编号31）：** 受到伤害降低40%。
2. **穿刺（编号32）：** 无视角色70%防御力。
3. **冰冻（编号33）：** 怪物首先冰冻角色3回合，冰冻期间每回合额外造成角色护盾的20%伤害。
4. **中子束（编号34）：** 每回合普攻两次，魔攻一次。
5. **残暴斩杀（编号35）：** 战斗开始时，如果角色血量不大于怪物血量的200%，则直接暴毙。
6. **窥血为攻（编号36）：** 战斗开始时，自身攻击力变为角色当前生命值的10%，向下取整。
7. **匙之力（编号37）：** 角色身上每存在一把黄钥匙，最终伤害提升5%；蓝钥匙视为三把黄钥匙，红钥匙视为九把黄钥匙，线性叠加。
8. **崩甲（编号38）：** 怪物每回合附加勇士战斗开始时的护盾数值的0.1倍作为伤害。
9. **混乱（编号39）：** 战斗中，勇士攻防互换。
10. **强击（编号40）：** 怪物第一回合三倍攻击。
11. **暗影庇护（编号41）：** 处于无敌状态，但每回合损耗自身2%的最大生命值。
再依次实现如下几个角色技能：
1. 角色每回合回复`flag:x1`%倍护盾的生命值。（如，`flag:x1`是10时，每回合回复10%护盾值的生命）
2. 角色每回合造成和受到的伤害均提升`flag:x2`%。（如，`flag:x2`为10时，每回合造成和受到伤害都提升10%）
3. 角色攻击在战斗时减少`flag:x3`，防御力增加`flag:x3`。
4. 角色无视怪物的`flag:x4`%的防御力。（如，`flag:x4`是10时，无视怪物的10%防御力）
5. 角色额外抢攻`flag:x5`回合。
[点此查看答案](L1_answer)

244
_codelab/L1_answer.md Normal file
View File

@ -0,0 +1,244 @@
```js
function (enemy, hero, x, y, floorId) {
// 获得战斗伤害信息（实际伤害计算函数）
//
// 参数说明：
// enemy：该怪物信息
// hero：勇士的当前数据；如果对应项不存在则会从core.status.hero中取。
// x,y：该怪物的坐标（查看手册和强制战斗时为undefined）
// floorId：该怪物所在的楼层
// 后面三个参数主要是可以在光环等效果上可以适用
floorId = floorId || core.status.floorId;
var hero_hp = core.getRealStatusOrDefault(hero, 'hp'),
hero_atk = core.getRealStatusOrDefault(hero, 'atk'),
hero_def = core.getRealStatusOrDefault(hero, 'def'),
hero_mdef = core.getRealStatusOrDefault(hero, 'mdef'),
origin_hero_hp = core.getStatusOrDefault(hero, 'hp'),
origin_hero_atk = core.getStatusOrDefault(hero, 'atk'),
origin_hero_def = core.getStatusOrDefault(hero, 'def');
// 勇士的负属性都按0计算
hero_hp = Math.max(0, hero_hp);
hero_atk = Math.max(0, hero_atk);
hero_def = Math.max(0, hero_def);
hero_mdef = Math.max(0, hero_mdef);
// 怪物的各项数据
// 对坚固模仿等处理扔到了脚本编辑-getEnemyInfo之中
var enemyInfo = core.enemys.getEnemyInfo(enemy, hero, x, y, floorId);
var mon_hp = enemyInfo.hp,
mon_atk = enemyInfo.atk,
mon_def = enemyInfo.def,
mon_special = enemyInfo.special;
// 混乱（编号39）：战斗中，勇士攻防互换。
if (core.hasSpecial(mon_special, 39)) {
var temp = hero_atk;
hero_atk = hero_def;
hero_def = temp;
}
// 残暴斩杀（编号35）：战斗开始时，如果角色血量不大于怪物血量的200%，则直接暴毙。
if (core.hasSpecial(mon_special, 35) && hero_hp < mon_hp * 2) {
return null;
}
// 窥血为攻（编号36）：战斗开始时，自身攻击力变为角色当前生命值的10%，向下取整。
if (core.hasSpecial(mon_special, 36)) {
mon_atk = Math.floor(hero_hp / 10);
}
// 技能3：角色攻击在战斗时减少`flag:x3`，防御力增加`flag:x3`。
if (core.getFlag('skill', 0) == 3) {
// 注意这里直接改变的面板攻击力（经过装备增幅后的）而不是基础攻击力。
hero_atk -= core.getFlag('x3', 0);
hero_def += core.getFlag('x3', 0);
}
// 技能4：角色无视怪物的`flag:x4`%的防御力。（如，`flag:x4`是10时，无视怪物的10%防御力）
if (core.getFlag('skill', 0) == 4) {
mon_def -= Math.floor(core.getFlag('x4', 0) / 100);
}
// 如果是无敌属性，且勇士未持有十字架
if (core.hasSpecial(mon_special, 20) && !core.hasItem("cross"))
return null; // 不可战斗
// 战前造成的额外伤害（可被护盾抵消）
var init_damage = 0;
// 吸血
if (core.hasSpecial(mon_special, 11)) {
var vampire_damage = hero_hp * enemy.value;
// 如果有神圣盾免疫吸血等可以在这里写
// 也可以用hasItem和hasEquip来判定装备
// if (core.hasFlag('shield5')) vampire_damage = 0;
vampire_damage = Math.floor(vampire_damage) || 0;
// 加到自身
if (enemy.add) // 如果加到自身
mon_hp += vampire_damage;
init_damage += vampire_damage;
}
// 每回合怪物对勇士造成的战斗伤害
var per_damage = mon_atk - hero_def;
// 魔攻：战斗伤害就是怪物攻击力
if (core.hasSpecial(mon_special, 2)) per_damage = mon_atk;
// 穿刺（编号32）：无视角色70%防御力。
if (core.hasSpecial(mon_special, 32)) per_damage = Math.floor(mon_atk - 0.3 * hero_def);
// 战斗伤害不能为负值
if (per_damage < 0) per_damage = 0;
// 中子束（编号34）：每回合普攻两次，魔攻一次。
if (core.hasSpecial(mon_special, 34)) {
per_damage *= 2;
per_damage += mon_atk;
}
// 崩甲（编号38）：怪物每回合附加勇士战斗开始时的护盾数值的0.1倍作为伤害。
if (core.hasSpecial(mon_special, 38)) {
per_damage += Math.floor(hero_mdef * 0.1);
}
// 2连击 & 3连击 & N连击
if (core.hasSpecial(mon_special, 4)) per_damage *= 2;
if (core.hasSpecial(mon_special, 5)) per_damage *= 3;
if (core.hasSpecial(mon_special, 6)) per_damage *= (enemy.n || 4);
// 每回合的反击伤害；反击是按照勇士的攻击次数来计算回合
var counterDamage = 0;
if (core.hasSpecial(mon_special, 8))
counterDamage += Math.floor((enemy.atkValue || core.values.counterAttack) * hero_atk);
// 先攻
if (core.hasSpecial(mon_special, 1)) init_damage += per_damage;
// 破甲
if (core.hasSpecial(mon_special, 7))
init_damage += Math.floor((enemy.defValue || core.values.breakArmor) * hero_def);
// 净化
if (core.hasSpecial(mon_special, 9))
init_damage += Math.floor((enemy.n || core.values.purify) * hero_mdef);
// 冰冻（编号33）：怪物首先冰冻角色3回合，冰冻期间每回合额外造成角色护盾的20%伤害。
if (core.hasSpecial(mon_special, 33)) {
init_damage += Math.floor(3 * (per_damage + 0.2 * hero_mdef));
}
// 勇士每回合对怪物造成的伤害
var hero_per_damage = Math.max(hero_atk - mon_def, 0);
// 技能2：角色每回合造成和受到的伤害均提升`flag:x2`%。（如，`flag:x2`为10时，每回合造成和受到伤害都提升10%）
if (core.getFlag("skill", 0) == 2) {
per_damage += Math.floor(per_damage * core.getFlag('x2', 0) / 100);
hero_per_damage += Math.floor(hero_per_damage * core.getFlag('x2', 0) / 100);
}
// 闪避（编号31）：受到伤害降低40%。
if (core.hasSpecial(mon_special, 31)) {
hero_per_damage = Math.floor(hero_per_damage * 0.6);
}
// 如果没有破防，则不可战斗
if (hero_per_damage <= 0) return null;
// 技能5：角色额外抢攻`flag:x5`回合。
if (core.getFlag("skill", 0) == 5) {
mon_hp -= core.getFlag('x5', 0) * hero_per_damage;
// 判定是否已经秒杀 -> 注意mon_hp不能小于等于0否则回合计算会出问题
if (mon_hp <= 0) mon_hp = 1;
}
// 暗影庇护（编号41）：处于无敌状态，但每回合损耗自身2%的最大生命值。
if (core.hasSpecial(mon_special, 41)) {
hero_per_damage = Math.floor(mon_hp * 0.02);
}
// 强击（编号40）：怪物第一回合三倍攻击。
// 注意：需要判定角色是否秒杀怪物
if (core.hasSpecial(mon_special, 40) && hero_per_damage < mon_hp) {
init_damage += 2 * mon_atk;
}
// 勇士的攻击回合数；为怪物生命除以每回合伤害向上取整
var turn = Math.ceil(mon_hp / hero_per_damage);
// ------ 支援 ----- //
// 这个递归最好想明白为什么，flag:__extraTurn__是怎么用的
var guards = core.getFlag("__guards__" + x + "_" + y, enemyInfo.guards);
var guard_before_current_enemy = false; // ------ 支援怪是先打(true)还是后打(false)？
turn += core.getFlag("__extraTurn__", 0);
if (guards.length > 0) {
if (!guard_before_current_enemy) { // --- 先打当前怪物，记录当前回合数
core.setFlag("__extraTurn__", turn);
}
// 获得那些怪物组成小队战斗
for (var i = 0; i < guards.length; i++) {
var gx = guards[i][0],
gy = guards[i][1],
gid = guards[i][2];
// 递归计算支援怪伤害信息，这里不传x,y保证不会重复调用
// 这里的mdef传0，因为护盾应该只会被计算一次
var info = core.enemys.getDamageInfo(core.material.enemys[gid], { hp: origin_hero_hp, atk: origin_hero_atk, def: origin_hero_def, mdef: 0 });
if (info == null) { // 小队中任何一个怪物不可战斗，直接返回null
core.removeFlag("__extraTurn__");
return null;
}
// 已经进行的回合数
core.setFlag("__extraTurn__", info.turn);
init_damage += info.damage;
}
if (guard_before_current_enemy) { // --- 先打支援怪物，增加当前回合数
turn += core.getFlag("__extraTurn__", 0);
}
}
core.removeFlag("__extraTurn__");
// ------ 支援END ------ //
// 最终伤害：初始伤害 + 怪物对勇士造成的伤害 + 反击伤害
var damage = init_damage + (turn - 1) * per_damage + turn * counterDamage;
// 再扣去护盾
damage -= hero_mdef;
// 匙之力（编号37）：角色身上每存在一把黄钥匙，最终伤害提升5%；蓝钥匙视为三把黄钥匙，红钥匙视为九把黄钥匙，线性叠加。
// 需要判定是否负伤
if (core.hasSpecial(mon_special, 37) && damage > 0) {
var cnt = core.itemCount("yellowKey") + 3 * core.itemCount("blueKey") + 9 * core.itemCount("redKey");
damage += Math.floor(damage * 0.05 * cnt);
}
// 检查是否允许负伤
if (!core.flags.enableNegativeDamage)
damage = Math.max(0, damage);
// 最后处理仇恨和固伤（因为这两个不能被护盾减伤）
if (core.hasSpecial(mon_special, 17)) { // 仇恨
damage += core.getFlag('hatred', 0);
}
if (core.hasSpecial(mon_special, 22)) { // 固伤
damage += enemy.damage || 0;
}
// 技能1：角色每回合回复`flag:x1`%倍护盾的生命值。（如，`flag:x1`是10时，每回合回复10%护盾值的生命）
if (core.getFlag("skill", 0) == 1) {
damage -= Math.floor(core.getFlag('x1', 0) / 100 * hero_mdef * turn);
}
return {
"mon_hp": Math.floor(mon_hp),
"mon_atk": Math.floor(mon_atk),
"mon_def": Math.floor(mon_def),
"init_damage": Math.floor(init_damage),
"per_damage": Math.floor(per_damage),
"hero_per_damage": Math.floor(hero_per_damage),
"turn": Math.floor(turn),
"damage": Math.floor(damage)
};
}
```

102
_codelab/L2.md Normal file
View File

@ -0,0 +1,102 @@
# 第二章：怪物特殊属性定义（getSpecials），表格配置
要求：读懂脚本编辑 - 怪物特殊属性定义（getSpecials）的实现。理解如何定义一个新的怪物属性。同时，还需要理解如何给怪物表格增加新项目。
回答如下问题：
1. 如何定义一个新的怪物属性？
2. 如何取得当前怪物的各项数值？
3. 第五项参数在哪些情况下写1？为什么需要？
4. 如何给怪物表格定义新项目？如何在伤害计算等地方取用定义的新项目？
5. 当前，有一部分怪物属性使用了相同的表格项，如阻激夹域都使用了`value`等；这样无法同时给怪物增加吸血和领域两个属性。那应该怎么做才能同时支持这两项？
6. 理解《咕工智障》的下述怪物特殊属性并回答：
- 如果一个该属性怪物设置了`hpValue = 10, range = 2`，那么怪物手册中显示该怪物的特殊属性名和描述是什么？
- 如果一个该属性怪物设置了`hpValue = -20, defValue = 30`，那么怪物手册中显示该怪物的特殊属性名和描述是什么？
- 如果一个该属性怪物设置了`hpValue = 10, atkValue = 20, defValue = 30, add = true`，那么怪物手册中显示该怪物的特殊属性名和描述是什么？
- 如果怪物手册中的描述是`周围方形范围内5格的友军生命提升10%，攻击降低20%，线性叠加`，那么该怪物的哪些项被设置了成了多少？该怪物的特殊属性名是什么？
- 如果怪物手册中的描述是`周围十字范围内3格的友军生命提升20%，攻击提升10%，防御提升5%，不可叠加`，那么该怪物的哪些项被设置了成了多少？该怪物的特殊属性名是什么？
```js
[25, function (enemy) {
if (enemy.auraName) return enemy.auraName;
if (enemy.hpValue && enemy.atkValue && enemy.defValue) return "魔力光环";
if (enemy.hpValue) {
if (enemy.hpValue > 0) return "活力光环";
return "懒散光环";
}
if (enemy.atkValue) {
if (enemy.atkValue > 0) return "狂暴光环";
return "静谧光环";
}
if (enemy.defValue) {
if (enemy.defValue > 0) return "坚毅光环";
return "软弱光环";
}
return "光环";
}, function (enemy) {
var str;
if (!enemy.range) {
str = "同楼层所有友军";
} else {
str = "周围" + (enemy.zoneSquare ? "方形" : "十字")
+ "范围内\r[yellow]" + (enemy.range || 1) + "\r格的友军";
}
if (enemy.hpValue) {
if (enemy.hpValue > 0) str += "生命提升\r[yellow]" + enemy.hpValue + "%\r，";
else str += "生命降低\r[yellow]" + (-enemy.hpValue) + "%\r，";
}
if (enemy.atkValue) {
if (enemy.atkValue > 0) str += "攻击提升\r[yellow]" + enemy.atkValue + "%\r，";
else str += "攻击降低\r[yellow]" + (-enemy.atkValue) + "%\r，";
}
if (enemy.defValue) {
if (enemy.defValue > 0) str += "防御提升\r[yellow]" + enemy.defValue + "%\r，";
else str += "防御降低\r[yellow]" + (-enemy.defValue) + "%\r，";
}
str += (enemy.add ? "线性叠加" : "不可叠加");
return str;
}, "#e6e099", 1],
```
7. 理解《咕工智障》的下述怪物特殊属性并回答：
- 吸血数值是如何计算在怪物手册之中的？
- 如何根据角色当前拥有的道具或者变量来修改怪物属性描述？
- 如果要让简单难度下，怪物吸血值减半，特殊属性定义中应该怎么修改？
```js
[11, "吸血", function (enemy) {
var str = "\r[\#e525ff]【红海技能】\r战斗前，首先吸取对方的"
+ Math.floor(100 * enemy.value || 0) + "%生命（约"
+ Math.floor((enemy.value || 0) * core.getRealStatus('hp')) + "点）作为伤害"
+ (enemy.add ? "，并把伤害数值加到自身生命上" : "");
if (core.hasItem("I_noVampire")) str += "\r[yellow]（对你无效）\r";
return str;
}, "#ff00d2"],
```
8. 定义同时满足如下条件的特殊属性（编号`28`），并和《咕工智障》的写法进行比较。
- 当怪物的 `value28 > 0` 时，特殊属性名为`迅捷光环`
- 当怪物的 `value28 <= 0` 时，特殊属性名为`怠惰光环`
- 当难度为简单（`flag:hard = 1`）时，描述为`此技能在简单难度下无效！`
- 当角色拥有道具 `I123` 时，描述为`此技能已被魔杖抵消！`
- 当怪物的 `range > 0` 时，描述存在`周围[方形/十字]范围内[?]格的友军`；其中这`[]`里面内容由怪物的 `zoneSquare` 和 `range` 决定。
- 当怪物的 `range = null` 时，描述存在`当前楼层的友军`
- 当怪物的 `value28 > 0` 时，描述存在`先攻X回合`，其中X由`value28`决定（如，`value28 = 5`时，描述存在`先攻5回合`）
- 当怪物的 `value28 <= 0` 时，描述存在`被先攻X回合`，其中X由`value28`决定（如，`value28 = -5`时，描述存在`被先攻5回合`）
9. 定义同时满足如下条件的特殊属性（编号`30`），并和《咕工智障》的写法进行比较。
- 特殊属性名：匙之力
- 当怪物的 `range > 0` 时，描述存在`周围[方形/十字]范围内[?]格内`；其中这`[]`里面内容由怪物的 `zoneSquare` 和 `range` 决定。
- 当怪物的 `range = null` 时，描述存在`同楼层内`
- 描述存在 `每存在一个黄钥匙，生命增加X点，攻击增加Y点，防御增加Z点`，其中`X, Y, Z`由怪物的`value, atkValue, defValue`决定。如果其中某一项为0或null则不显示对应项。（例如，如果`value = 30, defValue = 20`则只显示`生命增加30点，防御增加20点`）
10. 将阻击、激光、领域、吸血所使用的特殊属性值（当前均为`value`）分离，并实现一个怪物同时拥有`阻击伤害100点，激光伤害50点，领域伤害200点，且吸血20%`这四个特殊属性。
- 需在怪物手册正确显示
- 需正确实现对应的效果（需要修改`伤害计算（getDamageInfo）和阻激夹域伤害（updateCheckBlock）`两个函数）
[点此查看答案](L2_answer)

153
_codelab/L2_answer.md Normal file
View File

@ -0,0 +1,153 @@
1. 在怪物特殊属性中增加一行，分别定义特殊属性的数字、名字、描述、颜色，以及是否是地图类技能（如光环）。
2. 使用`function (enemy) {}`，里面可以取用`enemy.xxx`调用数值；例如`enemy.value`可以调用怪物的value值。
3. 仅在地图类技能时需要写1。当怪物的该项为1时，意味着该怪物的技能是和地图上其他图块有关的（而不是怪物自身独立的）。例如，先攻魔攻这些技能就是自身独立（和地图上其他图块无关），而光环，匙之力（根据周边钥匙数量提升属性）等这些技能就是与地图上其他怪物有关的。
4. 点击「配置表格」，找到怪物相关项目，并照葫芦画瓢即可。常见写法如下。
```js
"value": {
"_leaf": true,
"_type": "textarea",
"_docs": "特殊属性数值",
"_data": "特殊属性的数值\n如：领域/阻激/激光怪的伤害值；吸血怪的吸血比例；光环怪增加生命的比例"
},
```
5. 可定义不同项目如v1, v2, v3等分别表示伤害值；然后修改特殊描述和实际效果以取用v1, v2, v3等来代替原来的value。参见第10题解答。
6.
- 活力光环；周围十字范围内2格的友军生命提升10%，不可叠加。
- 懒散光环；同楼层所有友军生命降低20%，防御提升30%，不可叠加。（注意，不会显示坚毅光环！）
- 魔力光环：同楼层所有友军生命提升10%，攻击提升20%，防御提升30%，线性叠加。
- range=5, zoneSquare = true, hpValue=10, atkValue=-20, add=true；活力光环。
- range=3, hpValue = 20, atkValue = 10, defValue = 5；魔力光环。
7.
- 直接使用`enemy.value`获得当前吸血比例，乘以玩家当前生命值`core.getRealStatus('hp')`获得吸血数值，并取整再显示。
- 可以通过额外的if来修改具体的描述。
- 可以在简单难度下将value减半以达到效果。
```js
[11, "吸血", function (enemy) {
var value = enemy.value || 0; // 怪物吸血比例
if (flags.hard == 1) value /= 2; // 简单难度下吸血值减半
// 使用局部变量 value 代替 enemy.value
var str = "\r[\#e525ff]【红海技能】\r战斗前，首先吸取对方的"
+ Math.floor(100 * value) + "%生命（约"
+ Math.floor(value * core.getRealStatus('hp')) + "点）作为伤害"
+ (enemy.add ? "，并把伤害数值加到自身生命上" : "");
if (core.hasItem("I_noVampire")) str += "\r[yellow]（对你无效）\r";
return str;
}, "#ff00d2"],
```
8.
```js
[28, function (enemy) {
if (enemy.value28 > 0) return "迅捷光环";
return "怠惰光环";
}, function (enemy) {
var str;
// 直接 return 可以不显示具体技能内容。
if (flags.hard == 1) return '此技能在简单难度下无效！';
if (core.hasItem('I123')) return '此技能已被魔杖抵消！';
if (!enemy.range) {
str = "同楼层所有友军";
} else {
str = "周围" + (enemy.zoneSquare ? "方形" : "十字") + "范围内\r[yellow]" + (enemy.range || 1) + "\r格的友军";
}
if (enemy.value28 > 0) {
str += "先攻\r[yellow]" + (enemy.value28 || 0) + "\r回合。";
} else {
str += "被先攻\r[yellow]" + (-enemy.value28 || 0) + "\r回合。";
}
return str;
}, "#00dd00", 1],
```
9.
```js
[30, "匙之力", function (enemy) {
var str = "";
if (enemy.range) {
str += "周围" + (enemy.zoneSquare ? "方形" : "十字") + "范围内\r[yellow]" + enemy.range + "\r格，每存在一把黄钥匙，";
}
else str += "同楼层每存在一把黄钥匙，";
if (enemy.value) str += "生命增加\r[yellow]" + enemy.value + "\r点，";
if (enemy.atkValue) str += "攻击增加\r[yellow]" + enemy.atkValue + "\r点，";
if (enemy.defValue) str += "防御增加\r[yellow]" + enemy.defValue + "\r点，";
str += "线性叠加。1把蓝钥匙=3把黄钥匙，1把红钥匙=10把黄钥匙。";
return str;
}, "#A0A000", 1],
```
10. 使用配置表格增设如下项目（也可以使用更好的名称如laserValue）：
```js
"v1": {
"_leaf": true,
"_type": "textarea",
"_docs": "阻击伤害"
},
"v2": {
"_leaf": true,
"_type": "textarea",
"_docs": "激光伤害"
},
"v3": {
"_leaf": true,
"_type": "textarea",
"_docs": "领域伤害"
},
"v4": {
"_leaf": true,
"_type": "textarea",
"_docs": "吸血比例"
},
```
然后，特殊描述可以如下修改（分别使用v1, v2, v3, v4代替value）：
```js
[11, "吸血", function (enemy) { return "战斗前，怪物首先吸取角色的" + Math.floor(100 * enemy.v4 || 0) + "%生命（约" + Math.floor((enemy.v4 || 0) * core.getStatus('hp')) + "点）作为伤害" + (enemy.add ? "，并把伤害数值加到自身生命上" : ""); }, "#dd4448"],
[15, "领域", function (enemy) { return "经过怪物周围" + (enemy.zoneSquare ? "九宫格" : "十字") + "范围内" + (enemy.range || 1) + "格时自动减生命" + (enemy.v3 || 0) + "点"; }, "#c677dd"],
[18, "阻击", function (enemy) { return "经过怪物周围" + (enemy.zoneSquare ? "九宫格" : "十字") + "时自动减生命" + (enemy.v1 || 0) + "点，同时怪物后退一格"; }, "#8888e6"],
[24, "激光", function (enemy) { return "经过怪物同行或同列时自动减生命" + (enemy.v2 || 0) + "点"; }, "#dda0dd"],
```
最后，修改实际效果。
```js
// 吸血：getDamageInfo（节选）
if (core.hasSpecial(mon_special, 11)) {
/** ！！使用enemy.v4替代enemy.value！！ **/
var vampire_damage = hero_hp * enemy.v4;
// 如果有神圣盾免疫吸血等可以在这里写
// 也可以用hasItem和hasEquip来判定装备
// if (core.hasFlag('shield5')) vampire_damage = 0;
vampire_damage = Math.floor(vampire_damage) || 0;
// 加到自身
if (enemy.add) // 如果加到自身
mon_hp += vampire_damage;
init_damage += vampire_damage;
}
```
```js
// 领域：updateCheckBlock（节选）
for (var dx = -range; dx <= range; dx++) {
for (var dy = -range; dy <= range; dy++) {
if (dx == 0 && dy == 0) continue;
var nx = x + dx,
ny = y + dy,
currloc = nx + "," + ny;
if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
// 如果是十字领域，则还需要满足 |dx|+|dy|<=range
if (!zoneSquare && Math.abs(dx) + Math.abs(dy) > range) continue;
/** ！！使用enemy.v3替代enemy.value！！ **/
damage[currloc] = (damage[currloc] || 0) + (enemy.v3 || 0);
type[currloc] = type[currloc] || {};
type[currloc]["领域伤害"] = true;
}
}
```
激光和阻击同领域实现。

38
_codelab/L3.md Normal file
View File

@ -0,0 +1,38 @@
# 第三章：怪物真实属性获取（getEnemyInfo）
要求：读懂脚本编辑 - 怪物真实属性（getEnemyInfo）的实现（无需理解支援）。理解如何动态修改怪物的三维，理解光环效果的实现并知晓如何新增光环效果，理解如何定义新变量并在getDamageInfo中取用。
回答如下问题：
1. 为什么要存在`getEnemyInfo`函数以获得怪物真实属性？所有东西都写在`getDamageInfo`里面不好吗？
2. 实现**仿攻（编号45）**：怪物攻击不低于勇士攻击。
3. 实现**窥血为攻（编号36）**： 战斗开始时，自身攻击力变为角色当前生命值的10%，向下取整。这种写法比第一章中在`getDamageInfo`中写法效果更好，为什么？
4. 仅修改`getEnemyInfo`，实现一个怪物`E345`满足：
- 简单难度（flag:hard==1）下，无特殊属性。
- 普通难度（flag:hard==2）下，拥有先攻属性。
- 困难难度（flag:hard==3）下，拥有三连击属性。
- 噩梦难度（flag:hard==4）下，同时拥有先攻、魔攻、二连击属性。
- 如果玩家拥有道具`I123`，则直接无视此怪物所有属性。
5. 仅修改`getEnemyInfo`，实现一个道具`I234`：**当玩家持有此道具时，怪物的血攻防均降低10%。**
6. 仅修改`getEnemyInfo`，实现特殊属性 **「上位压制」（特殊编号46）**：玩家每低于怪物一个等级（通过`core.getStatus('lv')`获得当前玩家等级，通过`enemy.level`获得该怪物的等级），怪物三维提升10%；玩家每高于怪物一个等级，怪物三维降低5%。
7. 解释光环的缓存原理。为什么光环需要缓存？
8. `index`是什么意思？ `var cache = core.status.checkBlock.cache[index];` 是干什么的？
9. 在默认光环的实现中，`hp_buff`, `atk_buff`, `def_buff`, `usedEnemyIds` 分别是干什么的？
10. 在默认光环的实现中，怪物属性的`value`, `atkValue`和`defValue`用于控制怪物的比例增幅。将其效果修改成数值增幅（例如 `value = 50` 表示生命提升50点，而不是50%）。
11. 局部光环的实现原理是什么？十字和九宫格光环是如何区分的？
12. 实现 **「协同作战」（特殊属性47）**：同楼层/周围X格（由range和zoneSquare决定），每存在一个该属性的队友（包括自身），生命和攻防对应比例提升（提升比例由怪物value, atkValue, defValue决定，线性叠加）。并在游戏中实际验证效果。（注意这个效果和默认光环的区别）。
13. 实现 **「迅捷光环」（特殊属性28）**：同楼层/周围X格（由range和zoneSquare决定）的怪物额外先攻X回合（由此怪物的value28决定）。并在游戏中实际验证效果。
14. 实现 **「吸血光环」（特殊属性48）**：同楼层/周围X格（由range和zoneSquare决定）的怪物拥有「吸血」特殊属性，吸血比例由光环怪的`vampireValue`项决定。并在游戏中实际验证效果。

4
_codelab/_sidebar.md Normal file
View File

@ -0,0 +1,4 @@
- [第一章：伤害计算函数](L1)
- [第二章：特殊属性定义，表格配置](L2)
- [第三章：怪物真实属性](L3)

2
_codelab/docsify.min.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

86
_codelab/index.html Normal file
View File

@ -0,0 +1,86 @@
<!DOCTYPE html>
<html lang="ch_ZN">
<head>
<meta charset="UTF-8">
<title>HTML5魔塔样板JS进阶</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
<meta name="description" content="Description">
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
<link href="vue.css" rel="stylesheet">
</head>
<body>
<div id="app"></div>
<xml id="toolbox" style="display:none"></xml>
<div id="blocklyArea" style="opacity: 0;z-index: -1;"><div id="blocklyDiv"></div></div>
<textarea id="codeArea" style="display:none" spellcheck="false"></textarea>
<script>
window.$docsify = {
homepage: 'L1.md',
loadSidebar: true,
name: 'HTML5魔塔样板',
repo: 'https://github.com/ckcz123/mota-js',
// basepath: '../docs/',
// Search Support
search: {
maxAge: 43200000, // 过期时间，单位毫秒，默认一天
paths: 'auto',
placeholder: {
'/': '搜索文档...',
},
noData: {
'/': '找不到结果',
},
},
// load sidebar from _sidebar.md
loadSidebar: '_sidebar',
subMaxLevel: 2,
autoHeader: true,
auto2top: true,
mergeNavbar: true,
formatUpdated: '{YYYY}-{MM}-{DD} {HH}:{mm}:{ss}',
plugins: [
/*
function(hook){
var renderScriptNode=function(str){
return str.replace(/```.*?\r?\n['"]run['"];[^]*?\r?\n```/g,function(x){
return eval(`(function(){${x.replace(/```.*?\r?\n['"]run['"];/,'').slice(0,-3)}})()`)
})
}
var renderMotaAction=function(str){
return str.replace(bg.pattern,function(x){
return bg.replaceFunc(x)
})
}
hook.beforeEach(function(content){
return renderMotaAction(renderScriptNode(
content
))
})
hook.doneEach(function(){
var map=bg.replaceToken
var node=document.querySelector('.markdown-section')
var str=node.innerHTML
for(var id in map){
str=str.replace(id,map[id])
}
node.innerHTML=str
})
}
*/
]
}
</script>
<!-- 为了保证时序用脚本加载这两个 -->
<script src="docsify.min.js"></script>
</body>
</html>

5
_codelab/index.md Normal file
View File

@ -0,0 +1,5 @@
# H5脚本进阶顺序
```
伤害计算 - 战后 - 自绘状态栏 - 其他脚本编辑如检查地图伤害 - 插件中简单的复写libs - 自己根据API写插件函数 - 使用register系列注册点击和动画等 - 啃libs的实现 - 啃编辑器
```

1
_codelab/vue.css Normal file
View File

File diff suppressed because one or more lines are too long