Neuvillette Implementation

internal/characters/neuvillette/asc.go

@@ -0,0 +1,88 @@
+package neuvillette
+
+import (
+	"github.com/genshinsim/gcsim/pkg/core/attributes"
+	"github.com/genshinsim/gcsim/pkg/core/event"
+	"github.com/genshinsim/gcsim/pkg/core/player/character"
+	"github.com/genshinsim/gcsim/pkg/gadget"
+	"github.com/genshinsim/gcsim/pkg/modifier"
+)
+
+type NeuvA1Keys struct {
+	Evt event.Event
+	Key string
+}
+
+var a1Multipliers = [4]float64{1, 1.1, 1.25, 1.6}
+
+func (c *char) a1() {
+	a1 := []NeuvA1Keys{
+		{event.OnBloom, "neuvillette-a1-bloom"},
+		{event.OnCrystallizeHydro, "neuvillette-a1-crystallize-hydro"},
+		{event.OnElectroCharged, "neuvillette-a1-electro-charged"},
+		{event.OnFrozen, "neuvillette-a1-frozen"},
+		{event.OnSwirlHydro, "neuvillette-a1-swirl-hydro"},
+		{event.OnVaporize, "neuvillette-a1-vaporize"},
+	}
+
+	c.a1Statuses = append(c.a1Statuses,
+		a1...,
+	)
+
+	for _, val := range a1 {
+		// need to make a copy of key for the status key
+		key := val.Key
+		c.Core.Events.Subscribe(val.Evt, func(args ...interface{}) bool {
+			if _, ok := args[0].(*gadget.Gadget); ok {
+				return false
+			}
+			c.AddStatus(key, 30*60, true)
+			return false
+		}, key)
+	}
+}
+
+func (c *char) countA1() int {
+	if c.Base.Ascension < 1 {
+		return 0
+	}
+	a1TriggeredReactionsCount := 0
+	for _, val := range c.a1Statuses {
+		if c.StatusIsActive(val.Key) {
+			a1TriggeredReactionsCount += 1
+		}
+		if a1TriggeredReactionsCount == 3 {
+			break
+		}
+	}
+	return a1TriggeredReactionsCount
+}
+
+func (c *char) a4() {
+	c.AddStatMod(character.StatMod{
+		Base:         modifier.NewBase("neuvillette-a4", -1),
+		AffectedStat: attributes.HydroP,
+		Extra:        true,
+		Amount: func() ([]float64, bool) {
+			return c.a4Buff, true
+		},
+	})
+
+	c.a4Tick()
+}
+
+func (c *char) a4Tick() {
+	hpRatio := c.CurrentHPRatio()
+	hydroDmgBuff := (hpRatio - 0.3) * 0.6
+
+	if hydroDmgBuff < 0 {
+		hydroDmgBuff = 0
+	} else if hydroDmgBuff > 0.3 {
+		hydroDmgBuff = 0.3
+	}
+
+	c.a4Buff[attributes.HydroP] = hydroDmgBuff
+
+	// Tick every 2s
+	c.QueueCharTask(c.a4Tick, 120)
+}

internal/characters/neuvillette/attack.go

@@ -0,0 +1,73 @@
+package neuvillette
+
+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"
+)
+
+const normalHitNum = 3
+
+var (
+	attackFrames   [][]int
+	attackHitmarks = []int{19, 16, 32}
+	attackHitboxes = []float64{1.0, 1.0, 1.5}
+)
+
+func init() {
+	attackFrames = make([][]int, normalHitNum)
+
+	attackFrames[0] = frames.InitNormalCancelSlice(attackHitmarks[0], 36)
+	attackFrames[0][action.ActionAttack] = 29
+	attackFrames[0][action.ActionCharge] = 20
+
+	attackFrames[1] = frames.InitNormalCancelSlice(attackHitmarks[1], 33)
+	attackFrames[1][action.ActionAttack] = 31
+	attackFrames[1][action.ActionCharge] = 22
+
+	attackFrames[2] = frames.InitNormalCancelSlice(attackHitmarks[2], 62)
+	attackFrames[2][action.ActionWalk] = 61
+	attackFrames[2][action.ActionCharge] = 51
+}
+
+func (c *char) Attack(p map[string]int) (action.Info, error) {
+	if c.chargeEarlyCancelled {
+		return action.Info{}, fmt.Errorf("%v: Cannot early cancel Charged Attack: Equitable Judgement with Normal Attack", c.CharWrapper.Base.Key)
+	}
+
+	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.Hydro,
+		Durability: 25,
+		Mult:       attack[c.NormalCounter][c.TalentLvlAttack()],
+	}
+
+	c.Core.QueueAttack(
+		ai,
+		combat.NewCircleHitOnTarget(
+			c.Core.Combat.PrimaryTarget(),
+			nil,
+			attackHitboxes[c.NormalCounter],
+		),
+		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:   attackFrames[c.NormalCounter][action.ActionSwap],
+		State:           action.NormalAttackState,
+	}, nil
+}

internal/characters/neuvillette/burst.go

