add varesa

internal/characters/varesa/asc.go

@@ -0,0 +1,60 @@
+package varesa
+
+import (
+	"github.com/genshinsim/gcsim/pkg/core/attributes"
+	"github.com/genshinsim/gcsim/pkg/core/combat"
+	"github.com/genshinsim/gcsim/pkg/core/event"
+	"github.com/genshinsim/gcsim/pkg/core/player/character"
+	"github.com/genshinsim/gcsim/pkg/core/stacks"
+	"github.com/genshinsim/gcsim/pkg/modifier"
+)
+
+const a1Status = "rainbow-crash"
+
+func (c *char) a1() {
+	if c.Base.Ascension < 1 {
+		return
+	}
+	c.AddStatus(a1Status, 5*60, true)
+}
+
+func (c *char) a1PlungeBuff() float64 {
+	if c.Base.Ascension < 1 {
+		return 0.0
+	}
+	if !c.StatusIsActive(a1Status) {
+		return 0.0
+	}
+	if c.Base.Cons >= 1 || c.nightsoulState.HasBlessing() {
+		return 1.8
+	}
+	return 0.5
+}
+
+func (c *char) a1Cancel(_ combat.AttackCB) {
+	if c.Base.Ascension < 1 {
+		return
+	}
+	c.DeleteAttackMod(a1Status)
+}
+
+func (c *char) a4() {
+	if c.Base.Ascension < 4 {
+		return
+	}
+
+	m := make([]float64, attributes.EndStatType)
+	c.AddStatMod(character.StatMod{
+		Base: modifier.NewBase("varesa-a4", -1),
+		Amount: func() ([]float64, bool) {
+			m[attributes.ATKP] = 0.35 * float64(c.a4Stacks.Count())
+			return m, true
+		},
+	})
+
+	c.a4Stacks = stacks.NewMultipleRefreshNoRemove(2, c.QueueCharTask, &c.Core.F)
+	c.Core.Events.Subscribe(event.OnNightsoulBurst, func(args ...interface{}) bool {
+		c.a4Stacks.Add(12 * 60)
+		return false
+	}, "varesa-a4")
+}

internal/characters/varesa/attack.go

