calc-h 0.0.1 → 0.1.1

package/dist/core/o/enemy.d.ts

@@ -1,8 +1,9 @@
 import { Resistance } from './resistance.js';
-export interface Enemy {
+interface Enemy {
     name: string;
     hp: number;
     resistances: Resistance;
     level: number;
 }
-export declare const enemyArray: Enemy[];
+export declare const enemies: Enemy[];
+export {};

package/dist/core/o/enemy.js

@@ -1,3 +1,4 @@
-export const enemyArray = [
-    { name: '木桩', hp: 100000, resistances: { fire: 0.1 }, level: 100 },
+import { Resistance } from './resistance.js';
+export const enemies = [
+    { name: '木桩', hp: 100000, resistances: new Resistance(0.1), level: 100 },
 ];

package/dist/core/o/index.d.ts

@@ -1,12 +1,13 @@
 import { Resistance } from './resistance.js';
+import { RoleDamageRes } from './model/RoleDamageRes.js';
 /**
  * 攻击力计算
  * @author huaju
  * @param baseAttack 基础攻击（白值）
- * @param extreme 加成百分比
- * @param 面板攻击力
+ * @param atkPercent 加成百分比
+ * @returns 面板攻击力
  */
-export declare function attackCalc(baseAttack: number, extreme: number): number;
+export declare function attackCalc(baseAttack: number, atkPercent: number): number;
 /**
  * 基础伤害计算
  * @author huaju
@@ -29,6 +30,7 @@ export declare function featherCalc(attribute: number, multiplier: number): numb
  * @author huaju
  * @param roleLevel 角色等级
  * @param enemyLevel 敌人等级
+ * @returns 防御值
  */
 export declare function defenseCalc(roleLevel: number, enemyLevel: number): number;
 /**
@@ -40,3 +42,42 @@ export declare function defenseCalc(roleLevel: number, enemyLevel: number): numb
  * @returns 最终抗性
  */
 export declare function resistanceCalc(resistance: Resistance, reduce: Resistance): Resistance;
+/**
+ * 基本伤害计算
+ * @author huaju
+ * @description 公式: 攻击力 * 倍率 * (1 + 增伤) * (1 + 暴击伤害) * 防御系数 * (1 - 抗性系数)
+ * @param attack 攻击力
+ * @param multiplier 技能/伤害倍率
+ * @param roleLevel 角色等级
+ * @param enemyLevel 敌人等级
+ * @param enemyResistance 敌人抗性
+ * @param reduce 减伤
+ * @param dmgPercentBonus 伤害加成
+ * @param critDamage 暴击伤害
+ * @param damageType 伤害类型
+ * @returns 计算后的伤害值
+ */
+export declare function calcDamage(attack: number, multiplier: number, roleLevel: number, enemyLevel: number, enemyResistance: Resistance, reduce: Resistance, dmgPercentBonus: number, critDamage: number, damageType: number): number;
+/**
+ * 基本伤害计算
+ * @author huaju
+ * @description 公式: 攻击力 * 倍率 * (1 + 增伤) * (1 + 暴击伤害) * 防御系数 * (1 - 抗性系数)
+ * @param attack 攻击力
+ * @param multiplier 技能/伤害倍率
+ * @param roleLevel 角色等级
+ * @param enemyLevel 敌人等级
+ * @param enemyResistance 敌人抗性
+ * @param reduce 减伤
+ * @param dmgPercentBonus 伤害加成
+ * @param critDamage 暴击伤害
+ * @param damageType 伤害类型
+ * @returns 计算后的伤害值
+ */
+export declare function calcBaseDamage(attack: number, multiplier: number, roleLevel: number, enemyLevel: number, enemyResistance: number, reduce: number, dmgPercentBonus: number, critDamage: number, damageType: number): number;
+/**
+ * 角色伤害计算
+ * @description 公式: 基础攻击力 * (1 + 百分比攻击力加成) * 倍率 * (1 + 增伤) * (1 + 暴击伤害) * 防御系数 * (1 - 抗性系数)
+ * @author huaju
+ */
+export declare function calcRoleDamage(roleName: string, weaponName: string, enemyName: string, roleLevel: number, enemyLevel: number, atkPercent: number, reduce: number, dmgPercentBonus: number, critDamage: number, damageType: number): RoleDamageRes;
+export * from './model/RoleDamageRes.js';

package/dist/core/o/index.js

@@ -1,13 +1,17 @@
+import { Resistance } from './resistance.js';
 import { roundTo } from './utils/calc.js';
+import { roles } from './role.js';
+import { enemies } from './enemy.js';
+import { weapons } from './weapon.js';
 /**
  * 攻击力计算
  * @author huaju
  * @param baseAttack 基础攻击（白值）
- * @param extreme 加成百分比
- * @param 面板攻击力
+ * @param atkPercent 加成百分比
+ * @returns 面板攻击力
  */
-export function attackCalc(baseAttack, extreme) {
-    return roundTo(baseAttack * (1 + extreme));
+export function attackCalc(baseAttack, atkPercent) {
+    return roundTo(baseAttack * (1 + atkPercent));
 }
 /**
  * 基础伤害计算
@@ -35,6 +39,7 @@ export function featherCalc(attribute, multiplier) {
  * @author huaju
  * @param roleLevel 角色等级
  * @param enemyLevel 敌人等级
+ * @returns 防御值
  */
 export function defenseCalc(roleLevel, enemyLevel) {
     return roundTo((roleLevel + 100) / (roleLevel + 100 + enemyLevel + 100));
@@ -49,8 +54,85 @@ export function defenseCalc(roleLevel, enemyLevel) {
  */
 export function resistanceCalc(resistance, reduce) {
     let resultFire = resistance.fire - reduce.fire;
-    let result = {
-        fire: roundTo(resultFire < 0 ? resultFire / 2 : resultFire),
-    };
+    let result = new Resistance(roundTo(resultFire < 0 ? resultFire / 2 : resultFire));
     return result;
 }
+/**
+ * 基本伤害计算
+ * @author huaju
+ * @description 公式: 攻击力 * 倍率 * (1 + 增伤) * (1 + 暴击伤害) * 防御系数 * (1 - 抗性系数)
+ * @param attack 攻击力
+ * @param multiplier 技能/伤害倍率
+ * @param roleLevel 角色等级
+ * @param enemyLevel 敌人等级
+ * @param enemyResistance 敌人抗性
+ * @param reduce 减伤
+ * @param dmgPercentBonus 伤害加成
+ * @param critDamage 暴击伤害
+ * @param damageType 伤害类型
+ * @returns 计算后的伤害值
+ */
+export function calcDamage(attack, multiplier, roleLevel, enemyLevel, enemyResistance, reduce, dmgPercentBonus, critDamage, damageType) {
+    console.debug(`属性参数：${attack}, ${multiplier}, ${roleLevel}, ${enemyLevel}, ${enemyResistance}, ${reduce}, ${dmgPercentBonus}, ${critDamage}`);
+    const resultResistance = resistanceCalc(enemyResistance, reduce).getResistanceType(damageType);
+    if (resultResistance === undefined)
+        throw new Error('传入的伤害类型有误');
+    return roundTo(attack *
+        multiplier *
+        (1 + dmgPercentBonus) *
+        (1 + critDamage) *
+        defenseCalc(roleLevel, enemyLevel) *
+        (1 - resultResistance));
+}
+/**
+ * 基本伤害计算
+ * @author huaju
+ * @description 公式: 攻击力 * 倍率 * (1 + 增伤) * (1 + 暴击伤害) * 防御系数 * (1 - 抗性系数)
+ * @param attack 攻击力
+ * @param multiplier 技能/伤害倍率
+ * @param roleLevel 角色等级
+ * @param enemyLevel 敌人等级
+ * @param enemyResistance 敌人抗性
+ * @param reduce 减伤
+ * @param dmgPercentBonus 伤害加成
+ * @param critDamage 暴击伤害
+ * @param damageType 伤害类型
+ * @returns 计算后的伤害值
+ */
+export function calcBaseDamage(attack, multiplier, roleLevel, enemyLevel, enemyResistance, reduce, dmgPercentBonus, critDamage, damageType) {
+    return calcDamage(attack, multiplier, roleLevel, enemyLevel, new Resistance(enemyResistance), new Resistance(reduce), dmgPercentBonus, critDamage, damageType);
+}
+/**
+ * 角色伤害计算
+ * @description 公式: 基础攻击力 * (1 + 百分比攻击力加成) * 倍率 * (1 + 增伤) * (1 + 暴击伤害) * 防御系数 * (1 - 抗性系数)
+ * @author huaju
+ */
+export function calcRoleDamage(roleName, weaponName, enemyName, roleLevel, enemyLevel, atkPercent, reduce, dmgPercentBonus, critDamage, damageType) {
+    const role = roles.find((x) => x.name === roleName);
+    const weapon = weapons.find((x) => x.name === weaponName);
+    const enemy = enemies.find((x) => x.name === enemyName);
+    if (!role || !weapon || !enemy) {
+        throw new Error('角色/武器/敌人 名称未找到');
+    }
+    let baseAttack = role.baseAttack + weapon.baseAttack;
+    let roleDamageRes = {
+        normalDamage: [],
+        eDamage: [],
+        qDamahe: [],
+        passiveDamage: [],
+    };
+    role.normalAtkDamageBreakdown.forEach((multiplier) => {
+        roleDamageRes.normalDamage.push(calcDamage(baseAttack * (1 + atkPercent + weapon.atkPercent), multiplier, roleLevel, enemyLevel, enemy.resistances, new Resistance(reduce), dmgPercentBonus + weapon.dmgPercentBonus, critDamage + weapon.critDamage + role.critDamage, damageType));
+    });
+    role.eAtkDamageBreakdown.forEach((multiplier) => {
+        roleDamageRes.eDamage.push(calcDamage(baseAttack * (1 + atkPercent + weapon.atkPercent), multiplier, roleLevel, enemyLevel, enemy.resistances, new Resistance(reduce), dmgPercentBonus + weapon.dmgPercentBonus, critDamage + weapon.critDamage + role.critDamage, damageType));
+    });
+    role.qAtkDamageBreakdown.forEach((multiplier) => {
+        roleDamageRes.qDamahe.push(calcDamage(baseAttack * (1 + atkPercent + weapon.atkPercent), multiplier, roleLevel, enemyLevel, enemy.resistances, new Resistance(reduce), dmgPercentBonus + weapon.dmgPercentBonus, critDamage + weapon.critDamage + role.critDamage, damageType));
+    });
+    role.passiveDamageBreakdown.forEach((multiplier) => {
+        roleDamageRes.passiveDamage.push(calcDamage(baseAttack * (1 + atkPercent + weapon.atkPercent), multiplier, roleLevel, enemyLevel, enemy.resistances, new Resistance(reduce), dmgPercentBonus + weapon.dmgPercentBonus, critDamage + weapon.critDamage + role.critDamage, damageType));
+    });
+    return roleDamageRes;
+}
+export * from './model/RoleDamageRes.js';

package/dist/core/o/model/RoleDamageRes.d.ts

@@ -0,0 +1,6 @@
+export interface RoleDamageRes {
+    normalDamage: number[];
+    eDamage: number[];
+    qDamahe: number[];
+    passiveDamage: number[];
+}

package/dist/core/o/model/RoleDamageRes.js

@@ -0,0 +1 @@
+export {};

package/dist/core/o/resistance.d.ts

@@ -1,3 +1,5 @@
-export interface Resistance {
+export declare class Resistance {
     fire: number;
+    constructor(fire: number);
+    getResistanceType(type: number): number | undefined;
 }

package/dist/core/o/resistance.js

@@ -1 +1,13 @@
-export {};
+export class Resistance {
+    constructor(fire) {
+        this.fire = fire;
+    }
+    getResistanceType(type) {
+        switch (type) {
+            case 1:
+                return this.fire;
+            default:
+                return undefined;
+        }
+    }
+}

package/dist/core/o/role.d.ts

@@ -0,0 +1,15 @@
+interface Role {
+    name: string;
+    hp: number;
+    baseAttack: number;
+    defense: number;
+    critRate: number;
+    critDamage: number;
+    level: number;
+    normalAtkDamageBreakdown: number[];
+    eAtkDamageBreakdown: number[];
+    qAtkDamageBreakdown: number[];
+    passiveDamageBreakdown: number[];
+}
+export declare const roles: Role[];
+export {};

package/dist/core/o/role.js

@@ -0,0 +1,15 @@
+export const roles = [
+    {
+        name: '测试角色',
+        hp: 7000,
+        baseAttack: 750,
+        defense: 490,
+        critRate: 0.05,
+        critDamage: 1,
+        level: 100,
+        normalAtkDamageBreakdown: [1.2],
+        eAtkDamageBreakdown: [2.9],
+        qAtkDamageBreakdown: [10],
+        passiveDamageBreakdown: [],
+    },
+];

package/dist/core/o/weapon.d.ts

@@ -0,0 +1,12 @@
+interface Weapon {
+    name: string;
+    baseAttack: number;
+    atkPercent: number;
+    hpPercentBonus: number;
+    defPercentBonus: number;
+    dmgPercentBonus: number;
+    critRate: number;
+    critDamage: number;
+}
+export declare const weapons: Weapon[];
+export {};

package/dist/core/o/weapon.js

@@ -0,0 +1,12 @@
+export const weapons = [
+    {
+        name: '测试武器',
+        baseAttack: 600,
+        atkPercent: 0.5,
+        hpPercentBonus: 0.5,
+        defPercentBonus: 0.8,
+        dmgPercentBonus: 0.4,
+        critRate: 0.2,
+        critDamage: 1.2,
+    },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "calc-h",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "description": "伤害计算公式集",
   "license": "MIT",
   "author": "huaju",