@@ -0,0 +1,145 @@
+package neuvillette
+
+import (
+	"fmt"
+
+	"github.com/genshinsim/gcsim/internal/common"
+	"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"
+	"github.com/genshinsim/gcsim/pkg/core/glog"
+)
+
+var burstFrames []int
+var burstHitmarks = [3]int{95, 95 + 40, 95 + 40 + 19}
+
+var dropletPosOffsets = [][][]float64{{{0, 7}, {-1, 7.5}, {0.8, 6.5}}, {{-3.5, 7.5}, {-2.5, 6}}, {{3.3, 6}}}
+var dropletRandomRanges = [][]float64{{0.5, 2}, {0.5, 1.2}, {0.5, 1.2}}
+
+var defaultBurstAtkPosOffsets = [][]float64{{-3, 7.5}, {4, 6}}
+var burstTickTargetXOffsets = []float64{1.5, -1.5}
+
+func init() {
+	burstFrames = frames.InitAbilSlice(135)
+	burstFrames[action.ActionCharge] = 133
+	burstFrames[action.ActionSkill] = 127
+	burstFrames[action.ActionDash] = 127
+	burstFrames[action.ActionJump] = 128
+	burstFrames[action.ActionWalk] = 134
+	burstFrames[action.ActionSwap] = 120
+}
+
+func (c *char) Burst(p map[string]int) (action.Info, error) {
+	c.chargeEarlyCancelled = false
+	player := c.Core.Combat.Player()
+
+	aiInitialHit := combat.AttackInfo{
+		ActorIndex: c.Index,
+		Abil:       "O Tides, I Have Returned: Skill DMG",
+		AttackTag:  attacks.AttackTagElementalBurst,
+		ICDTag:     attacks.ICDTagElementalBurst,
+		ICDGroup:   attacks.ICDGroupDefault,
+		StrikeType: attacks.StrikeTypeDefault,
+		Element:    attributes.Hydro,
+		Durability: 25,
+		FlatDmg:    burst[c.TalentLvlBurst()] * c.MaxHP(),
+	}
+	aiWaterfall := combat.AttackInfo{
+		ActorIndex: c.Index,
+		Abil:       "O Tides, I Have Returned: Waterfall DMG",
+		AttackTag:  attacks.AttackTagElementalBurst,
+		ICDTag:     attacks.ICDTagElementalBurst,
+		ICDGroup:   attacks.ICDGroupDefault,
+		StrikeType: attacks.StrikeTypeDefault,
+		Element:    attributes.Hydro,
+		Durability: 25,
+		FlatDmg:    burstWaterfall[c.TalentLvlBurst()] * c.MaxHP(),
+	}
+	for i := 0; i < 3; i++ {
+		ix := i // avoid closure issue
+
+		dropletCount := 3 - ix
+		ai := aiInitialHit
+		if ix > 0 {
+			ai = aiWaterfall
+		}
+
+		c.QueueCharTask(func() {
+			// spawn droplets for current tick using random point from player pos with offset
+			for j := 0; j < dropletCount; j++ {
+				common.NewSourcewaterDroplet(
+					c.Core,
+					geometry.CalcRandomPointFromCenter(
+						geometry.CalcOffsetPoint(
+							player.Pos(),
+							geometry.Point{X: dropletPosOffsets[ix][j][0], Y: dropletPosOffsets[ix][j][1]},
+							player.Direction(),
+						),
+						dropletRandomRanges[ix][0],
+						dropletRandomRanges[ix][1],
+						c.Core.Rand,
+					),
+					combat.GadgetTypSourcewaterDropletNeuv,
+				)
+			}
+			c.Core.Combat.Log.NewEvent(fmt.Sprint("Burst: Spawned ", dropletCount, " droplets"), glog.LogCharacterEvent, c.Index)
+
+			// determine attack pattern
+			// initial tick
+			ap := combat.NewCircleHitOnTarget(player, geometry.Point{Y: 1}, 8)
+			// 2nd and 3rd tick
+			if ix > 0 {
+				// determine attack pattern pos
+				// default assumption: no target in range -> ticks should spawn at specific offset from player
+				apPos := geometry.CalcOffsetPoint(
+					player.Pos(),
+					geometry.Point{
+						X: defaultBurstAtkPosOffsets[ix-1][0],
+						Y: defaultBurstAtkPosOffsets[ix-1][1],
+					},
+					player.Direction(),
+				)
+
+				// check if target is within range
+				target := c.Core.Combat.PrimaryTarget()
+				if target.IsWithinArea(combat.NewCircleHitOnTarget(player, nil, 10)) {
+					// target in range -> adjust pos
+					// pos is a point in random range from target pos + offset
+					// TODO: offset is not accurate because currently target is always looking in default direction
+					apPos = geometry.CalcRandomPointFromCenter(
+						geometry.CalcOffsetPoint(
+							target.Pos(),
+							geometry.Point{X: burstTickTargetXOffsets[ix-1]},
+							target.Direction(),
+						),
+						0,
+						1.5,
+						c.Core.Rand,
+					)
+				}
+				// create attack pattern for tick after determining pos
+				ap = combat.NewCircleHitOnTarget(apPos, nil, 5)
+			}
+
+			c.Core.QueueAttack(
+				ai,
+				ap,
+				0,
+				0,
+			)
+		}, burstHitmarks[ix])
+	}
+
+	c.SetCD(action.ActionBurst, 18*60)
+	c.ConsumeEnergy(4)
+
+	return action.Info{
+		Frames:          frames.NewAbilFunc(burstFrames),
+		AnimationLength: burstFrames[action.InvalidAction],
+		CanQueueAfter:   burstFrames[action.ActionSwap], // earliest cancel
+		State:           action.BurstState,
+	}, nil
+}