@@ -0,0 +1,142 @@
+package varesa
+
+import (
+	"fmt"
+
+	"github.com/genshinsim/gcsim/internal/frames"
+	"github.com/genshinsim/gcsim/pkg/core/action"
+	"github.com/genshinsim/gcsim/pkg/core/attacks"
+	"github.com/genshinsim/gcsim/pkg/core/attributes"
+	"github.com/genshinsim/gcsim/pkg/core/combat"
+	"github.com/genshinsim/gcsim/pkg/core/geometry"
+)
+
+// TODO: hitboxes
+var (
+	attackFrames          [][]int
+	attackHitmarks        = []int{28, 7, 33}
+	attackHitlagHaltFrame = []float64{0, 0, 0.03}
+	attackHitlagFactor    = []float64{0, 0, 0.01}
+	attackHitboxes        = [][]float64{{2, 3}, {2, 3}, {2.2}}
+	attackOffsets         = []float64{-0.2, -0.2, 1.1}
+
+	fieryAttackFrames   [][]int
+	fieryAttackHitmarks = []int{18, 29, 37}
+	fieryAttackHitboxes = [][]float64{{2, 3}, {2, 3}, {2.5, 3}}
+)
+
+const normalHitNum = 3
+
+func init() {
+	attackFrames = make([][]int, normalHitNum)
+
+	attackFrames[0] = frames.InitNormalCancelSlice(attackHitmarks[0], 49) // N1 -> Walk
+	attackFrames[0][action.ActionAttack] = 33
+	attackFrames[0][action.ActionCharge] = 23
+
+	attackFrames[1] = frames.InitNormalCancelSlice(attackHitmarks[1], 30) // N2 -> N3
+	attackFrames[1][action.ActionCharge] = 17
+	attackFrames[1][action.ActionWalk] = 28
+
+	attackFrames[2] = frames.InitNormalCancelSlice(attackHitmarks[2], 59) // N3 -> Walk
+	attackFrames[2][action.ActionAttack] = 45
+	attackFrames[2][action.ActionCharge] = 32
+
+	fieryAttackFrames = make([][]int, normalHitNum)
+
+	fieryAttackFrames[0] = frames.InitNormalCancelSlice(fieryAttackHitmarks[0], 39) // N1 -> Walk
+	fieryAttackFrames[0][action.ActionAttack] = 29
+	fieryAttackFrames[0][action.ActionCharge] = 31
+
+	fieryAttackFrames[1] = frames.InitNormalCancelSlice(fieryAttackHitmarks[1], 47) // N2 -> Walk
+	fieryAttackFrames[1][action.ActionAttack] = 39
+	fieryAttackFrames[1][action.ActionCharge] = 25
+
+	fieryAttackFrames[2] = frames.InitNormalCancelSlice(fieryAttackHitmarks[2], 63) // N3 -> N4/Walk
+	fieryAttackFrames[2][action.ActionCharge] = 37
+}
+
+func (c *char) Attack(p map[string]int) (action.Info, error) {
+	// OnRemoved is sometimes called after the next action is executed. so we need to exit nightsoul here too
+	c.clearNightsoulCB(action.NormalAttackState)
+
+	if c.StatusIsActive(skillStatus) {
+		// TODO: or c.Core.Player.Exec(action.ActionCharge, c.Base.Key, nil)
+		return c.ChargeAttack(p)
+	}
+	if c.nightsoulState.HasBlessing() {
+		return c.fieryAttack(), nil
+	}
+
+	ai := combat.AttackInfo{
+		ActorIndex:         c.Index,
+		Abil:               fmt.Sprintf("Normal %v", c.NormalCounter),
+		AttackTag:          attacks.AttackTagNormal,
+		ICDTag:             attacks.ICDTagNormalAttack,
+		ICDGroup:           attacks.ICDGroupDefault,
+		StrikeType:         attacks.StrikeTypeDefault,
+		Element:            attributes.Electro,
+		Durability:         25,
+		Mult:               attack[c.NormalCounter][c.TalentLvlAttack()],
+		HitlagFactor:       0.01,
+		HitlagHaltFrames:   attackHitlagHaltFrame[c.NormalCounter] * 60,
+		CanBeDefenseHalted: true,
+	}
+	ap := combat.NewCircleHitOnTarget(
+		c.Core.Combat.Player(),
+		geometry.Point{Y: attackOffsets[c.NormalCounter]},
+		attackHitboxes[c.NormalCounter][0],
+	)
+	if c.NormalCounter == 0 || c.NormalCounter == 1 {
+		ap = combat.NewBoxHitOnTarget(
+			c.Core.Combat.Player(),
+			geometry.Point{Y: attackOffsets[c.NormalCounter]},
+			attackHitboxes[c.NormalCounter][0],
+			attackHitboxes[c.NormalCounter][1],
+		)
+	}
+	c.Core.QueueAttack(ai, ap, attackHitmarks[c.NormalCounter], attackHitmarks[c.NormalCounter])
+
+	defer c.AdvanceNormalIndex()
+
+	return action.Info{
+		Frames:          frames.NewAttackFunc(c.Character, attackFrames),
+		AnimationLength: attackFrames[c.NormalCounter][action.InvalidAction],
+		CanQueueAfter:   attackHitmarks[c.NormalCounter],
+		State:           action.NormalAttackState,
+	}, nil
+}
+
+func (c *char) fieryAttack() action.Info {
+	ai := combat.AttackInfo{
+		ActorIndex:         c.Index,
+		Abil:               fmt.Sprintf("Fiery Passion %v", c.NormalCounter),
+		AttackTag:          attacks.AttackTagNormal,
+		ICDTag:             attacks.ICDTagNormalAttack,
+		ICDGroup:           attacks.ICDGroupDefault,
+		StrikeType:         attacks.StrikeTypeDefault,
+		Element:            attributes.Electro,
+		Durability:         25,
+		Mult:               fieryAttack[c.NormalCounter][c.TalentLvlAttack()],
+		HitlagFactor:       0.01,
+		HitlagHaltFrames:   0.03 * 60,
+		CanBeDefenseHalted: true,
+	}
+
+	ap := combat.NewBoxHitOnTarget(
+		c.Core.Combat.Player(),
+		nil,
+		fieryAttackHitboxes[c.NormalCounter][0],
+		fieryAttackHitboxes[c.NormalCounter][1],
+	)
+	c.Core.QueueAttack(ai, ap, fieryAttackHitmarks[c.NormalCounter], fieryAttackHitmarks[c.NormalCounter])
+
+	defer c.AdvanceNormalIndex()
+
+	return action.Info{
+		Frames:          frames.NewAttackFunc(c.Character, fieryAttackFrames),
+		AnimationLength: fieryAttackFrames[c.NormalCounter][action.InvalidAction],
+		CanQueueAfter:   fieryAttackHitmarks[c.NormalCounter],
+		State:           action.NormalAttackState,
+	}
+}

internal/characters/varesa/burst.go

