Merge branch 'v2.x'

Author: unanmed

_codelab/L1.md

@@ -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)

_codelab/L1_answer.md

@@ -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)
+	};
+}
+```