Mistweaver implementation

sim/core/apl.go

@@ -2,6 +2,7 @@ package core
 
 import (
 	"fmt"
+	"slices"
 	"time"
 
 	"github.com/wowsims/mop/sim/core/proto"
@@ -23,6 +24,8 @@ type APLRotation struct {
 	// If true, can recast channel when interrupted.
 	allowChannelRecastOnInterrupt bool
 
+	//Checking for cast-while-channeling spells to allow the APL to not evaluate during channels unless absolutely necessary
+	allowCastWhileChanneling bool
 	// Used inside of actions/value to determine whether they will occur during the prepull or regular rotation.
 	parsingPrepull bool
 
@@ -265,6 +268,11 @@ func (rot *APLRotation) reset(sim *Simulation) {
 	rot.inLoop = false
 	rot.interruptChannelIf = nil
 	rot.allowChannelRecastOnInterrupt = false
+
+	//rot.allowCastWhileChanneling = slices.ContainsFunc(rot.unit.Spellbook, func(spell *Spell) bool {
+	//	return spell.Flags.Matches(SpellFlagCastWhileChanneling)
+	//})
+
 	for _, action := range rot.allAPLActions() {
 		action.impl.Reset(sim)
 	}
@@ -282,7 +290,12 @@ func (apl *APLRotation) DoNextAction(sim *Simulation) {
 		return
 	}
 
-	if apl.unit.ChanneledDot != nil {
+	//Probably not the best solution, added so apl evaluates if a spell can be cast while channeling during runtime rather than on reset
+	apl.allowCastWhileChanneling = slices.ContainsFunc(apl.unit.Spellbook, func(spell *Spell) bool {
+		return spell.Flags.Matches(SpellFlagCastWhileChanneling)
+	})
+
+	if apl.unit.ChanneledDot != nil && !apl.allowCastWhileChanneling {
 		return
 	}
 

sim/core/cast.go

@@ -146,6 +146,10 @@ func (spell *Spell) makeCastFunc(config CastConfig) CastSuccessFunc {
 			return spell.castFailureHelper(sim, "casting/channeling %v for %s, curTime = %s", hc.ActionID, hc.Expires-sim.CurrentTime, sim.CurrentTime)
 		}
 
+		if dot := spell.Unit.ChanneledDot; spell.Unit.IsChanneling(sim) && !spell.Flags.Matches(SpellFlagCastWhileChanneling) && (spell.Unit.Rotation.interruptChannelIf == nil || !spell.Unit.Rotation.interruptChannelIf.GetBool(sim)) {
+			return spell.castFailureHelper(sim, "channeling %v for %s, curTime = %s", dot.ActionID, dot.expires-sim.CurrentTime, sim.CurrentTime)
+		}
+
 		if effectiveTime := spell.CurCast.EffectiveTime(); effectiveTime != 0 {
 
 			// do not add channeled time here as they have variable cast length

sim/core/flags.go

@@ -165,6 +165,7 @@ const (
 	SpellFlagCannotBeDodged                                // Ignores dodge in physical hit rolls
 	SpellFlagBinary                                        // Does not do partial resists and could need a different hit roll.
 	SpellFlagChanneled                                     // Spell is channeled
+	SpellFlagCastWhileChanneling                           // Spell can be cast while channeling
 	SpellFlagDisease                                       // Spell is categorized as disease
 	SpellFlagHelpful                                       // For healing spells / buffs.
 	SpellFlagMeleeMetrics                                  // Marks a spell as a melee ability for metrics.

sim/core/spell.go

@@ -571,10 +571,11 @@ func (spell *Spell) CanCast(sim *Simulation, target *Unit) bool {
 	}
 
 	// While casting or channeling, no other action is possible
-	if spell.Unit.Hardcast.Expires > sim.CurrentTime {
+	if (spell.Unit.Hardcast.Expires > sim.CurrentTime || spell.Unit.IsChanneling(sim)) && !spell.Flags.Matches(SpellFlagCastWhileChanneling) {
 		//if sim.Log != nil {
 		//	sim.Log("Cant cast because already casting/channeling")
 		//}
+
 		return false
 	}
 

sim/core/spell_mod.go

@@ -329,6 +329,9 @@ const (
 	// Enables casting while moving
 	SpellMod_AllowCastWhileMoving
 
+	// Enables casting while channeling
+	SpellMod_AllowCastWhileChanneling
+
 	// Add/subtract bonus spell power
 	// Uses: FloatValue
 	SpellMod_BonusSpellPower_Flat
@@ -448,6 +451,11 @@ var spellModMap = map[SpellModType]*SpellModFunctions{
 		Remove: removeAllowCastWhileMoving,
 	},
 
+	SpellMod_AllowCastWhileChanneling: {
+		Apply:  applyAllowCastWhileChanneling,
+		Remove: removeAllowCastWhileChanneling,
+	},
+
 	SpellMod_BonusSpellPower_Flat: {
 		Apply:  applyBonusSpellPowerFlat,
 		Remove: removeBonusSpellPowerFlat,
@@ -680,6 +688,14 @@ func removeAllowCastWhileMoving(mod *SpellMod, spell *Spell) {
 	spell.Flags ^= SpellFlagCanCastWhileMoving
 }
 
+func applyAllowCastWhileChanneling(mod *SpellMod, spell *Spell) {
+	spell.Flags |= SpellFlagCastWhileChanneling
+}
+
+func removeAllowCastWhileChanneling(mod *SpellMod, spell *Spell) {
+	spell.Flags ^= SpellFlagCastWhileChanneling
+}
+
 func applyBonusSpellPowerFlat(mod *SpellMod, spell *Spell) {
 	spell.BonusSpellPower += mod.floatValue
 }

sim/core/unit.go

@@ -471,6 +471,10 @@ func (unit *Unit) InitialCastSpeed() float64 {
 	return unit.initialCastSpeed
 }
 
+func (unit *Unit) IsChanneling(sim *Simulation) bool {
+	return unit.ChanneledDot != nil
+}
+
 func (unit *Unit) SpellGCD() time.Duration {
 	return max(GCDMin, unit.ApplyCastSpeed(GCDDefault))
 }

sim/monk/blackout_kick.go

@@ -68,6 +68,7 @@ func blackoutKickSpellConfig(monk *Monk, isSEFClone bool, overrides core.SpellCo
 func (monk *Monk) registerBlackoutKick() {
 	chiMetrics := monk.NewChiMetrics(blackoutKickActionID)
 	chiCost := int32(2)
+	manaMetrics := monk.NewManaMetrics(blackoutKickActionID)
 
 	monk.RegisterSpell(blackoutKickSpellConfig(monk, false, core.SpellConfig{
 		Cast: core.CastConfig{
@@ -92,6 +93,11 @@ func (monk *Monk) registerBlackoutKick() {
 				} else {
 					monk.SpendChi(sim, chiCost, chiMetrics)
 				}
+
+				if monk.MuscleMemoryAura.IsActive() {
+					result.Damage += result.Damage * 1.5
+					monk.AddMana(sim, monk.MaxMana()*0.04, manaMetrics)
+				}
 			}
 
 			spell.DealOutcome(sim, result)

sim/monk/jab.go

@@ -73,7 +73,8 @@ func (monk *Monk) registerJab() {
 			Refund: 0.8,
 		},
 		ManaCost: core.ManaCostOptions{
-			BaseCostPercent: core.TernaryFloat64(monk.StanceMatches(WiseSerpent), 8, 0),
+			//This is wrong? But works?
+			BaseCostPercent: core.TernaryFloat64(monk.StanceMatches(WiseSerpent), 0, 8),
 		},
 
 		Cast: core.CastConfig{
@@ -84,6 +85,7 @@ func (monk *Monk) registerJab() {
 		},
 
 		ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) {
+
 			baseDamage := monk.CalculateMonkStrikeDamage(sim, spell)
 			result := spell.CalcAndDealDamage(sim, target, baseDamage, spell.OutcomeMeleeSpecialHitAndCrit)
 

sim/monk/mistweaver/enveloping_mist.go

@@ -0,0 +1,82 @@
+package mistweaver
+
+import (
+	"time"
+
+	"github.com/wowsims/mop/sim/core"
+	"github.com/wowsims/mop/sim/monk"
+)
+
+func (mw *MistweaverMonk) registerEnvelopingMist() {
+	actionID := core.ActionID{SpellID: 124682}
+	chiMetrics := mw.NewChiMetrics(actionID)
+	spellCoeff := 0.45
+
+	mw.enevelopingMist = mw.RegisterSpell(core.SpellConfig{
+		ActionID:       actionID,
+		SpellSchool:    core.SpellSchoolNature,
+		ProcMask:       core.ProcMaskSpellHealing,
+		Flags:          core.SpellFlagHelpful | core.SpellFlagAPL, // | core.SpellFlagCastWhileChanneling,
+		ClassSpellMask: monk.MonkSpellEnvelopingMist,
+
+		ManaCost: core.ManaCostOptions{BaseCostPercent: 0},
+		Cast: core.CastConfig{
+			DefaultCast: core.Cast{
+				GCD:      core.GCDDefault,
+				CastTime: time.Millisecond * 2000,
+			},
+		},
+		DamageMultiplier: 1,
+		ThreatMultiplier: 1,
+		CritMultiplier:   mw.DefaultCritMultiplier(),
+
+		ExtraCastCondition: func(sim *core.Simulation, target *core.Unit) bool {
+			return mw.GetChi() >= 3
+		},
+
+		ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) {
+
+			mw.SpendChi(sim, 3, chiMetrics)
+			spell.RelatedDotSpell.Cast(sim, &mw.Unit)
+
+		},
+	})
+
+	mw.enevelopingMist.RelatedDotSpell = mw.RegisterSpell(core.SpellConfig{
+		ActionID:    actionID,
+		SpellSchool: core.SpellSchoolNature,
+		ProcMask:    core.ProcMaskSpellHealing,
+		Flags:       core.SpellFlagHelpful,
+		//ClassSpellMask: monk.MonkSpellEnvelopingMist,
+
+		DamageMultiplier: 1,
+		ThreatMultiplier: 1,
+		CritMultiplier:   mw.DefaultCritMultiplier(),
+		Hot: core.DotConfig{
+			Aura: core.Aura{
+				Label: "Enveloping Mist",
+			},
+			NumberOfTicks:        6,
+			TickLength:           1 * time.Second,
+			AffectedByCastSpeed:  true,
+			HasteReducesDuration: true,
+			OnSnapshot: func(sim *core.Simulation, target *core.Unit, dot *core.Dot, _ bool) {
+				dot.SnapshotBaseDamage = 0 + mw.CalcScalingSpellDmg(spellCoeff)
+				dot.SnapshotAttackerMultiplier = dot.Spell.CasterHealingMultiplier()
+			},
+
+			OnTick: func(sim *core.Simulation, target *core.Unit, dot *core.Dot) {
+				dot.CalcAndDealPeriodicSnapshotHealing(sim, target, dot.OutcomeTick)
+
+			},
+		},
+
+		ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) {
+			//Targets only mw currently
+			hot := spell.Hot(&mw.Unit)
+
+			hot.Apply(sim)
+
+		},
+	})
+}

sim/monk/mistweaver/mana_tea.go

@@ -0,0 +1,102 @@
+package mistweaver
+
+import (
+	"math"
+	"time"
+
+	"github.com/wowsims/mop/sim/core"
+	"github.com/wowsims/mop/sim/core/stats"
+	"github.com/wowsims/mop/sim/monk"
+)
+
+func (mw *MistweaverMonk) registerManaTea() {
+
+	buffActionID := core.ActionID{SpellID: 115294}
+	stackActionID := core.ActionID{SpellID: 123766}
+	manaMetrics := mw.NewManaMetrics(buffActionID)
+	manaPerTick := 0.0
+	//numerOFTicks := 6
+
+	mw.Monk.RegisterOnChiSpent(func(sim *core.Simulation, chiSpent int32) {
+		accumulatedChi := mw.outstandingChi + chiSpent
+
+		for accumulatedChi >= 4 {
+
+			mw.AddBrewStacks(sim, 1)
+			accumulatedChi -= 4
+		}
+
+		mw.outstandingChi = accumulatedChi
+
+	})
+
+	mw.ManaTeaStackAura = mw.RegisterAura(core.Aura{
+		Label:     "Mana Tea Stacks" + mw.Label,
+		ActionID:  stackActionID,
+		Duration:  time.Hour,
+		MaxStacks: 10,
+	})
+
+	mw.Monk.RegisterOnNewBrewStacks(func(sim *core.Simulation, stacksToAdd int32) {
+		mw.ManaTeaStackAura.Activate(sim)
+
+		procChance := mw.GetStat(stats.SpellCritPercent)
+
+		if sim.Proc(math.Mod(procChance, 1), "Mana Tea") {
+			stacksToAdd += 1
+		}
+
+		mw.ManaTeaStackAura.SetStacks(sim, mw.ManaTeaStackAura.GetStacks()+stacksToAdd)
+	})
+
+	mw.RegisterSpell(core.SpellConfig{
+		ActionID:       buffActionID,
+		Flags:          core.SpellFlagAPL | core.SpellFlagNoOnCastComplete | core.SpellFlagHelpful | core.SpellFlagChanneled,
+		ClassSpellMask: monk.MonkSpellManaTea,
+
+		Cast: core.CastConfig{
+			DefaultCast: core.Cast{
+				GCD: time.Millisecond * 1000,
+			},
+		},
+
+		Hot: core.DotConfig{
+			SelfOnly: true,
+			Aura: core.Aura{
+				Label:    "Mana Tea",
+				Duration: 3 * time.Second, //Set at activation
+			},
+			NumberOfTicks:       6,
+			TickLength:          500 * time.Millisecond,
+			AffectedByCastSpeed: false, //?
+			OnSnapshot: func(sim *core.Simulation, target *core.Unit, dot *core.Dot, isRollover bool) {
+				mw.manaTeaAura = dot.Aura
+			},
+			OnTick: func(sim *core.Simulation, target *core.Unit, spell *core.Dot) {
+				mw.AddMana(sim, manaPerTick, manaMetrics)
+
+				mw.ManaTeaStackAura.SetStacks(sim, mw.ManaTeaStackAura.GetStacks()-1)
+
+			},
+		},
+
+		ExtraCastCondition: func(sim *core.Simulation, target *core.Unit) bool {
+
+			return mw.ManaTeaStackAura.GetStacks() > 0
+		},
+
+		ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) {
+			manaPerTick = mw.MaxMana() * 0.05 //Patched to restore 5% instead of original 4%
+
+			hot := spell.SelfHot()
+			stacksToUse := min(mw.ManaTeaStackAura.GetStacks(), 6.0)
+			hot.Duration = time.Duration(stacksToUse) * 500 * time.Millisecond
+			hot.BaseTickCount = stacksToUse
+			hot.Activate(sim)
+			//mw.ManaTeaStackAura.SetStacks(sim, mw.ManaTeaStackAura.GetStacks()-1)
+
+			//spell.SelfHot().Apply(sim)
+
+		},
+	})
+}

sim/monk/mistweaver/mistweaver.go

@@ -50,6 +50,17 @@ func NewMistweaverMonk(character *core.Character, options *proto.Player) *Mistwe
 
 type MistweaverMonk struct {
 	*monk.Monk
+
+	ManaTeaStackAura *core.Aura
+
+	renewingMist    *core.Spell
+	enevelopingMist *core.Spell
+
+	JadeSerpentAura *core.Aura
+	//May move this to monk as both ww and mw use this
+	outstandingChi int32
+
+	manaTeaAura *core.Aura
 }
 
 func (mw *MistweaverMonk) GetMonk() *monk.Monk {
@@ -68,11 +79,21 @@ func (mw *MistweaverMonk) ApplyTalents() {
 }
 
 func (mw *MistweaverMonk) Reset(sim *core.Simulation) {
+	mw.outstandingChi = 0
 	mw.Monk.Reset(sim)
 }
 
 func (mw *MistweaverMonk) RegisterSpecializationEffects() {
 	mw.RegisterMastery()
+	mw.registerRenewingMist()
+	mw.registerSurgingMist()
+	mw.registerSoothingMist()
+	mw.registerEnvelopingMist()
+	mw.registerUplift()
+	mw.registerRevival()
+	mw.registerSummonJadeSerpentStatue()
+	mw.registerManaTea()
+	mw.registerPassives()
 }
 
 func (mw *MistweaverMonk) RegisterMastery() {