Implement 10 Relics

internal/relic/cavern/band/band.go

@@ -0,0 +1,63 @@
+package band
+
+import (
+	"github.com/simimpact/srsim/pkg/engine"
+	"github.com/simimpact/srsim/pkg/engine/equip/relic"
+	"github.com/simimpact/srsim/pkg/engine/event"
+	"github.com/simimpact/srsim/pkg/engine/info"
+	"github.com/simimpact/srsim/pkg/engine/modifier"
+	"github.com/simimpact/srsim/pkg/engine/prop"
+	"github.com/simimpact/srsim/pkg/key"
+	"github.com/simimpact/srsim/pkg/model"
+)
+
+const (
+	check = "band-of-sizzling-thunder"
+	buff  = "band-of-sizzling-thunder-buff"
+)
+
+// 2pc: Increases Lightning DMG by 10%.
+// 4pc: When the wearer uses their Skill, increases the wearer's ATK by 20% for 1 turn(s).
+
+func init() {
+	relic.Register(key.BandOfSizzlingThunder, relic.Config{
+		Effects: []relic.SetEffect{
+			{
+				MinCount:     2,
+				Stats:        info.PropMap{prop.ThunderDamagePercent: 0.1},
+				CreateEffect: nil,
+			},
+			{
+				MinCount: 4,
+				Stats:    nil,
+				CreateEffect: func(engine engine.Engine, owner key.TargetID) {
+					engine.AddModifier(owner, info.Modifier{
+						Name:   check,
+						Source: owner,
+					})
+				},
+			},
+		},
+	})
+	modifier.Register(check, modifier.Config{
+		Listeners: modifier.Listeners{
+			OnBeforeAction: onBeforeSkill,
+		},
+	})
+	modifier.Register(buff, modifier.Config{
+		Stacking:   modifier.ReplaceBySource,
+		StatusType: model.StatusType_STATUS_BUFF,
+		CanDispel:  true,
+		Duration:   1,
+	})
+}
+
+func onBeforeSkill(mod *modifier.Instance, e event.ActionStart) {
+	if e.AttackType == model.AttackType_SKILL {
+		mod.Engine().AddModifier(mod.Owner(), info.Modifier{
+			Name:   buff,
+			Source: mod.Owner(),
+			Stats:  info.PropMap{prop.ATKPercent: 0.2},
+		})
+	}
+}

internal/relic/cavern/disciple/disciple.go

@@ -0,0 +1,83 @@
+package disciple
+
+import (
+	"github.com/simimpact/srsim/pkg/engine"
+	"github.com/simimpact/srsim/pkg/engine/equip/relic"
+	"github.com/simimpact/srsim/pkg/engine/event"
+	"github.com/simimpact/srsim/pkg/engine/info"
+	"github.com/simimpact/srsim/pkg/engine/modifier"
+	"github.com/simimpact/srsim/pkg/engine/prop"
+	"github.com/simimpact/srsim/pkg/key"
+	"github.com/simimpact/srsim/pkg/model"
+)
+
+const (
+	check  = "longevous-disciple"
+	crbuff = "longevous-disciple-cr-buff"
+)
+
+// 2pc: Increases Max HP by 12%.
+// 4pc: When the wearer is hit or has their HP consumed by an ally or themselves,
+//      their CRIT Rate increases by 8% for 2 turn(s) and up to 2 stacks.
+
+// TO-DO: in onHPChange, assumes e.Target means source; check whether this is correct
+
+func init() {
+	relic.Register(key.LongevousDisciple, relic.Config{
+		Effects: []relic.SetEffect{
+			{
+				MinCount:     2,
+				Stats:        info.PropMap{prop.HPPercent: 0.12},
+				CreateEffect: nil,
+			},
+			{
+				MinCount: 4,
+				Stats:    nil,
+				CreateEffect: func(engine engine.Engine, owner key.TargetID) {
+					engine.AddModifier(owner, info.Modifier{
+						Name:   check,
+						Source: owner,
+					})
+				},
+			},
+		},
+	})
+	modifier.Register(check, modifier.Config{
+		Listeners: modifier.Listeners{
+			OnHPChange:           onHPChange,
+			OnAfterBeingAttacked: onAfterBeingAttacked,
+		},
+	})
+	modifier.Register(crbuff, modifier.Config{
+		Stacking:          modifier.ReplaceBySource,
+		StatusType:        model.StatusType_STATUS_BUFF,
+		CanDispel:         true,
+		MaxCount:          2,
+		CountAddWhenStack: 1,
+		Duration:          2,
+		Listeners: modifier.Listeners{
+			OnAdd: onAdd,
+		},
+	})
+}
+
+func onHPChange(mod *modifier.Instance, e event.HPChange) {
+	// source is friendly, not HP change by damage, hp change is negative
+	if mod.Engine().IsCharacter(e.Target) && !e.IsHPChangeByDamage && e.NewHP < e.OldHP {
+		mod.Engine().AddModifier(mod.Owner(), info.Modifier{
+			Name:   crbuff,
+			Source: mod.Owner(),
+		})
+	}
+}
+
+func onAfterBeingAttacked(mod *modifier.Instance, e event.AttackEnd) {
+	mod.Engine().AddModifier(mod.Owner(), info.Modifier{
+		Name:   crbuff,
+		Source: mod.Owner(),
+	})
+}
+
+func onAdd(mod *modifier.Instance) {
+	mod.AddProperty(prop.ATKPercent, 0.08*mod.Count())
+}

