public void TestBasicTouchPreferredOverTricksOfTheTradeWithHighDurability2()
{
Simulator.Engine.Ability tott = new TricksOfTheTrade();
Simulator.Engine.Ability basicTouch = new BasicTouch();
Simulator.Engine.Ability steadyHand = new SteadyHand();
State state = new State();
state.Condition = Simulator.Engine.Condition.Good;
state.Control = 119;
state.Craftsmanship = 131;
state.CP = 254;
state.MaxCP = 254;
state.MaxDurability = 70;
state.Durability = 70;
state.MaxProgress = 74;
state.Quality = 284;
state.MaxQuality = 1053;
state.SynthLevel = 20;
state.CrafterLevel = 19;
state = steadyHand.Activate(state, true);
State tottState = tott.Activate(state, true);
tottState.Condition = Condition.Normal;
State basicTouchState = basicTouch.Activate(state, true);
basicTouchState.Condition = Condition.Normal;
Assert.IsTrue(basicTouchState.Score > tottState.Score);
}
// Construct the CarpenterActions list.
public CarpenterActions()
{
ResourceLibrary = new ResourceLibrary(Settings.ResourceLocation, ClassJobType.Carpenter);
BasicSynthesis = new BasicSynthesis(CraftActionId.crp_BasicSynthesis,
ResourceLibrary.ClassSkillImages["crp_BasicSynthesis"]);
StandardSynthesis = new StandardSynthesis(CraftActionId.crp_StandardSynthesis,
ResourceLibrary.ClassSkillImages["crp_StandardSynthesis"]);
BasicTouch = new BasicTouch(CraftActionId.crp_BasicTouch, ResourceLibrary.ClassSkillImages["crp_BasicTouch"]);
StandardTouch = new StandardTouch(CraftActionId.crp_StandardTouch,
ResourceLibrary.ClassSkillImages["crp_StandardTouch"]);
AdvancedTouch = new AdvancedTouch(CraftActionId.crp_AdvancedTouch,
ResourceLibrary.ClassSkillImages["crp_AdvancedTouch"]);
PreciseTouch = new PreciseTouch(CraftActionId.crp_PreciseTouch,
ResourceLibrary.ClassSkillImages["crp_PreciseTouch"]);
MastersMend = new MastersMend(CraftActionId.crp_MastersMend);
MastersMendII = new MastersMendII(CraftActionId.crp_MastersMendII);
SteadyHand = new SteadyHand(CraftActionId.crp_SteadyHand);
InnerQuiet = new InnerQuiet(CraftActionId.crp_InnerQuiet);
GreatStrides = new GreatStrides(CraftActionId.crp_GreatStrides);
Observe = new Observe(CraftActionId.crp_Observe);
CollectableSynthesis = new CollectableSynthesis(CraftActionId.crp_CollectableSynthesis);
ByregotsBrow = new ByregotsBrow(CraftActionId.crp_ByregotsBrow);
InnovativeTouch = new InnovativeTouch(CraftActionId.crp_InnovativeTouch);
ByregotsMiracle = new ByregotsMiracle(CraftActionId.crp_ByregotsMiracle);
NymeiasWheel = new NymeiasWheel(CraftActionId.crp_NymeiasWheel);
TrainedHand = new TrainedHand(CraftActionId.crp_TrainedHand);
Satisfaction = new Satisfaction(CraftActionId.crp_Satisfaction);
Heart = new Heart(CraftActionId.crp_Heart);
WhistleWhileYouWork = new WhistleWhileYouWork(CraftActionId.crp_WhistleWhileYouWork);
PHTouch = new PHTouch(CraftActionId.crp_PreciseTouch);
}
public void TestSteadyHandTurns()
{
State details = new State();
Assert.AreEqual <uint>(0, SteadyHand.GetTurnsRemaining(details));
for (int i = 5; i >= 0; --i)
{
SteadyHand.SetTurnsRemaining(details, (uint)i);
Assert.AreEqual <uint>((uint)i, SteadyHand.GetTurnsRemaining(details));
}
}
public void TestManipulation()
{
Manipulation manipulation = new Manipulation();
BasicSynthesis basic = new BasicSynthesis();
SteadyHand steadyHand = new SteadyHand();
State state = Utility.CreateDefaultState();
state.Durability = 30;
state.MaxDurability = 60;
// Verify that Manipulation can be activated successfully.
State s1 = manipulation.Activate(state, true);
Assert.AreEqual <uint>(manipulation.Duration, Manipulation.GetTurnsRemaining(s1));
// Verify that the durability has not changed simply as a result of activating manipulation.
Assert.AreEqual <uint>(state.Durability, s1.Durability);
// Verify that Manipulation can't be used if it's already up.
Assert.IsFalse(manipulation.CanUse(s1));
// Verify that using Basic Synthesis with Manipulation up doesn't decrease the durability.
State s2 = basic.Activate(s1, true);
Assert.AreEqual <uint>(s1.Durability, s2.Durability);
Assert.AreEqual <uint>(2, Manipulation.GetTurnsRemaining(s2));
Assert.IsFalse(manipulation.CanUse(s2));
// Verify that using Steady hand with Manipulation up causes the durability to increase by 10.
State s3 = steadyHand.Activate(s2, true);
Assert.AreEqual <uint>(s2.Durability + 10, s3.Durability);
Assert.AreEqual <uint>(1, Manipulation.GetTurnsRemaining(s3));
Assert.IsFalse(manipulation.CanUse(s3));
// Use another Basic Synthesis so we can verify that the buff de-activates.
State s4 = basic.Activate(s3, true);
Assert.IsTrue(manipulation.CanUse(s4));
}
public void TestUrgentCompletion2()
{
Analyzer analyzer = new Analyzer();
BasicSynthesis bs = new BasicSynthesis();
SteadyHand sh = new SteadyHand();
analyzer.Actions.AddAction(bs);
//analyzer.Actions.AddAction(new BasicTouch());
//analyzer.Actions.AddAction(new MastersMend());
analyzer.Actions.AddAction(sh);
//analyzer.Actions.AddAction(new Observe());
State state = Utility.CreateDefaultState();
// Make sure we don't have enough CP to run Master's Mend.
state.CP = Compute.CP(SynthAction <SynthActionAttribute, MastersMend> .Attributes.CP, state) - 1;
state.Durability = 20;
// Make sure exactly 2 Basic Synthesis' are required to finish the synth.
state.Progress = 0;
state.MaxProgress = 2 * Compute.Progress(state, bs.BaseEfficiency);
analyzer.Run(state);
// The best sequence is Steady Hand -> Basic Synthesis -> Basic Synthesis
Simulator.Engine.Ability bestAction = analyzer.OptimalAction(state);
Assert.AreEqual <Type>(typeof(SteadyHand), bestAction.GetType());
state = sh.Activate(state, true);
bestAction = analyzer.OptimalAction(state);
Assert.AreEqual <Type>(typeof(BasicSynthesis), bestAction.GetType());
state = bs.Activate(state, true);
bestAction = analyzer.OptimalAction(state);
Assert.AreEqual <Type>(typeof(BasicSynthesis), bestAction.GetType());
state = bs.Activate(state, true);
Assert.AreEqual(SynthesisStatus.COMPLETED, state.Status);
}
public void TestSteadyHand()
{
SteadyHand sh = new SteadyHand();
HastyTouch ht = new HastyTouch();
State state = Utility.CreateDefaultState();
state.Control = 10;
state.MaxDurability = 100;
state.Durability = 100;
state.MaxProgress = 127;
// Make sure we can actually use SH
Assert.IsTrue(sh.CanUse(state));
State afterSH = sh.Activate(state, true);
// Make sure Steady Hand uses the right amount of TP.
Assert.AreEqual <uint>(state.CP - sh.RequiredCP, afterSH.CP);
// Test that the buff is up, and is active for the correct number of turns.
Assert.AreEqual <uint>(sh.Duration, SteadyHand.GetTurnsRemaining(afterSH));
// Use Basic Synthesis 5 times, and make sure the success bonus decreases.
for (int i = 5; i > 0; --i)
{
Assert.AreEqual <uint>((uint)i, SteadyHand.GetTurnsRemaining(afterSH));
Assert.IsTrue(Compute.SuccessRate(ht.BaseSuccessRate, afterSH) > Compute.SuccessRate(ht.BaseSuccessRate, state));
// Make sure we can't use SH while SH is up.
Assert.IsFalse(sh.CanUse(afterSH));
afterSH = ht.Activate(afterSH, true);
}
Assert.AreEqual <uint>(0, SteadyHand.GetTurnsRemaining(afterSH));
Assert.AreEqual <double>(Compute.SuccessRate(sh.BaseSuccessRate, state), Compute.SuccessRate(sh.BaseSuccessRate, afterSH));
}
public void TestMultipleStatAssignment2()
{
State details = new State();
details.CrafterLevel = 13U;
details.SynthLevel = 40U;
details.Quality = 1215U;
details.MaxQuality = 923U;
details.Condition = Engine.Condition.Excellent;
Manipulation.SetTurnsRemaining(details, 2);
GreatStrides.SetTurnsRemaining(details, 3);
Ingenuity.SetTurnsRemaining(details, 1);
SteadyHand.SetTurnsRemaining(details, 4);
Assert.AreEqual <uint>(13, details.CrafterLevel);
Assert.AreEqual <uint>(40, details.SynthLevel);
Assert.AreEqual <uint>(1215, details.Quality);
Assert.AreEqual <uint>(923, details.MaxQuality);
Assert.AreEqual <Engine.Condition>(Engine.Condition.Excellent, details.Condition);
Assert.AreEqual <uint>(2, Manipulation.GetTurnsRemaining(details));
Assert.AreEqual <uint>(3, GreatStrides.GetTurnsRemaining(details));
Assert.AreEqual <uint>(1, Ingenuity.GetTurnsRemaining(details));
Assert.AreEqual <uint>(4, SteadyHand.GetTurnsRemaining(details));
}