add warrior toggles for stopattack

proto/warrior.proto

@@ -129,11 +129,7 @@ enum WarriorStance {
  WarriorStanceGladiator = 4;
 }
 
-message Warrior {
- message Rotation {
- }
-
- message Options {
+message WarriorBaseOptions {
  reserved 2;
  reserved "use_recklessness";
 
@@ -142,20 +138,27 @@ message Warrior {
 
  WarriorShout shout = 3;
  WarriorStance stance = 7;
+
+ bool IsUsingRendStopAttack = 8;
+ bool IsUsingBloodthirstStopAttack = 9;
+ bool IsUsingQuickStrikeStopAttack = 10;
+ bool IsUsingHamstringStopAttack = 11;
+ bool IsUsingWhirlwindStopAttack = 12;
+ bool IsUsingExecuteStopAttack = 13;
+ bool IsUsingOverpowerStopAttack = 14;
+ bool IsUsingHeroicStrikeStopAttack = 15;
  }
- Options options = 3;
-}
 
-message TankWarrior {
+message Warrior {
  message Rotation {
  }
 
- message Options {
- double starting_rage = 1;
- bool stance_snapshot = 6;
+ WarriorBaseOptions options = 3;
+}
 
- WarriorShout shout = 3;
-  WarriorStance stance = 7;
+message TankWarrior {
+ message Rotation {
  }
- Options options = 3;
+
+ WarriorBaseOptions options = 3;
 }

sim/warrior/dps_warrior/dps_warrior.go

@@ -25,34 +25,33 @@ func RegisterDpsWarrior() {
 
 type DpsWarrior struct {
  *warrior.Warrior
-
- Options *proto.Warrior_Options
 }
 
 func NewDpsWarrior(character *core.Character, options *proto.Player) *DpsWarrior {
- warOptions := options.GetWarrior()
+ warOptions := options.GetWarrior().Options
+
+ war := warrior.NewWarrior(character, options, warOptions, warrior.WarriorInputs{
+ StanceSnapshot: warOptions.StanceSnapshot,
+ })
 
- war := &DpsWarrior{
- Warrior: warrior.NewWarrior(character, options.TalentsString, warrior.WarriorInputs{
- StanceSnapshot: warOptions.Options.StanceSnapshot,
- }),
- Options: warOptions.Options,
+ dpsWar := &DpsWarrior{
+ Warrior: war,
  }
 
- war.EnableRageBar(core.RageBarOptions{
- StartingRage: warOptions.Options.StartingRage,
+ dpsWar.EnableRageBar(core.RageBarOptions{
+ StartingRage: warOptions.StartingRage,
  DamageDealtMultiplier: 1,
  DamageTakenMultiplier: 1,
  })
 
- war.EnableAutoAttacks(war, core.AutoAttackOptions{
- MainHand: war.WeaponFromMainHand(),
- OffHand: war.WeaponFromOffHand(),
+ dpsWar.EnableAutoAttacks(dpsWar, core.AutoAttackOptions{
+ MainHand: dpsWar.WeaponFromMainHand(),
+ OffHand: dpsWar.WeaponFromOffHand(),
  AutoSwingMelee: true,
- ReplaceMHSwing: war.TryHSOrCleave,
+ ReplaceMHSwing: dpsWar.TryHSOrCleave,
  })
 
- return war
+ return dpsWar
 }
 
 func (war *DpsWarrior) OnGCDReady(sim *core.Simulation) {

sim/warrior/dps_warrior/dps_warrior_test.go

@@ -139,7 +139,7 @@ var PlayerOptionsFury = &proto.Player_Warrior{
  },
 }
 
-var warriorOptions = &proto.Warrior_Options{
+var warriorOptions = &proto.WarriorBaseOptions{
  StartingRage: 50,
  Shout: proto.WarriorShout_WarriorShoutBattle,
 }

sim/warrior/tank_warrior/tank_warrior.go

@@ -25,34 +25,33 @@ func RegisterTankWarrior() {
 
 type TankWarrior struct {
  *warrior.Warrior
-
- Options *proto.TankWarrior_Options
 }
 
 func NewTankWarrior(character *core.Character, options *proto.Player) *TankWarrior {
- warOptions := options.GetTankWarrior()
+ warOptions := options.GetTankWarrior().Options
+
+ war := warrior.NewWarrior(character, options, warOptions, warrior.WarriorInputs{
+ StanceSnapshot: warOptions.StanceSnapshot,
+ })
 
- war := &TankWarrior{
- Warrior: warrior.NewWarrior(character, options.TalentsString, warrior.WarriorInputs{
- StanceSnapshot: warOptions.Options.StanceSnapshot,
- }),
- Options: warOptions.Options,
+ tankWar := &TankWarrior{
+ Warrior: war,
  }
 
- war.EnableRageBar(core.RageBarOptions{
- StartingRage: warOptions.Options.StartingRage,
+ tankWar.EnableRageBar(core.RageBarOptions{
+ StartingRage: warOptions.StartingRage,
  DamageDealtMultiplier: 1,
  DamageTakenMultiplier: 1,
  })
 
- war.EnableAutoAttacks(war, core.AutoAttackOptions{
- MainHand: war.WeaponFromMainHand(),
- OffHand: war.WeaponFromOffHand(),
+ tankWar.EnableAutoAttacks(tankWar, core.AutoAttackOptions{
+ MainHand: tankWar.WeaponFromMainHand(),
+ OffHand: tankWar.WeaponFromOffHand(),
  AutoSwingMelee: true,
- ReplaceMHSwing: war.TryHSOrCleave,
+ ReplaceMHSwing: tankWar.TryHSOrCleave,
  })
 
- return war
+ return tankWar
 }
 
 func (war *TankWarrior) GetWarrior() *warrior.Warrior {

sim/warrior/tank_warrior/tank_warrior_test.go

@@ -42,7 +42,7 @@ var PlayerOptionsBasic = &proto.Player_TankWarrior{
  },
 }
 
-var warriorOptions = &proto.TankWarrior_Options{
+var warriorOptions = &proto.WarriorBaseOptions{
  Shout: proto.WarriorShout_WarriorShoutCommanding,
  StartingRage: 0,
 }

sim/warrior/warrior.go

@@ -58,6 +58,7 @@ type Warrior struct {
 
  Talents *proto.WarriorTalents
 
+ Options *proto.WarriorBaseOptions
  WarriorInputs
 
  // Current state
@@ -144,6 +145,15 @@ type Warrior struct {
  DemoralizingShoutAuras core.AuraArray
  SunderArmorAuras core.AuraArray
  ThunderClapAuras core.AuraArray
+
+ IsUsingRendStopAttack bool
+ IsUsingBloodthirstStopAttack bool
+ IsUsingQuickStrikeStopAttack bool
+ IsUsingHamstringStopAttack bool
+ IsUsingWhirlwindStopAttack bool
+ IsUsingExecuteStopAttack bool
+ IsUsingOverpowerStopAttack bool
+ IsUsingHeroicStrikeStopAttack bool
 }
 
 func (warrior *Warrior) GetCharacter() *core.Character {
@@ -263,6 +273,57 @@ func (warrior *Warrior) Initialize() {
 
  warrior.registerBloodrageCD()
  warrior.RegisterRecklessnessCD()
+
+ warrior.registerStopAttackMacros()
+
+}
+
+func (warrior *Warrior) registerStopAttackMacros() {
+
+ if warrior.Rend != nil && warrior.Options.IsUsingRendStopAttack {
+ warrior.Rend.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.Bloodthirst != nil && warrior.Options.IsUsingBloodthirstStopAttack {
+ warrior.Bloodthirst.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.QuickStrike != nil && warrior.Options.IsUsingQuickStrikeStopAttack {
+ warrior.Bloodthirst.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.Hamstring != nil && warrior.Options.IsUsingHamstringStopAttack {
+ warrior.Hamstring.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.Whirlwind != nil && warrior.Options.IsUsingWhirlwindStopAttack {
+ warrior.Whirlwind.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.Whirlwind != nil && warrior.Options.IsUsingWhirlwindStopAttack {
+ warrior.Whirlwind.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.WhirlwindMH != nil && warrior.Options.IsUsingWhirlwindStopAttack {
+ warrior.WhirlwindMH.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.WhirlwindOH != nil && warrior.Options.IsUsingWhirlwindStopAttack {
+ warrior.WhirlwindOH.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.Execute != nil && warrior.Options.IsUsingExecuteStopAttack {
+ warrior.Execute.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.Overpower != nil && warrior.Options.IsUsingOverpowerStopAttack {
+ warrior.Overpower.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
+ if warrior.HeroicStrike != nil && warrior.Options.IsUsingHeroicStrikeStopAttack {
+ warrior.HeroicStrike.Flags |= core.SpellFlagBatchStopAttackMacro
+ }
+
 }
 
 func (warrior *Warrior) Reset(sim *core.Simulation) {
@@ -301,13 +362,14 @@ func (warrior *Warrior) Reset(sim *core.Simulation) {
  }
 }
 
-func NewWarrior(character *core.Character, talents string, inputs WarriorInputs) *Warrior {
+func NewWarrior(character *core.Character, options *proto.Player, warOptions *proto.WarriorBaseOptions, inputs WarriorInputs) *Warrior {
  warrior := &Warrior{
  Character: *character,
  Talents: &proto.WarriorTalents{},
+ Options: warOptions,
  WarriorInputs: inputs,
  }
- core.FillTalentsProto(warrior.Talents.ProtoReflect(), talents, TalentTreeSizes)
+ core.FillTalentsProto(warrior.Talents.ProtoReflect(), options.TalentsString, TalentTreeSizes)
 
  warrior.PseudoStats.CanParry = true
 

ui/core/proto_utils/utils.ts

@@ -75,10 +75,10 @@ import { BlessingsAssignment, BlessingsAssignments, UIEnchant as Enchant, UIItem
 import { TankWarlock, Warlock, WarlockOptions, WarlockRotation, WarlockTalents } from '../proto/warlock.js';
 import {
  TankWarrior,
- TankWarrior_Options as TankWarriorOptions,
+ WarriorBaseOptions as TankWarriorOptions,
  TankWarrior_Rotation as TankWarriorRotation,
  Warrior,
- Warrior_Options as WarriorOptions,
+ WarriorBaseOptions as WarriorOptions,
  Warrior_Rotation as WarriorRotation,
  WarriorTalents,
 } from '../proto/warrior.js';

ui/tank_warrior/presets.ts

@@ -23,7 +23,7 @@ import {
  ZanzaBuff,
 } from '../core/proto/common.js';
 import { SavedTalents } from '../core/proto/ui.js';
-import { TankWarrior_Options as TankWarriorOptions, WarriorShout, WarriorStance } from '../core/proto/warrior.js';
+import { WarriorBaseOptions as TankWarriorOptions, WarriorShout, WarriorStance } from '../core/proto/warrior.js';
 import Phase4APL from './apls/phase_4.apl.json';
 import Phase4DamageGear from './gear_sets/phase_4_damage.gear.json';
 import Phase4TankyGear from './gear_sets/phase_4_tanky.gear.json';

ui/warrior/inputs.ts

@@ -1,2 +1,52 @@
 // Configuration for spec-specific UI elements on the settings tab.
 // These don't need to be in a separate file but it keeps things cleaner.
+import * as InputHelpers from '../core/components/input_helpers.js';
+import { Spec } from '../core/proto/common.js';
+
+export const RendStopAttack = InputHelpers.makeSpecOptionsBooleanInput<Spec.SpecWarrior>({
+ fieldName: 'isUsingRendStopAttack',
+ label: 'Using Rend StopAttack Macro',
+ labelTooltip: '/cast [@target] Rend \n/stopattack',
+});
+
+export const BloodthirstStopAttack = InputHelpers.makeSpecOptionsBooleanInput<Spec.SpecWarrior>({
+ fieldName: 'isUsingBloodthirstStopAttack',
+ label: 'Using Bloodthirst StopAttack Macro',
+ labelTooltip: '/cast [@target] Bloodthirst \n/stopattack',
+});
+
+export const QuickStrikeStopAttack = InputHelpers.makeSpecOptionsBooleanInput<Spec.SpecWarrior>({
+ fieldName: 'isUsingQuickStrikeStopAttack',
+ label: 'Using Quick Strike StopAttack Macro',
+ labelTooltip: '/cast [@target] Quick Strike \n/stopattack',
+});
+
+export const HamstringStopAttack = InputHelpers.makeSpecOptionsBooleanInput<Spec.SpecWarrior>({
+ fieldName: 'isUsingHamstringStopAttack',
+ label: 'Using Hamstring StopAttack Macro',
+ labelTooltip: '/cast [@target] Hamstring \n/stopattack',
+});
+
+export const WhirlwindStopAttack = InputHelpers.makeSpecOptionsBooleanInput<Spec.SpecWarrior>({
+ fieldName: 'isUsingWhirlwindStopAttack',
+ label: 'Using Whirlwind StopAttack Macro',
+ labelTooltip: '/cast [@target] Whirlwind \n/stopattack',
+});
+
+export const ExecuteStopAttack = InputHelpers.makeSpecOptionsBooleanInput<Spec.SpecWarrior>({
+ fieldName: 'isUsingExecuteStopAttack',
+ label: 'Using Execute StopAttack Macro',
+ labelTooltip: '/cast [@target] Execute \n/stopattack',
+});
+
+export const OverpowerStopAttack = InputHelpers.makeSpecOptionsBooleanInput<Spec.SpecWarrior>({
+ fieldName: 'isUsingOverpowerStopAttack',
+ label: 'Using Overpower StopAttack Macro',
+ labelTooltip: '/cast [@target] Overpower \n/stopattack',
+});
+
+export const HeroicStrikeStopAttack = InputHelpers.makeSpecOptionsBooleanInput<Spec.SpecWarrior>({
+ fieldName: 'isUsingHeroicStrikeStopAttack',
+ label: 'Using Heroic Strike StopAttack Macro',
+ labelTooltip: '/cast [@target] Heroic Strike \n/stopattack',
+});

ui/warrior/presets.ts

@@ -22,7 +22,7 @@ import {
  ZanzaBuff,
 } from '../core/proto/common.js';
 import { SavedTalents } from '../core/proto/ui.js';
-import { Warrior_Options as WarriorOptions, WarriorShout, WarriorStance } from '../core/proto/warrior.js';
+import { WarriorBaseOptions, WarriorShout, WarriorStance as Warrior_Options } from '../core/proto/warrior.js';
 import Phase1APLArms from './apls/phase_1_arms.apl.json';
 import Phase2APLArms from './apls/phase_2_arms.apl.json';
 import Phase2APLFury from './apls/phase_2_fury.apl.json';
@@ -180,10 +180,10 @@ export const PresetBuildGlad = PresetUtils.makePresetBuild('Glad', DefaultGearGl
 // Options Presets
 ///////////////////////////////////////////////////////////////////////////
 
-export const DefaultOptions = WarriorOptions.create({
+export const DefaultOptions = WarriorBaseOptions.create({
  startingRage: 0,
  shout: WarriorShout.WarriorShoutBattle,
- stance: WarriorStance.WarriorStanceBerserker,
+ stance: Warrior_Options.WarriorStanceBerserker,
 });
 
 export const DefaultConsumes = Consumes.create({

ui/warrior/sim.ts

@@ -9,6 +9,7 @@ import { WarriorRune, WarriorStance } from '../core/proto/warrior';
 import { Stats } from '../core/proto_utils/stats';
 import { getSpecIcon } from '../core/proto_utils/utils';
 import * as Presets from './presets';
+import * as DpsWarriorInputs from './inputs.js';
 
 const SPEC_CONFIG = registerSpecConfig(Spec.SpecWarrior, {
  cssClass: 'warrior-sim-ui',
@@ -87,8 +88,14 @@ const SPEC_CONFIG = registerSpecConfig(Spec.SpecWarrior, {
  excludeBuffDebuffInputs: [],
  // Inputs to include in the 'Other' section on the settings tab.
  otherInputs: {
- inputs: [WarriorInputs.StartingRage<Spec.SpecWarrior>(), WarriorInputs.StanceSnapshot<Spec.SpecWarrior>(), OtherInputs.InFrontOfTarget],
+ inputs: [WarriorInputs.StartingRage<Spec.SpecWarrior>(), 
+ WarriorInputs.StanceSnapshot<Spec.SpecWarrior>(),
+ OtherInputs.InFrontOfTarget,
+ DpsWarriorInputs.RendStopAttack, DpsWarriorInputs.BloodthirstStopAttack, DpsWarriorInputs.QuickStrikeStopAttack,
+ DpsWarriorInputs.HamstringStopAttack, DpsWarriorInputs.WhirlwindStopAttack, DpsWarriorInputs.ExecuteStopAttack,
+ DpsWarriorInputs.OverpowerStopAttack, DpsWarriorInputs.HeroicStrikeStopAttack],
  },
+
  encounterPicker: {
  // Whether to include 'Execute Duration (%)' in the 'Encounter' section of the settings tab.
  showExecuteProportion: true,