internal/relic/cavern/eagle/eagle.go

@@ -0,0 +1,55 @@
+package eagle
+
+import (
+	"github.com/simimpact/srsim/pkg/engine"
+	"github.com/simimpact/srsim/pkg/engine/equip/relic"
+	"github.com/simimpact/srsim/pkg/engine/event"
+	"github.com/simimpact/srsim/pkg/engine/info"
+	"github.com/simimpact/srsim/pkg/engine/modifier"
+	"github.com/simimpact/srsim/pkg/engine/prop"
+	"github.com/simimpact/srsim/pkg/key"
+	"github.com/simimpact/srsim/pkg/model"
+)
+
+const eagle = "eagle-of-twilight-thunder"
+
+// 2pc: Increases Wind DMG by 10%.
+// 4pc: After the wearer uses their Ultimate, their action is Advanced Forward by 25%.
+
+func init() {
+	relic.Register(key.EagleOfTwilightLine, relic.Config{
+		Effects: []relic.SetEffect{
+			{
+				MinCount:     2,
+				Stats:        info.PropMap{prop.WindDamagePercent: 0.1},
+				CreateEffect: nil,
+			},
+			{
+				MinCount: 4,
+				Stats:    nil,
+				CreateEffect: func(engine engine.Engine, owner key.TargetID) {
+					engine.AddModifier(owner, info.Modifier{
+						Name:   eagle,
+						Source: owner,
+					})
+				},
+			},
+		},
+	})
+	modifier.Register(eagle, modifier.Config{
+		Listeners: modifier.Listeners{
+			OnAfterAction: onAfterUltimate,
+		},
+	})
+}
+
+func onAfterUltimate(mod *modifier.Instance, e event.ActionEnd) {
+	if e.AttackType == model.AttackType_ULT {
+		mod.Engine().ModifyGaugeNormalized(info.ModifyAttribute{
+			Key:    eagle,
+			Target: mod.Owner(),
+			Source: mod.Owner(),
+			Amount: -0.25,
+		})
+	}
+}

internal/relic/cavern/firesmith/firesmith.go

