556 lines
14 KiB
JavaScript
556 lines
14 KiB
JavaScript
var PassiveMaker = /** @class */ (function () {
|
|
function PassiveMaker() {}
|
|
PassiveMaker.prototype.make = function (actor, skill, battleMembers) {
|
|
var passiveSkills = this.makePassiveSkills(skill);
|
|
if (passiveSkills.length == 0) {
|
|
return [];
|
|
}
|
|
var result = [];
|
|
for (
|
|
var _i = 0, passiveSkills_1 = passiveSkills;
|
|
_i < passiveSkills_1.length;
|
|
_i++
|
|
) {
|
|
var passiveSkill = passiveSkills_1[_i];
|
|
if (!passiveSkill) {
|
|
continue;
|
|
}
|
|
var targets = this.makePassiveTargets(actor, skill, battleMembers);
|
|
passiveSkill.setTargets(targets);
|
|
var valueRate = this.calcValueRate(skill, battleMembers, actor);
|
|
passiveSkill.setValueRate(valueRate);
|
|
result.push(passiveSkill);
|
|
}
|
|
return result;
|
|
};
|
|
PassiveMaker.prototype.makePassiveSkills = function (skill) {
|
|
var result = [];
|
|
if (skill.meta["agi"]) {
|
|
result.push(
|
|
new PassiveSkill(PassiveType.agiUp, parseInt(skill.meta["agi"]))
|
|
);
|
|
}
|
|
if (skill.meta["atk"]) {
|
|
result.push(
|
|
new PassiveSkill(PassiveType.atkUp, parseInt(skill.meta["atk"]))
|
|
);
|
|
}
|
|
if (skill.meta["mhp"]) {
|
|
result.push(
|
|
new PassiveSkill(PassiveType.mhpUp, parseInt(skill.meta["mhp"]))
|
|
);
|
|
}
|
|
if (skill.meta["mhpSelf"]) {
|
|
result.push(
|
|
new PassiveSkill(PassiveType.mhpSelf, parseInt(skill.meta["mhpSelf"]))
|
|
);
|
|
}
|
|
if (skill.meta["atkSelf"]) {
|
|
result.push(
|
|
new PassiveSkill(PassiveType.atkSelf, parseInt(skill.meta["atkSelf"]))
|
|
);
|
|
}
|
|
if (skill.meta["agiSelf"]) {
|
|
result.push(
|
|
new PassiveSkill(PassiveType.agiSelf, parseInt(skill.meta["agiSelf"]))
|
|
);
|
|
}
|
|
if (skill.meta["skillRate"]) {
|
|
result.push(
|
|
new PassiveSkill(
|
|
PassiveType.skillRateUp,
|
|
parseInt(skill.meta["skillRate"])
|
|
)
|
|
);
|
|
}
|
|
if (skill.meta["deathAtk"]) {
|
|
result.push(
|
|
new PassiveSkill(PassiveType.deathAtk, parseInt(skill.meta["deathAtk"]))
|
|
);
|
|
}
|
|
if (skill.meta["recoverHp"]) {
|
|
result.push(
|
|
new PassiveSkill(
|
|
PassiveType.recoverHp,
|
|
parseInt(skill.meta["recoverHp"])
|
|
)
|
|
);
|
|
}
|
|
if (skill.meta["recoverHpAll"]) {
|
|
result.push(
|
|
new PassiveSkill(
|
|
PassiveType.recoverHpAll,
|
|
parseInt(skill.meta["recoverHpAll"])
|
|
)
|
|
);
|
|
}
|
|
if (skill.meta["deathRecover"]) {
|
|
result.push(null);
|
|
}
|
|
if (skill.meta["provoke"]) {
|
|
result.push(
|
|
new PassiveSkill(PassiveType.provoke, parseInt(skill.meta["provoke"]))
|
|
);
|
|
}
|
|
if (result.length == 0) {
|
|
console.error("不正なパッシブスキルです");
|
|
p(skill);
|
|
}
|
|
return result;
|
|
};
|
|
PassiveMaker.prototype.makePassiveTargets = function (
|
|
actor,
|
|
skill,
|
|
battleMembers
|
|
) {
|
|
var candidates = this.makePassiveCandidates(actor, skill, battleMembers);
|
|
return this.applyPassiveCondition(actor, skill, candidates);
|
|
};
|
|
PassiveMaker.prototype.applyPassiveCondition = function (
|
|
actor,
|
|
skill,
|
|
battleMembers
|
|
) {
|
|
var list = [];
|
|
var left = null;
|
|
var right = null;
|
|
if (skill.meta["toMinHp"]) {
|
|
return this.findMinHp(battleMembers);
|
|
}
|
|
for (var i = 0; i < battleMembers.length; i++) {
|
|
var b = battleMembers[i];
|
|
right = battleMembers[i + 1];
|
|
if (skill.meta["toTop"]) {
|
|
list.push(b);
|
|
return list;
|
|
}
|
|
if (skill.meta["toBack"]) {
|
|
if (b == actor) {
|
|
for (var k = i + 1; k < battleMembers.length; k++) {
|
|
var b2 = battleMembers[k];
|
|
list.push(b2);
|
|
}
|
|
return list;
|
|
}
|
|
}
|
|
if (skill.meta["toLeftFlame"]) {
|
|
if (b == actor) {
|
|
if (left && left.element() == MonsterElement.flame) {
|
|
list.push(left);
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["toLeftWater"]) {
|
|
if (b == actor) {
|
|
if (left && left.element() == MonsterElement.water) {
|
|
list.push(left);
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["toLeftWood"]) {
|
|
if (b == actor) {
|
|
if (left && left.element() == MonsterElement.wood) {
|
|
list.push(left);
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["toRightFlame"]) {
|
|
if (b == actor) {
|
|
if (right) {
|
|
if (right.element() == MonsterElement.flame) {
|
|
list.push(right);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["toRightWater"]) {
|
|
if (b == actor) {
|
|
if (right) {
|
|
if (right.element() == MonsterElement.water) {
|
|
list.push(right);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["toRightWood"]) {
|
|
if (b == actor) {
|
|
if (right) {
|
|
if (right.element() == MonsterElement.wood) {
|
|
list.push(right);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["toWater"]) {
|
|
if (b.element() == MonsterElement.water) {
|
|
list.push(b);
|
|
}
|
|
}
|
|
if (skill.meta["toFlame"]) {
|
|
if (b.element() == MonsterElement.flame) {
|
|
list.push(b);
|
|
}
|
|
}
|
|
if (skill.meta["toWood"]) {
|
|
if (b.element() == MonsterElement.wood) {
|
|
list.push(b);
|
|
}
|
|
}
|
|
if (skill.meta["toSelf"]) {
|
|
if (b == actor) {
|
|
list.push(b);
|
|
}
|
|
}
|
|
if (skill.meta["toLeft"]) {
|
|
if (b == actor) {
|
|
list.push(left);
|
|
}
|
|
}
|
|
if (skill.meta["toRight"]) {
|
|
if (b == actor) {
|
|
list.push(right);
|
|
}
|
|
}
|
|
if (skill.meta["toBottomSelf"]) {
|
|
if (b == actor) {
|
|
if (i == battleMembers.length - 1) {
|
|
list.push(b);
|
|
}
|
|
}
|
|
}
|
|
left = b;
|
|
}
|
|
var result = [];
|
|
for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
|
|
var b = list_1[_i];
|
|
if (b) {
|
|
result.push(b);
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
PassiveMaker.prototype.findMinHp = function (battleMembers) {
|
|
var min = battleMembers[0];
|
|
for (
|
|
var _i = 0, battleMembers_1 = battleMembers;
|
|
_i < battleMembers_1.length;
|
|
_i++
|
|
) {
|
|
var b = battleMembers_1[_i];
|
|
if (min.mhpBase() > b.mhpBase()) {
|
|
min = b;
|
|
}
|
|
}
|
|
return [min];
|
|
};
|
|
PassiveMaker.prototype.makePassiveCandidates = function (
|
|
actor,
|
|
skill,
|
|
battleMembers
|
|
) {
|
|
var result = [];
|
|
if (
|
|
skill.meta["toLeft"] ||
|
|
skill.meta["toRight"] ||
|
|
skill.meta["toMinHp"] ||
|
|
skill.meta["toTop"] ||
|
|
skill.meta["toBack"] ||
|
|
skill.meta["toFront"] ||
|
|
skill.meta["toBottomSelf"] ||
|
|
skill.meta["toTopSelf"] ||
|
|
skill.meta["toTop"] ||
|
|
skill.meta["toLeftFlame"] ||
|
|
skill.meta["toLeftWater"] ||
|
|
skill.meta["toLeftWood"] ||
|
|
skill.meta["toRightWater"] ||
|
|
skill.meta["toRightFlame"] ||
|
|
skill.meta["toRightWood"]
|
|
) {
|
|
return battleMembers;
|
|
}
|
|
if (skill.meta["toFriend"]) {
|
|
for (
|
|
var _i = 0, battleMembers_2 = battleMembers;
|
|
_i < battleMembers_2.length;
|
|
_i++
|
|
) {
|
|
var b = battleMembers_2[_i];
|
|
if (b == actor) {
|
|
continue;
|
|
}
|
|
if (b) {
|
|
result.push(b);
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["toSelf"]) {
|
|
result.push(actor);
|
|
}
|
|
return result;
|
|
};
|
|
PassiveMaker.prototype.calcValueRate = function (
|
|
skill,
|
|
battleMembers,
|
|
actor
|
|
) {
|
|
var result = 0;
|
|
var isEnabled = false;
|
|
if (skill.meta["flameCount"]) {
|
|
isEnabled = true;
|
|
var value = parseInt(skill.meta["flameCount"]);
|
|
for (
|
|
var _i = 0, battleMembers_3 = battleMembers;
|
|
_i < battleMembers_3.length;
|
|
_i++
|
|
) {
|
|
var b = battleMembers_3[_i];
|
|
if (b == actor) {
|
|
continue;
|
|
}
|
|
if (b.element() == MonsterElement.flame) {
|
|
result += value;
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["woodCount"]) {
|
|
isEnabled = true;
|
|
var value = parseInt(skill.meta["woodCount"]);
|
|
for (
|
|
var _a = 0, battleMembers_4 = battleMembers;
|
|
_a < battleMembers_4.length;
|
|
_a++
|
|
) {
|
|
var b = battleMembers_4[_a];
|
|
if (b == actor) {
|
|
continue;
|
|
}
|
|
if (b.element() == MonsterElement.wood) {
|
|
result += value;
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["waterCount"]) {
|
|
isEnabled = true;
|
|
var value = parseInt(skill.meta["waterCount"]);
|
|
for (
|
|
var _b = 0, battleMembers_5 = battleMembers;
|
|
_b < battleMembers_5.length;
|
|
_b++
|
|
) {
|
|
var b = battleMembers_5[_b];
|
|
if (b == actor) {
|
|
continue;
|
|
}
|
|
if (b.element() == MonsterElement.water) {
|
|
result += value;
|
|
}
|
|
}
|
|
}
|
|
if (skill.meta["frontCount"]) {
|
|
isEnabled = true;
|
|
var value = parseInt(skill.meta["frontCount"]);
|
|
for (
|
|
var _c = 0, battleMembers_6 = battleMembers;
|
|
_c < battleMembers_6.length;
|
|
_c++
|
|
) {
|
|
var b = battleMembers_6[_c];
|
|
if (b == actor) {
|
|
break;
|
|
}
|
|
result += value;
|
|
}
|
|
}
|
|
if (!isEnabled) {
|
|
return -1;
|
|
}
|
|
return result;
|
|
};
|
|
return PassiveMaker;
|
|
})();
|
|
var PassiveSkills = /** @class */ (function () {
|
|
function PassiveSkills() {
|
|
this._skills = [];
|
|
/*
|
|
paramPlusSelf(battleActor: BattleActor, value: number, type: PassiveType): number {
|
|
let rate = 0;
|
|
|
|
for (const s of this._skills) {
|
|
if (s.type() == type) {
|
|
if (s.isTarget(battleActor)) {
|
|
rate += s.value();
|
|
}
|
|
}
|
|
}
|
|
return Math.round(value * rate / 100);
|
|
}*/
|
|
}
|
|
PassiveSkills.prototype.push = function (skill) {
|
|
this._skills.push(skill);
|
|
};
|
|
PassiveSkills.prototype.agiPlus = function (battleActor) {
|
|
var result = 0;
|
|
result += this.paramRatePlus(
|
|
battleActor,
|
|
battleActor.agiBase(),
|
|
PassiveType.agiUp
|
|
);
|
|
result += this.paramRatePlus(
|
|
battleActor,
|
|
battleActor.agiBase(),
|
|
PassiveType.agiSelf
|
|
);
|
|
return result;
|
|
};
|
|
PassiveSkills.prototype.atkPlus = function (battleActor) {
|
|
var result = 0;
|
|
result += this.paramRatePlus(
|
|
battleActor,
|
|
battleActor.atkBase(),
|
|
PassiveType.atkUp
|
|
);
|
|
result += this.paramRatePlus(
|
|
battleActor,
|
|
battleActor.atkBase(),
|
|
PassiveType.atkSelf
|
|
);
|
|
return result;
|
|
};
|
|
PassiveSkills.prototype.deathAtk = function (battleActor, value) {
|
|
var rate = 0;
|
|
for (var _i = 0, _a = this._skills; _i < _a.length; _i++) {
|
|
var s = _a[_i];
|
|
if (s.type() == PassiveType.deathAtk) {
|
|
if (s.isTarget(battleActor)) {
|
|
var n = $slg.formation().deadMembers().length;
|
|
rate += s.value() * n;
|
|
}
|
|
}
|
|
}
|
|
return Math.round((value * rate) / 100);
|
|
};
|
|
PassiveSkills.prototype.mhpPlus = function (battleActor) {
|
|
var result = 0;
|
|
result += this.paramRatePlus(
|
|
battleActor,
|
|
battleActor.mhpBase(),
|
|
PassiveType.mhpUp
|
|
);
|
|
result += this.paramRatePlus(
|
|
battleActor,
|
|
battleActor.mhpBase(),
|
|
PassiveType.mhpSelf
|
|
);
|
|
return result;
|
|
};
|
|
PassiveSkills.prototype.skillRatePlus = function (battleActor) {
|
|
var result = 0;
|
|
result += this.paramPlus(battleActor, 0, PassiveType.skillRateUp);
|
|
result += this.paramPlus(battleActor, 0, PassiveType.skillRateSelf);
|
|
return result;
|
|
};
|
|
PassiveSkills.prototype.paramRatePlus = function (battleActor, value, type) {
|
|
var rate = 0;
|
|
for (var _i = 0, _a = this._skills; _i < _a.length; _i++) {
|
|
var s = _a[_i];
|
|
if (s.type() == type) {
|
|
if (s.isTarget(battleActor)) {
|
|
rate += s.value();
|
|
}
|
|
}
|
|
}
|
|
return Math.round((value * rate) / 100);
|
|
};
|
|
PassiveSkills.prototype.paramPlus = function (battleActor, value, type) {
|
|
var n = 0;
|
|
for (var _i = 0, _a = this._skills; _i < _a.length; _i++) {
|
|
var s = _a[_i];
|
|
if (s.type() == type) {
|
|
if (s.isTarget(battleActor)) {
|
|
n += s.value();
|
|
}
|
|
}
|
|
}
|
|
return n;
|
|
};
|
|
PassiveSkills.prototype.provokeValue = function (battleActor) {
|
|
var n = 0;
|
|
for (var _i = 0, _a = this._skills; _i < _a.length; _i++) {
|
|
var s = _a[_i];
|
|
if (s.type() == PassiveType.provoke) {
|
|
if (s.isTarget(battleActor)) {
|
|
n += s.value();
|
|
}
|
|
}
|
|
}
|
|
return n;
|
|
};
|
|
return PassiveSkills;
|
|
})();
|
|
var PassiveSkill = /** @class */ (function () {
|
|
function PassiveSkill(type, value) {
|
|
this._targetIdList = [];
|
|
this._type = type;
|
|
this._value = value;
|
|
this._valueRate = -1;
|
|
}
|
|
PassiveSkill.prototype.type = function () {
|
|
return this._type;
|
|
};
|
|
PassiveSkill.prototype.value = function () {
|
|
if (this._valueRate >= 0) {
|
|
return this._value * this._valueRate;
|
|
}
|
|
return this._value;
|
|
};
|
|
PassiveSkill.prototype.setValueRate = function (rate) {
|
|
this._valueRate = rate;
|
|
};
|
|
PassiveSkill.prototype.valueRate = function () {
|
|
return this._valueRate;
|
|
};
|
|
PassiveSkill.prototype.setTargets = function (battleMembers) {
|
|
this._targetIdList = [];
|
|
for (
|
|
var _i = 0, battleMembers_7 = battleMembers;
|
|
_i < battleMembers_7.length;
|
|
_i++
|
|
) {
|
|
var b = battleMembers_7[_i];
|
|
this._targetIdList.push(b.id());
|
|
}
|
|
};
|
|
PassiveSkill.prototype.isTarget = function (battleActor) {
|
|
return this._targetIdList.contains(battleActor.id());
|
|
};
|
|
return PassiveSkill;
|
|
})();
|
|
var PassiveType;
|
|
(function (PassiveType) {
|
|
PassiveType["atkUp"] = "atkUp";
|
|
PassiveType["mhpUp"] = "mhpUp";
|
|
PassiveType["agiUp"] = "agiUp";
|
|
PassiveType["mhpSelf"] = "mhpSelf";
|
|
PassiveType["atkSelf"] = "atkSelf";
|
|
PassiveType["agiSelf"] = "agiSelf";
|
|
PassiveType["deathAtk"] = "deathAtk";
|
|
PassiveType["skillRateUp"] = "skillRateUp";
|
|
PassiveType["skillRateSelf"] = "skillRateSelf";
|
|
PassiveType["recoverHp"] = "recoverHp";
|
|
PassiveType["recoverHpAll"] = "recoverHpAll";
|
|
PassiveType["provoke"] = "provoke";
|
|
})(PassiveType || (PassiveType = {}));
|
|
var SKILL_VALUE_META_LIST = [
|
|
"atk",
|
|
"agi",
|
|
"mhp",
|
|
"mhpSelf",
|
|
"agiSelf",
|
|
"atkSelf",
|
|
"damage",
|
|
"skillRate",
|
|
"deathRecover",
|
|
"recoverHp",
|
|
"recoverHpAll",
|
|
"deathAtk",
|
|
];
|