@@ -0,0 +1,129 @@
+package varesa
+
+import (
+	"github.com/genshinsim/gcsim/internal/frames"
+	"github.com/genshinsim/gcsim/pkg/core/action"
+	"github.com/genshinsim/gcsim/pkg/core/attacks"
+	"github.com/genshinsim/gcsim/pkg/core/attributes"
+	"github.com/genshinsim/gcsim/pkg/core/combat"
+)
+
+// TODO: update hitlags/hitboxes
+var (
+	burstFrames    []int
+	volcanicFrames []int
+)
+
+const (
+	burstHitmark     = 88
+	burstEnergyFrame = 9
+
+	kablamHitmark = 42
+	kablamCost    = 30
+	kablamAbil    = "Volcano Kablam"
+)
+
+func init() {
+	burstFrames = frames.InitAbilSlice(122) // Q -> Jump
+	burstFrames[action.ActionAttack] = 93
+	burstFrames[action.ActionSkill] = 90
+	burstFrames[action.ActionDash] = 93
+	burstFrames[action.ActionWalk] = 101
+	burstFrames[action.ActionSwap] = 90
+
+	volcanicFrames = frames.InitAbilSlice(47) // Q -> Walk
+	volcanicFrames[action.ActionAttack] = 46
+	volcanicFrames[action.ActionSkill] = 45
+	volcanicFrames[action.ActionDash] = 43
+	volcanicFrames[action.ActionSwap] = 42
+}
+
+func (c *char) Burst(p map[string]int) (action.Info, error) {
+	c.c4Burst()
+
+	if c.StatusIsActive(apexState) {
+		return c.volcanicKablam(), nil
+	}
+
+	ai := combat.AttackInfo{
+		ActorIndex:     c.Index,
+		Abil:           "Flying Kick",
+		AttackTag:      attacks.AttackTagElementalBurst,
+		AdditionalTags: []attacks.AdditionalTag{attacks.AdditionalTagNightsoul},
+		ICDTag:         attacks.ICDTagNone,
+		ICDGroup:       attacks.ICDGroupDefault,
+		StrikeType:     attacks.StrikeTypeDefault,
+		Element:        attributes.Electro,
+		Durability:     25,
+		Mult:           kick[c.TalentLvlBurst()],
+		HitlagFactor:   0.1,
+	}
+
+	c.QueueCharTask(func() {
+		c.nightsoulState.GeneratePoints(c.nightsoulState.MaxPoints)
+		c.generatePlungeNightsoul()
+	}, 3)
+
+	if c.nightsoulState.HasBlessing() {
+		ai.Abil = "Fiery Passion Flying Kick"
+		ai.Mult = fieryKick[c.TalentLvlBurst()]
+	}
+
+	c.Core.QueueAttack(
+		ai,
+		combat.NewCircleHit(c.Core.Combat.Player(), c.Core.Combat.PrimaryTarget(), nil, 6),
+		burstHitmark,
+		burstHitmark,
+	)
+
+	c.ConsumeEnergy(burstEnergyFrame)
+	c.SetCD(action.ActionBurst, 18*60)
+
+	return action.Info{
+		Frames:          frames.NewAbilFunc(burstFrames),
+		AnimationLength: burstFrames[action.InvalidAction],
+		CanQueueAfter:   burstFrames[action.ActionSwap],
+		State:           action.BurstState,
+	}, nil
+}
+
+func (c *char) volcanicKablam() action.Info {
+	ai := combat.AttackInfo{
+		ActorIndex:     c.Index,
+		Abil:           kablamAbil,
+		AdditionalTags: []attacks.AdditionalTag{attacks.AdditionalTagNightsoul},
+		AttackTag:      attacks.AttackTagPlunge,
+		ICDTag:         attacks.ICDTagVaresaCombatCycle,
+		ICDGroup:       attacks.ICDGroupDefault,
+		StrikeType:     attacks.StrikeTypeDefault,
+		Element:        attributes.Electro,
+		Durability:     25,
+		Mult:           kablam[c.TalentLvlBurst()],
+		HitlagFactor:   0.1,
+	}
+
+	if c.Base.Cons >= 1 {
+		c.a1()
+	}
+
+	c.Core.Tasks.Add(func() {
+		c.Core.QueueAttack(
+			ai,
+			combat.NewCircleHit(c.Core.Combat.Player(), c.Core.Combat.PrimaryTarget(), nil, 6),
+			0,
+			0,
+		)
+		c.DeleteStatus(apexState)
+	}, kablamHitmark)
+
+	c.AddEnergy("varesa-kablam", -kablamCost)
+	c.SetCD(action.ActionBurst, 1*60)
+
+	return action.Info{
+		Frames:          frames.NewAbilFunc(volcanicFrames),
+		AnimationLength: volcanicFrames[action.InvalidAction],
+		CanQueueAfter:   volcanicFrames[action.ActionSwap],
+		State:           action.BurstState, // TODO: or plunge state?
+		OnRemoved:       c.clearNightsoulCB,
+	}
+}