@@ -0,0 +1,76 @@
+package firesmith
+
+import (
+	"github.com/simimpact/srsim/pkg/engine"
+	"github.com/simimpact/srsim/pkg/engine/equip/relic"
+	"github.com/simimpact/srsim/pkg/engine/event"
+	"github.com/simimpact/srsim/pkg/engine/info"
+	"github.com/simimpact/srsim/pkg/engine/modifier"
+	"github.com/simimpact/srsim/pkg/engine/prop"
+	"github.com/simimpact/srsim/pkg/key"
+	"github.com/simimpact/srsim/pkg/model"
+)
+
+const (
+	check = "firesmith-of-lava-forging"
+	buff  = "firesmith-of-lava-forging-buff"
+)
+
+// 2pc: Increases Fire DMG by 10%.
+// 4pc: Increases the wearer's Skill DMG by 12%.
+//      After unleashing Ultimate, increases the wearer's Fire DMG by 12% for the next attack.
+
+func init() {
+	relic.Register(key.FiresmithOfLavaForging, relic.Config{
+		Effects: []relic.SetEffect{
+			{
+				MinCount:     2,
+				Stats:        info.PropMap{prop.FireDamagePercent: 0.1},
+				CreateEffect: nil,
+			},
+			{
+				MinCount: 4,
+				Stats:    nil,
+				CreateEffect: func(engine engine.Engine, owner key.TargetID) {
+					engine.AddModifier(owner, info.Modifier{
+						Name:   check,
+						Source: owner,
+					})
+				},
+			},
+		},
+	})
+	modifier.Register(check, modifier.Config{
+		Listeners: modifier.Listeners{
+			OnBeforeHitAll: onBeforeHitAll,
+			OnAfterAction:  onAfterUltimate,
+		},
+	})
+	modifier.Register(buff, modifier.Config{
+		StatusType: model.StatusType_STATUS_BUFF,
+		CanDispel:  true,
+		Listeners: modifier.Listeners{
+			OnAfterAttack: removeBuff,
+		},
+	})
+}
+
+func onBeforeHitAll(mod *modifier.Instance, e event.HitStart) {
+	if e.Hit.AttackType == model.AttackType_SKILL {
+		e.Hit.Attacker.AddProperty(check, prop.AllDamagePercent, 0.12)
+	}
+}
+
+func onAfterUltimate(mod *modifier.Instance, e event.ActionEnd) {
+	if e.AttackType == model.AttackType_ULT {
+		mod.Engine().AddModifier(mod.Owner(), info.Modifier{
+			Name:   buff,
+			Source: mod.Owner(),
+			Stats:  info.PropMap{prop.FireDamagePercent: 0.12},
+		})
+	}
+}
+
+func removeBuff(mod *modifier.Instance, e event.AttackEnd) {
+	mod.RemoveSelf()
+}

internal/relic/cavern/guard/guard.go

@@ -0,0 +1,67 @@
+package guard
+
+import (
+	"github.com/simimpact/srsim/pkg/engine"
+	"github.com/simimpact/srsim/pkg/engine/equip/relic"
+	"github.com/simimpact/srsim/pkg/engine/info"
+	"github.com/simimpact/srsim/pkg/engine/modifier"
+	"github.com/simimpact/srsim/pkg/engine/prop"
+	"github.com/simimpact/srsim/pkg/key"
+	"github.com/simimpact/srsim/pkg/model"
+)
+
+const (
+	guard  = "guard-of-wuthering-snow"
+	heal   = "guard-of-wuthering-snow-heal"
+	energy = "guard-of-wuthering-snow-energy"
+)
+
+// 2pc: Reduces DMG taken by 8%.
+// 4pc: At the beginning of the turn, if the wearer's HP is equal to or less than 50%,
+//      restores HP equal to 8% of their Max HP and regenerates 5 Energy.
+
+func init() {
+	relic.Register(key.GuardOfWutheringSnow, relic.Config{
+		Effects: []relic.SetEffect{
+			{
+				MinCount:     2,
+				Stats:        info.PropMap{prop.AllDamageReduce: 0.08},
+				CreateEffect: nil,
+			},
+			{
+				MinCount: 4,
+				Stats:    nil,
+				CreateEffect: func(engine engine.Engine, owner key.TargetID) {
+					engine.AddModifier(owner, info.Modifier{
+						Name:   guard,
+						Source: owner,
+					})
+				},
+			},
+		},
+	})
+	modifier.Register(guard, modifier.Config{
+		Listeners: modifier.Listeners{
+			OnPhase1: onPhase1,
+		},
+	})
+}
+
+func onPhase1(mod *modifier.Instance) {
+	// If above 50% HP, bypass
+	if mod.Engine().HPRatio(mod.Owner()) > 0.5 {
+		return
+	}
+	mod.Engine().Heal(info.Heal{
+		Key:      heal,
+		Targets:  []key.TargetID{mod.Owner()},
+		Source:   mod.Owner(),
+		BaseHeal: info.HealMap{model.HealFormula_BY_TARGET_MAX_HP: 0.08},
+	})
+	mod.Engine().ModifyEnergy(info.ModifyAttribute{
+		Key:    energy,
+		Target: mod.Owner(),
+		Source: mod.Owner(),
+		Amount: 5.0,
+	})
+}