public void TestWasteNot2()
{
WasteNot2 waste = new WasteNot2();
BasicSynthesis bs = new BasicSynthesis();
State state = Utility.CreateDefaultState();
state.MaxDurability = 50;
state.Durability = 50;
state.Craftsmanship = 10;
state.Control = 10;
state.MaxProgress = 100;
State activeState = waste.Activate(state, true);
State nextState = null;
for (int i = (int)waste.Duration; i > 0; --i)
{
Assert.AreEqual <uint>((uint)i, activeState.WasteNot2Turns);
nextState = bs.Activate(activeState, true);
Assert.AreEqual <uint>(activeState.Durability - 5U, nextState.Durability);
activeState = nextState;
}
nextState = bs.Activate(activeState, true);
Assert.AreEqual <uint>(activeState.Durability - 10U, nextState.Durability);
}
public void TestInnerQuiet()
{
InnerQuiet iq = new InnerQuiet();
BasicTouch bt = new BasicTouch();
BasicSynthesis bs = new BasicSynthesis();
State state = Utility.CreateDefaultState();
state.MaxQuality = 1500;
state.Quality = 0;
State afteriq = iq.Activate(state, true);
Assert.IsTrue(afteriq.InnerQuietIsActive);
Assert.AreEqual <uint>(0, afteriq.InnerQuietStacks);
State afterbt = bt.Activate(afteriq, true);
Assert.AreEqual <uint>(1, afterbt.InnerQuietStacks);
Assert.IsTrue(Compute.Control(afterbt) > Compute.Control(afteriq));
Assert.IsTrue(Compute.Quality(afterbt, 100) > Compute.Quality(afteriq, 100));
State afterbs = bs.Activate(afterbt, true);
Assert.AreEqual <uint>(1, afterbs.InnerQuietStacks);
Assert.AreEqual <uint>(Compute.Control(afterbt), Compute.Control(afterbs));
Assert.AreEqual <uint>(Compute.Quality(afterbt, 100), Compute.Quality(afterbs, 100));
}
public void TestComfortZone()
{
ComfortZone comfort = new ComfortZone();
BasicSynthesis basic = new BasicSynthesis();
State state = Utility.CreateDefaultState();
state.CrafterLevel = 20;
state.Craftsmanship = 20;
state.SynthLevel = 25;
state.Progress = 0;
state.MaxProgress = 120;
state.CP = 100;
state.MaxCP = 500;
state.MaxDurability = 120;
state.Durability = 120;
State comfortable = comfort.Activate(state, true);
Assert.IsTrue(ComfortZone.IsActive(comfortable));
for (int i = (int)comfort.Duration; i > 0; --i)
{
State nextState = basic.Activate(comfortable, true);
Assert.AreEqual <uint>(comfortable.CP + 10, nextState.CP);
comfortable = nextState;
}
}
public void TestBasicSynthesis()
{
BasicSynthesis action = new BasicSynthesis();
State state = Utility.CreateDefaultState();
State success = action.Activate(state, true);
State failure = action.Activate(state, false);
// Test that we can use it even with 0 CP
TestBlocks.TestCanUseWithCP(action, state, 0);
// Test that it doesn't use any CP
Assert.AreEqual <uint>(state.CP, success.CP);
Assert.AreEqual <uint>(state.CP, failure.CP);
// Test that it uses the correct amount of durability.
Assert.AreEqual <uint>(state.Durability - action.BaseDurability, success.Durability);
Assert.AreEqual <uint>(state.Durability - action.BaseDurability, failure.Durability);
// Test that failure does not increase progress, but success does.
Assert.AreEqual <uint>(state.Progress, failure.Progress);
Assert.AreEqual <uint>(state.Progress + Compute.Progress(state, action.BaseEfficiency), success.Progress);
// Test that nothing changed except durability, progress, and condition.
success.Condition = failure.Condition = state.Condition;
success.Durability = failure.Durability = state.Durability;
success.Progress = failure.Progress = state.Progress;
bool equal = state.Equals(success);
Assert.AreEqual <State>(state, success);
Assert.AreEqual <State>(state, failure);
}
public void TestGreatStridesDuration()
{
GreatStrides greatStrides = new GreatStrides();
BasicSynthesis basicSynth = new BasicSynthesis();
State state = Utility.CreateDefaultState();
state.Quality = 142;
state.MaxQuality = 726;
state.Progress = 0;
state.MaxProgress = 100;
state.Durability = 100;
state.MaxDurability = 100;
state.CrafterLevel = 16;
state.SynthLevel = 13;
state.Craftsmanship = 105;
state.Control = 102;
state.Condition = Condition.Normal;
state.CP = 55;
state.MaxCP = 233;
Assert.IsTrue(greatStrides.CanUse(state));
state = greatStrides.Activate(state, true);
for (uint i = greatStrides.Duration; i > 0; --i)
{
Assert.AreEqual <uint>(i, GreatStrides.GetTurnsRemaining(state));
state = basicSynth.Activate(state, true);
}
Assert.AreEqual <uint>(0U, GreatStrides.GetTurnsRemaining(state));
}
// 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 TestIngenuity2LevelReduction()
{
Ingenuity2 ingenuity = new Ingenuity2();
BasicSynthesis bs = new BasicSynthesis();
State state = Utility.CreateDefaultState();
state.CrafterLevel = 20;
state.SynthLevel = 25;
state.Progress = 0;
state.MaxProgress = 100;
Assert.AreEqual <int>(-5, Compute.LevelSurplus(state));
state = ingenuity.Activate(state, true);
Assert.AreEqual <int>(3, Compute.LevelSurplus(state));
}
public void TestManipulationWithTenDurabilityBusts()
{
Manipulation manipulation = new Manipulation();
BasicSynthesis basic = new BasicSynthesis();
State state = Utility.CreateDefaultState();
state.Durability = 10;
State s2 = manipulation.Activate(state, true);
Assert.AreEqual <uint>(10, s2.Durability);
Assert.AreEqual(SynthesisStatus.IN_PROGRESS, s2.Status);
s2 = basic.Activate(s2, true);
Assert.AreEqual <uint>(0, s2.Durability);
Assert.AreEqual(SynthesisStatus.BUSTED, s2.Status);
}
public void EnsureMastersMendAtEndOfMultiStageSynth()
{
// By using a 4 step max analysis depth, we can check that after 3 steps, if the
// 4th step would end the synth, a Master's Mend can be used to regain durability.
Analyzer analyzer = new Analyzer();
analyzer.Actions.AddAction(new BasicSynthesis());
analyzer.Actions.AddAction(new BasicTouch());
analyzer.Actions.AddAction(new MastersMend());
analyzer.Actions.AddAction(new SteadyHand());
analyzer.Actions.AddAction(new Observe());
analyzer.Actions.AddAction(new Manipulation());
analyzer.Actions.AddAction(new TricksOfTheTrade());
analyzer.Actions.AddAction(new StandardTouch());
State initialState = new State();
initialState.Condition = Condition.Normal;
initialState.Control = 115;
initialState.Craftsmanship = 123;
initialState.CP = 251;
initialState.MaxCP = 251;
initialState.MaxDurability = 40;
initialState.Durability = 40;
initialState.MaxProgress = 74;
initialState.Quality = 0;
initialState.MaxQuality = 1053;
initialState.SynthLevel = 20;
initialState.CrafterLevel = 18;
analyzer.MaxAnalysisDepth = 4;
analyzer.Run(initialState);
BasicSynthesis basic = new BasicSynthesis();
initialState = basic.Activate(initialState, true);
initialState = basic.Activate(initialState, true);
initialState = basic.Activate(initialState, true);
Simulator.Engine.Ability bestAction = analyzer.OptimalAction(initialState);
Assert.AreEqual <Type>(typeof(MastersMend), bestAction.GetType());
}
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 TestIngenuity2Turns()
{
Ingenuity2 ingenuity = new Ingenuity2();
BasicSynthesis bs = new BasicSynthesis();
State state = Utility.CreateDefaultState();
state.CrafterLevel = 20;
state.SynthLevel = 25;
state.Progress = 0;
state.MaxProgress = 100;
state = ingenuity.Activate(state, true);
for (int i = 0; i < ingenuity.Duration; ++i)
{
Assert.AreEqual(ingenuity.Duration - i, Ingenuity2.GetTurnsRemaining(state));
state = bs.Activate(state, true);
}
Assert.AreEqual <uint>(0, Ingenuity2.GetTurnsRemaining(state));
Assert.IsFalse(Ingenuity.IsActive(state));
}
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);
}
