战斗切精灵失效bug待修复

This commit is contained in:
2025-09-07 05:58:47 +08:00
parent 9d2de92dd6
commit e111e08638
6 changed files with 330 additions and 209 deletions

View File

@@ -95,9 +95,9 @@ var dualElementMap = map[int][2]int{
// 元素组合结构体
type ElementCombination struct {
primary ElementType // 主属性1-17
secondary *ElementType // 副属性1-17双属性时非空
id int // 组合ID
Primary ElementType // 主属性1-17
Secondary *ElementType // 副属性1-17双属性时非空
ID int // 组合ID
}
// 创建元素组合(严格验证范围)
@@ -116,9 +116,9 @@ func NewElementCombination(id int) (*ElementCombination, error) {
primary, secondary = secondary, primary
}
return &ElementCombination{
primary: primary,
secondary: &secondary,
id: id,
Primary: primary,
Secondary: &secondary,
ID: id,
}, nil
}
@@ -126,36 +126,36 @@ func NewElementCombination(id int) (*ElementCombination, error) {
return nil, fmt.Errorf("单属性ID必须为1-17实际: %d", id)
}
return &ElementCombination{
primary: ElementType(id),
secondary: nil,
id: id,
Primary: ElementType(id),
Secondary: nil,
ID: id,
}, nil
}
// 判断是否为双属性
func (ec *ElementCombination) IsDual() bool {
return ec.secondary != nil
return ec.Secondary != nil
}
// 获取所有属性
func (ec *ElementCombination) Elements() []ElementType {
if ec.IsDual() {
return []ElementType{ec.primary, *ec.secondary}
return []ElementType{ec.Primary, *ec.Secondary}
}
return []ElementType{ec.primary}
return []ElementType{ec.Primary}
}
// 缓存键
func (ec *ElementCombination) CacheKey() string {
return fmt.Sprintf("id_%d", ec.id)
return fmt.Sprintf("id_%d", ec.ID)
}
// 字符串展示
func (ec *ElementCombination) String() string {
if ec.IsDual() {
return fmt.Sprintf("(%v, %v)", ec.primary, *ec.secondary)
return fmt.Sprintf("(%v, %v)", ec.Primary, *ec.Secondary)
}
return fmt.Sprintf("(%vv)", ec.primary)
return fmt.Sprintf("(%vv)", ec.Primary)
}
// 元素计算器(全属性支持+缓存)
@@ -375,85 +375,85 @@ func (c *ElementCalculator) GetOffensiveMultiplier(attackerXID, defenderYID int)
// 核心计算逻辑(严格遵循橙汁学姐规则)
func (c *ElementCalculator) calculateMultiplier(attackerX, defenderY *ElementCombination) float64 {
// 1. 单属性→单属性:直接查表
if !attackerX.IsDual() && !defenderY.IsDual() {
return c.tableMatrix[attackerX.primary][defenderY.primary]
}
// 1. 单属性→单属性:直接查表
if !attackerX.IsDual() && !defenderY.IsDual() {
return c.tableMatrix[attackerX.Primary][defenderY.Primary]
}
// 2. 单属性→双属性:拆分防守方,分类计算
if !attackerX.IsDual() {
y1, y2 := defenderY.primary, *defenderY.secondary
m1 := c.tableMatrix[attackerX.primary][y1]
m2 := c.tableMatrix[attackerX.primary][y2]
// 2. 单属性→双属性:拆分防守方,分类计算
if !attackerX.IsDual() {
y1, y2 := defenderY.Primary, *defenderY.Secondary
m1 := c.tableMatrix[attackerX.Primary][y1]
m2 := c.tableMatrix[attackerX.Primary][y2]
// 单→双规则:双克制=4含无效÷4其他÷2
if m1 == 2 && m2 == 2 {
return 4.0
} else if m1 == 0 || m2 == 0 {
return (m1 + m2) / 4.0
} else {
return (m1 + m2) / 2.0
}
}
// 单→双规则:双克制=4含无效÷4其他÷2
if m1 == 2 && m2 == 2 {
return 4.0
} else if m1 == 0 || m2 == 0 {
return (m1 + m2) / 4.0
} else {
return (m1 + m2) / 2.0
}
}
// 3. 双属性→单属性:拆分攻击方,分类计算
if !defenderY.IsDual() {
x1, x2 := attackerX.primary, *attackerX.secondary
k1 := c.tableMatrix[x1][defenderY.primary]
k2 := c.tableMatrix[x2][defenderY.primary]
// 3. 双属性→单属性:拆分攻击方,分类计算
if !defenderY.IsDual() {
x1, x2 := attackerX.Primary, *attackerX.Secondary
k1 := c.tableMatrix[x1][defenderY.Primary]
k2 := c.tableMatrix[x2][defenderY.Primary]
// 补全默认值未定义的普通关系为1.0
if k1 == 0 && c.tableMatrix[x1][defenderY.primary] != 0 {
k1 = 1.0
}
if k2 == 0 && c.tableMatrix[x2][defenderY.primary] != 0 {
k2 = 1.0
}
// 补全默认值未定义的普通关系为1.0
if k1 == 0 && c.tableMatrix[x1][defenderY.Primary] != 0 {
k1 = 1.0
}
if k2 == 0 && c.tableMatrix[x2][defenderY.Primary] != 0 {
k2 = 1.0
}
// 双→单规则:双克制=4含无效÷4其他÷2
if k1 == 2 && k2 == 2 {
return 4.0
} else if k1 == 0 || k2 == 0 {
return (k1 + k2) / 4.0
} else {
return (k1 + k2) / 2.0
}
}
// 双→单规则:双克制=4含无效÷4其他÷2
if k1 == 2 && k2 == 2 {
return 4.0
} else if k1 == 0 || k2 == 0 {
return (k1 + k2) / 4.0
} else {
return (k1 + k2) / 2.0
}
}
// 4. 双属性→双属性:拆分防守方为两个单属性,分别计算双→单后取平均
x1, x2 := attackerX.primary, *attackerX.secondary
y1, y2 := defenderY.primary, *defenderY.secondary
// 4. 双属性→双属性:拆分防守方为两个单属性,分别计算双→单后取平均
x1, x2 := attackerX.Primary, *attackerX.Secondary
y1, y2 := defenderY.Primary, *defenderY.Secondary
// 计算攻击方对防守方第一个单属性y1的双→单系数
coeffY1 := c.calculateDualToSingle(x1, x2, y1)
// 计算攻击方对防守方第二个单属性y2的双→单系数
coeffY2 := c.calculateDualToSingle(x1, x2, y2)
// 计算攻击方对防守方第一个单属性y1的双→单系数
coeffY1 := c.calculateDualToSingle(x1, x2, y1)
// 计算攻击方对防守方第二个单属性y2的双→单系数
coeffY2 := c.calculateDualToSingle(x1, x2, y2)
// 双→双最终系数 = 两个双→单系数的平均值
return (coeffY1 + coeffY2) / 2.0
// 双→双最终系数 = 两个双→单系数的平均值
return (coeffY1 + coeffY2) / 2.0
}
// 辅助函数:双属性攻击单属性的核心计算(提取复用逻辑)
func (c *ElementCalculator) calculateDualToSingle(attacker1, attacker2, defender ElementType) float64 {
k1 := c.tableMatrix[attacker1][defender]
k2 := c.tableMatrix[attacker2][defender]
k1 := c.tableMatrix[attacker1][defender]
k2 := c.tableMatrix[attacker2][defender]
// 补全默认值未定义的普通关系为1.0
if k1 == 0 && c.tableMatrix[attacker1][defender] != 0 {
k1 = 1.0
}
if k2 == 0 && c.tableMatrix[attacker2][defender] != 0 {
k2 = 1.0
}
// 补全默认值未定义的普通关系为1.0
if k1 == 0 && c.tableMatrix[attacker1][defender] != 0 {
k1 = 1.0
}
if k2 == 0 && c.tableMatrix[attacker2][defender] != 0 {
k2 = 1.0
}
// 双→单规则应用
if k1 == 2 && k2 == 2 {
return 4.0
} else if k1 == 0 || k2 == 0 {
return (k1 + k2) / 4.0
} else {
return (k1 + k2) / 2.0
}
// 双→单规则应用
if k1 == 2 && k2 == 2 {
return 4.0
} else if k1 == 0 || k2 == 0 {
return (k1 + k2) / 4.0
} else {
return (k1 + k2) / 2.0
}
}
// 全场景测试用例