%Please PLEASE find mistakes! I love working on this, any excuse to do
%more - you can reach me on BG as Radec, FFXIAH as Radec.Bismarck, Radec on
%Lunariansls.com, or RadecTheBLM on AIM.

%Using MATLAB 7.1.0.246 R14 SP3

%Assumptions: No JA are used when they could alter swing speed EXCEPT that
%WS does not killshot and the 120 delay there is felt. For every JA you use
%in a TP Cycle add 120 delay to

% Time_To_100 = ((Delay/Round_Rate)*Hits_to_WS/(1+DA_Rate) + 120)/60;

%Something like boost before a WS: Add whatever time you spend between
%boost and the WS, up to 2 seconds (120). Chained JA, up to 120 between
%them and 120 after the last, ex: Haste Samba > Wait 1.5 seconds (90) >
%Quick Step > Wait 1.2 seconds (72) > Reverse Flourish > Wait 2 Seconds
%(120) = 282 added delay.

%Other things: There is no mention of Accuracy here, or Zanshin. I
%originally wrote this to find the difference between 2March and MarchMin
%which shouldn't be altered by misses. At some point I may repost with
%Calcuation for those added but for now, enjoy.

%Honestly it's best if you fill this in on your own

Hits_to_WS = 15; %After WS has landed - This doesn't have to be whole, if 10% of the time you go 1 hit over, add 10%, 5.5 if normal is 5, etc.
Hits_on_WS = 8; %Remember /nin gets a bonus on Offhand
Haste_Gear = 0.25; %Some jobs get less
Haste_Magic = 0.15+0.12; %Haste Spell + VMarch
Haste_JA = 0.0+0.1; %Hasso and Samba
Att_Base = 465; %Guess
Level = 75; %If you change this you better fix WSC
Enemy_Def = 270; %Guess
Enemy_Level = 82; %Guess
Crit_Rate = 0.15; %Guess
DA_Rate = 0.05;
%OAT Weapons: Calculate your own "real" DA rate - I should make this extra
%attacks per round rather than DA in retrospect, to allow for
%Ridill/Soboro/KClub etc - just figure "On Average I throw 2.4 hits per
%round" and put that there.

WS_Crits = 0; %Set to 1 if the WS can crit.
WS_Crit_Rate = 0.00; %Guess
WS_Att_Base = 577;

WS_Att_Boost = 0; %Set to 0 if the WS doesn't get a base attack boost.
WS_First_Att_Base = 9999; %For WS with ATT boost, usually is capped but not always.
WS_First_Crit_Rate = 0; %Set to 1 for SA, or to w/e WS Crit rate is if you can crit Ws and get Att boost

WS_DA_Rate = 0.00; %Double normal DA rate if you have an offhand swing on the WS - example NIN/WAR + brutal is normally 15%, put 0.30.
%I'm aware that you don't get a 30% DA rate overall but read the whole
%thing before you question it please, I think it'll work.

%Aside: If you're a whm/nin trying to work this with hexa, FUCK YOU - I
%have no idea how 7 hits + 2 potential DA's will work with the
%8-hits-at-once cap.
Delay = 176;
WD_TP = 35 + 10; %Weapon Damage + fSTR
WD_WS = 35 + 10 + 12; %Weapon Damage + fSTR + WSC
WD_WS_Extra = 35 + 10; %No WSC on extra hits on WS
WS_fTP = 1.1; %Asuran Fist w/ Gorget

%Yup, that's a lot of variables!

%Case 1: 2x March
CRatio_Marches = Att_Base/Enemy_Def;
WS_CRatio_Marches = WS_Att_Base/Enemy_Def;
WS_First_CRatio_Marches = WS_First_Att_Base/Enemy_Def;

if Enemy_Level > Level
    CRatio_Marches = CRatio_Marches - 0.050 * (Enemy_Level - Level);
    WS_CRatio_Marches = WS_CRatio_Marches - 0.050 * (Enemy_Level - Level);
    WS_First_CRatio_Marches = WS_First_CRatio_Marches - 0.050 * (Enemy_Level - Level);
end

%TP CRatio
if CRatio_Marches < 0
    CRatio_Marches = 0;
end
if CRatio_Marches > 2
    CRatio_Marches1 = 2;
end
if CRatio_Marches > 2.2
    CRatio_Marches2 = 2.2;
end
CRatio_Marches1 = CRatio_Marches;
CRatio_Marches2 = CRatio_Marches;

%WS_CRatio
if WS_CRatio_Marches < 0
    WS_CRatio_Marches = 0;
end
if WS_CRatio_Marches > 2
    WS_CRatio_Marches1 = 2;
end
if WS_CRatio_Marches > 2.2
    WS_CRatio_Marches2 = 2.2;
end
WS_CRatio_Marches1 = WS_CRatio_Marches;
WS_CRatio_Marches2 = WS_CRatio_Marches;

%WS_CRatio w/ ATT Boosted first hit.
if WS_First_CRatio_Marches < 0
    WS_First_CRatio_Marches = 0;
end
if WS_First_CRatio_Marches > 2
    WS_First_CRatio_Marches1 = 2;
else
    WS_First_CRatio_Marches1 = WS_First_CRatio_Marches;
end
if WS_First_CRatio_Marches > 2.2
    WS_First_CRatio_Marches2 = 2.2;
else
    WS_First_CRatio_Marches2 = WS_First_CRatio_Marches;
end

%Case 1A: 1Hander
if CRatio_Marches1 < 0.5
    fMax_1Hand_Marches = 0.4 + 1.2*CRatio_Marches1;
elseif CRatio_Marches1 <= 5/6
    fMax_1Hand_Marches = 1;
elseif CRatio_Marches1 < 2
    fMax_1Hand_Marches = 1.2*CRatio_Marches1;
elseif CRatio_Marches1 == 2
    fMax_1Hand_Marches = 1.2*CRatio_Marches1 + 0.05;
end

fMax_1Hand_Marches_Crit = (fMax_1Hand_Marches+1);
if fMax_1Hand_Marches_Crit > 3
    fMax_1Hand_Marches_Crit = 3;
end

fMax_1Hand_Marches_Crit = fMax_1Hand_Marches_Crit * 1.05;
fMax_1Hand_Marches = fMax_1Hand_Marches * 1.05;

if CRatio_Marches1 < 1.25
    fMin_1Hand_Marches = -0.5 + 1.2*CRatio_Marches1;
elseif 1.25 < CRatio_Marches1 <= 1.5
    fMin_1Hand_Marches = 1;
elseif 1.5 < CRatio_Marches1 < 2
    fMin_1Hand_Marches = -0.8+1.2*CRatio_Marches1;
elseif CRatio_Marches1 == 2
    fMin_1Hand_Marches = -0.82+1.2*CRatio_Marches1;
end
if fMin_1Hand_Marches < 0
    fMin_1Hand_Marches = 0;
end

fMin_1Hand_Marches_Crit = fMin_1Hand_Marches+1;

%Case 1B: 2Hander - note that unlike 1Hand I am not 100% certain on pDIF
%numbers.

if CRatio_Marches2 <= 0.5
    fMax_2Hand_Marches = 0.4 + 1.2*CRatio_Marches2;
elseif CRatio_Marches2 <= 5/6
    fMax_2Hand_Marches = 1;
elseif CRatio_Marches2 < 2.2
    fMax_2Hand_Marches = 1.2*CRatio_Marches2;
elseif CRatio_Marches2 == 2.2
    fMax_2Hand_Marches = 1.2*CRatio_Marches2 + 0.05;
end

fMax_2Hand_Marches_Crit = (fMax_2Hand_Marches+1);
if fMax_2Hand_Marches_Crit > 3
    fMax_2Hand_Marches_Crit = 3;
end

fMax_2Hand_Marches_Crit = fMax_2Hand_Marches_Crit * 1.05;
fMax_2Hand_Marches = fMax_2Hand_Marches*1.05;

if CRatio_Marches2 <= 1.25
    fMin_2Hand_Marches = -0.5 + 1.2*CRatio_Marches2;
elseif CRatio_Marches2 <= 1.5;
    fMin_2Hand_Marches = 1;
elseif CRatio_Marches2 < 2.2
    fMin_2Hand_Marches = -0.8+1.2*CRatio_Marches2;
elseif CRatio_Marches2 == 2.2
    fMin_2Hand_Marches = -0.8+1.2*CRatio_Marches2;
end

if fMin_2Hand_Marches < 0
    fMin_2Hand_Marches = 0;
end
fMin_2Hand_Marches_Crit = fMin_2Hand_Marches+1;

%Case 1C: 1Hander WS

if WS_CRatio_Marches1 < 0.5
    WS_fMax_1Hand_Marches = 0.4 + 1.2*WS_CRatio_Marches1;
elseif WS_CRatio_Marches1 <= 5/6
    WS_fMax_1Hand_Marches = 1;
elseif WS_CRatio_Marches1 < 2
    WS_fMax_1Hand_Marches = 1.2*WS_CRatio_Marches1;
elseif WS_CRatio_Marches1 == 2
    WS_fMax_1Hand_Marches = 1.2*WS_CRatio_Marches1 + 0.05;
end

WS_fMax_1Hand_Marches_Crit = (WS_fMax_1Hand_Marches+1);
if WS_fMax_1Hand_Marches_Crit > 3
    WS_fMax_1Hand_Marches_Crit = 3;
end

WS_fMax_1Hand_Marches_Crit = WS_fMax_1Hand_Marches_Crit * 1.05;
WS_fMax_1Hand_Marches = WS_fMax_1Hand_Marches * 1.05;

if WS_CRatio_Marches1 < 1.25
    WS_fMin_1Hand_Marches = -0.5 + 1.2*WS_CRatio_Marches1;
elseif 1.25 < WS_CRatio_Marches1 <= 1.5
    WS_fMin_1Hand_Marches = 1;
elseif 1.5 < WS_CRatio_Marches1 < 2
    WS_fMin_1Hand_Marches = -0.8+1.2*WS_CRatio_Marches1;
elseif WS_CRatio_Marches1 == 2
    WS_fMin_1Hand_Marches = -0.82+1.2*WS_CRatio_Marches1;
end
if WS_fMin_1Hand_Marches < 0
    WS_fMin_1Hand_Marches = 0;
end

WS_fMin_1Hand_Marches_Crit = WS_fMin_1Hand_Marches+1;

%Case 1D: 2Hander WS

if WS_CRatio_Marches2 <= 0.5
    WS_fMax_2Hand_Marches = 0.4 + 1.2*WS_CRatio_Marches2;
elseif WS_CRatio_Marches2 <= 5/6
    WS_fMax_2Hand_Marches = 1;
elseif WS_CRatio_Marches2 < 2.2
    WS_fMax_2Hand_Marches = 1.2*WS_CRatio_Marches2;
elseif WS_CRatio_Marches2 == 2.2
    WS_fMax_2Hand_Marches = 1.2*WS_CRatio_Marches2 + 0.05;
end

WS_fMax_2Hand_Marches_Crit = (WS_fMax_2Hand_Marches+1);
if WS_fMax_2Hand_Marches_Crit > 3
    WS_fMax_2Hand_Marches_Crit = 3;
end

WS_fMax_2Hand_Marches_Crit = WS_fMax_2Hand_Marches_Crit * 1.05;
WS_fMax_2Hand_Marches = WS_fMax_2Hand_Marches*1.05;

if WS_CRatio_Marches2 <= 1.25
    WS_fMin_2Hand_Marches = -0.5 + 1.2*WS_CRatio_Marches2;
elseif WS_CRatio_Marches2 <= 1.5;
    WS_fMin_2Hand_Marches = 1;
elseif WS_CRatio_Marches2 < 2.2
    WS_fMin_2Hand_Marches = -0.8+1.2*WS_CRatio_Marches2;
elseif WS_CRatio_Marches2 == 2.2
    WS_fMin_2Hand_Marches = -0.8+1.2*WS_CRatio_Marches2;
end

if WS_fMin_2Hand_Marches < 0
    WS_fMin_2Hand_Marches = 0;
end
WS_fMin_2Hand_Marches_Crit = WS_fMin_2Hand_Marches+1;

%Case 1E: 1Hander WS with ATT Boost

if WS_First_CRatio_Marches1 < 0.5
    WS_First_fMax_1Hand_Marches = 0.4 + 1.2*WS_First_CRatio_Marches1;
elseif WS_First_CRatio_Marches1 <= 5/6
    WS_First_fMax_1Hand_Marches = 1;
elseif WS_First_CRatio_Marches1 < 2
    WS_First_fMax_1Hand_Marches = 1.2*WS_First_CRatio_Marches1;
elseif WS_First_CRatio_Marches1 == 2
    WS_First_fMax_1Hand_Marches = 1.2*WS_First_CRatio_Marches1 + 0.05;
end

WS_First_fMax_1Hand_Marches_Crit = (WS_First_fMax_1Hand_Marches+1);
if WS_First_fMax_1Hand_Marches_Crit > 3
    WS_First_fMax_1Hand_Marches_Crit = 3;
end

WS_First_fMax_1Hand_Marches_Crit = WS_First_fMax_1Hand_Marches_Crit * 1.05;
WS_First_fMax_1Hand_Marches = WS_First_fMax_1Hand_Marches * 1.05;

if WS_First_CRatio_Marches1 < 1.25
    WS_First_fMin_1Hand_Marches = -0.5 + 1.2*WS_First_CRatio_Marches1;
elseif 1.25 < WS_First_CRatio_Marches1 <= 1.5
    WS_First_fMin_1Hand_Marches = 1;
elseif 1.5 < WS_First_CRatio_Marches1 < 2
    WS_First_fMin_1Hand_Marches = -0.8+1.2*WS_First_CRatio_Marches1;
elseif WS_First_CRatio_Marches1 == 2
    WS_First_fMin_1Hand_Marches = -0.82+1.2*WS_First_CRatio_Marches1;
end
if WS_First_fMin_1Hand_Marches < 0
    WS_First_fMin_1Hand_Marches = 0;
end

WS_First_fMin_1Hand_Marches_Crit = WS_First_fMin_1Hand_Marches+1;

%Case 1F: 2Hander WS with ATT Boost

if WS_First_CRatio_Marches2 <= 0.5
    WS_First_fMax_2Hand_Marches = 0.4 + 1.2*WS_First_CRatio_Marches2;
elseif WS_First_CRatio_Marches2 <= 5/6
    WS_First_fMax_2Hand_Marches = 1;
elseif WS_First_CRatio_Marches2 < 2.2
    WS_First_fMax_2Hand_Marches = 1.2*WS_First_CRatio_Marches2;
elseif WS_First_CRatio_Marches2 == 2.2
    WS_First_fMax_2Hand_Marches = 1.2*WS_First_CRatio_Marches2 + 0.05;
end

WS_First_fMax_2Hand_Marches_Crit = (WS_First_fMax_2Hand_Marches+1);
if WS_First_fMax_2Hand_Marches_Crit > 3
    WS_First_fMax_2Hand_Marches_Crit = 3;
end

WS_First_fMax_2Hand_Marches_Crit = WS_First_fMax_2Hand_Marches_Crit * 1.05;
WS_First_fMax_2Hand_Marches = WS_First_fMax_2Hand_Marches*1.05;

if WS_First_CRatio_Marches2 <= 1.25
    WS_First_fMin_2Hand_Marches = -0.5 + 1.2*WS_First_CRatio_Marches2;
elseif WS_First_CRatio_Marches2 <= 1.5;
    WS_First_fMin_2Hand_Marches = 1;
elseif WS_First_CRatio_Marches2 < 2.2
    WS_First_fMin_2Hand_Marches = -0.8+1.2*WS_First_CRatio_Marches2;
elseif WS_First_CRatio_Marches2 == 2.2
    WS_First_fMin_2Hand_Marches = -0.8+1.2*WS_First_CRatio_Marches2;
end

if WS_First_fMin_2Hand_Marches < 0
    WS_First_fMin_2Hand_Marches = 0;
end
WS_First_fMin_2Hand_Marches_Crit = WS_First_fMin_2Hand_Marches+1;

Haste_Magic_Marches = Haste_Magic + 0.09;
if Haste_Magic_Marches > 0.4375;
    Haste_Magic_Marches = 0.4375;
end

Haste_Marches = Haste_Gear + Haste_Magic_Marches + Haste_JA; %Haste Total
if Haste_Marches > 0.8
    Haste_Marches = 0.8;
end

Round_Rate = 1/(1-Haste_Marches);
Time_To_100 = ((Delay/Round_Rate)*Hits_to_WS/(1+DA_Rate) + 120)/60;

%Going to make an assumption pdif is evenly distributed in the range min ->
%max.
pDIF_1Hand_Marches_avg = (fMin_1Hand_Marches+fMax_1Hand_Marches)/2;
pDIF_2Hand_Marches_avg = (fMin_2Hand_Marches+fMax_2Hand_Marches)/2;

pDIF_1Hand_Marches_avg_Crit = (fMin_1Hand_Marches_Crit+fMax_1Hand_Marches_Crit)/2;
pDIF_2Hand_Marches_avg_Crit = (fMin_2Hand_Marches_Crit+fMax_2Hand_Marches_Crit)/2;

pDIF_1Hand_Marches_avg_withCrit = ((1-Crit_Rate)*(pDIF_1Hand_Marches_avg)+(Crit_Rate)*(pDIF_1Hand_Marches_avg_Crit));
pDIF_2Hand_Marches_avg_withCrit = ((1-Crit_Rate)*(pDIF_2Hand_Marches_avg)+(Crit_Rate)*(pDIF_2Hand_Marches_avg_Crit));

WS_pDIF_1Hand_Marches_avg = (WS_fMin_1Hand_Marches+WS_fMax_1Hand_Marches)/2;
WS_pDIF_2Hand_Marches_avg = (WS_fMin_2Hand_Marches+WS_fMax_2Hand_Marches)/2;

WS_pDIF_1Hand_Marches_avg_Crit = (WS_fMin_1Hand_Marches_Crit+WS_fMax_1Hand_Marches_Crit)/2;
WS_pDIF_2Hand_Marches_avg_Crit = (WS_fMin_2Hand_Marches_Crit+WS_fMax_2Hand_Marches_Crit)/2;

WS_pDIF_1Hand_Marches_avg_withCrit = ((1-WS_Crit_Rate)*(WS_pDIF_1Hand_Marches_avg)+(WS_Crit_Rate)*(WS_pDIF_1Hand_Marches_avg_Crit));
WS_pDIF_2Hand_Marches_avg_withCrit = ((1-WS_Crit_Rate)*(WS_pDIF_2Hand_Marches_avg)+(WS_Crit_Rate)*(WS_pDIF_2Hand_Marches_avg_Crit));

WS_First_pDIF_1Hand_Marches_avg = (WS_First_fMin_1Hand_Marches+WS_First_fMax_1Hand_Marches)/2;
WS_First_pDIF_2Hand_Marches_avg = (WS_First_fMin_2Hand_Marches+WS_First_fMax_2Hand_Marches)/2;

WS_First_pDIF_1Hand_Marches_avg_Crit = (WS_First_fMin_1Hand_Marches_Crit+WS_First_fMax_1Hand_Marches_Crit)/2;
WS_First_pDIF_2Hand_Marches_avg_Crit = (WS_First_fMin_2Hand_Marches_Crit+WS_First_fMax_2Hand_Marches_Crit)/2;

WS_First_pDIF_1Hand_Marches_avg_withCrit = ((1-WS_First_Crit_Rate)*(WS_First_pDIF_1Hand_Marches_avg)+(WS_First_Crit_Rate)*(WS_First_pDIF_1Hand_Marches_avg_Crit));
WS_First_pDIF_2Hand_Marches_avg_withCrit = ((1-WS_First_Crit_Rate)*(WS_First_pDIF_2Hand_Marches_avg)+(WS_First_Crit_Rate)*(WS_First_pDIF_2Hand_Marches_avg_Crit));

Damage_To_100_1Hand_Marches = Hits_to_WS*WD_TP*pDIF_1Hand_Marches_avg_withCrit;
Damage_To_100_2Hand_Marches = Hits_to_WS*WD_TP*pDIF_2Hand_Marches_avg_withCrit;

if WS_Att_Boost == 1 %I've replaced pDIF averages on the first hit with the highest possible average here - as magic numbers. Sorry!
    if WS_Crits == 0
        WS_Damage_1Hand_Marches = (WD_WS)*WS_fTP*WS_First_pDIF_1Hand_Marches_avg + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_1Hand_Marches_avg;
        WS_Damage_2Hand_Marches = (WD_WS)*WS_fTP*WS_First_pDIF_2Hand_Marches_avg + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_2Hand_Marches_avg;
    else
        WS_Damage_1Hand_Marches = (WD_WS)*WS_fTP*WS_First_pDIF_1Hand_Marches_avg_withCrit + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_1Hand_Marches_avg_withCrit;
        WS_Damage_2Hand_Marches = (WD_WS)*WS_fTP*WS_First_pDIF_2Hand_Marches_avg_withCrit + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_2Hand_Marches_avg_withCrit;
    end
else
    if WS_Crits == 1
        WS_Damage_1Hand_Marches = (WD_WS)*WS_fTP*WS_pDIF_1Hand_Marches_avg_withCrit + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_1Hand_Marches_avg_withCrit;
        WS_Damage_2Hand_Marches = (WD_WS)*WS_fTP*WS_pDIF_2Hand_Marches_avg_withCrit + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_2Hand_Marches_avg_withCrit;
    else
        WS_Damage_1Hand_Marches = (WD_WS)*WS_fTP*(WS_pDIF_1Hand_Marches_avg) + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*(WS_pDIF_1Hand_Marches_avg);
        WS_Damage_2Hand_Marches = (WD_WS)*WS_fTP*(WS_pDIF_2Hand_Marches_avg) + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*(WS_pDIF_2Hand_Marches_avg);
    end
end

DPS_1Hand_Marches = (WS_Damage_1Hand_Marches+Damage_To_100_1Hand_Marches)/Time_To_100
DPS_2Hand_Marches = (WS_Damage_2Hand_Marches+Damage_To_100_2Hand_Marches)/Time_To_100

%Case 2: VMarch and Min4

CRatio_MarchMin = Att_Base+66/Enemy_Def;
WS_CRatio_MarchMin = WS_Att_Base+66/Enemy_Def;
WS_First_CRatio_MarchMin = WS_First_Att_Base+66/Enemy_Def;

if Enemy_Level > Level
    CRatio_MarchMin = CRatio_MarchMin - 0.050 * (Enemy_Level - Level);
    WS_CRatio_MarchMin = WS_CRatio_MarchMin - 0.050 * (Enemy_Level - Level);
end

%TP CRatio
if CRatio_MarchMin < 0
    CRatio_MarchMin = 0;
end
if CRatio_MarchMin > 2
    CRatio_MarchMin1 = 2;
else
    CRatio_MarchMin1 = CRatio_MarchMin;
end
if CRatio_MarchMin > 2.2
    CRatio_MarchMin2 = 2.2;
else
    CRatio_MarchMin1 = CRatio_MarchMin;
end

%WS_CRatio
if WS_CRatio_MarchMin < 0
    WS_CRatio_MarchMin = 0;
end
if WS_CRatio_MarchMin > 2
    WS_CRatio_MarchMin1 = 2;
else
    WS_CRatio_MarchMin1 = WS_CRatio_MarchMin;
end
if WS_CRatio_MarchMin > 2.2
    WS_CRatio_MarchMin2 = 2.2;
else
    WS_CRatio_MarchMin1 = WS_CRatio_MarchMin;
end

%WS_CRatio w/ ATT Boosted first hit.
if WS_First_CRatio_MarchMin < 0
    WS_First_CRatio_MarchMin = 0;
end
if WS_First_CRatio_MarchMin > 2
    WS_First_CRatio_MarchMin1 = 2;
else
    WS_First_CRatio_MarchMin1 = WS_First_CRatio_MarchMin;
end
if WS_First_CRatio_MarchMin > 2.2
    WS_First_CRatio_MarchMin2 = 2.2;
else
    WS_First_CRatio_MarchMin2 = WS_First_CRatio_MarchMin;
end

%Case 2A: 1Hander
if CRatio_MarchMin1 < 0.5
    fMax_1Hand_MarchMin = 0.4 + 1.2*CRatio_MarchMin1;
elseif CRatio_MarchMin1 <= 5/6
    fMax_1Hand_MarchMin = 1;
elseif CRatio_MarchMin1 < 2
    fMax_1Hand_MarchMin = 1.2*CRatio_MarchMin1;
elseif CRatio_MarchMin1 == 2
    fMax_1Hand_MarchMin = 1.2*CRatio_MarchMin1 + 0.05;
end

fMax_1Hand_MarchMin_Crit = (fMax_1Hand_MarchMin+1);
if fMax_1Hand_MarchMin_Crit > 3
    fMax_1Hand_MarchMin_Crit = 3;
end

fMax_1Hand_MarchMin_Crit = fMax_1Hand_MarchMin_Crit * 1.05;
fMax_1Hand_MarchMin = fMax_1Hand_MarchMin * 1.05;

if CRatio_MarchMin1 < 1.25
    fMin_1Hand_MarchMin = -0.5 + 1.2*CRatio_MarchMin1;
elseif 1.25 < CRatio_MarchMin1 <= 1.5
    fMin_1Hand_MarchMin = 1;
elseif 1.5 < CRatio_MarchMin1 < 2
    fMin_1Hand_MarchMin = -0.8+1.2*CRatio_MarchMin1;
elseif CRatio_MarchMin1 == 2
    fMin_1Hand_MarchMin = -0.82+1.2*CRatio_MarchMin1;
end
if fMin_1Hand_MarchMin < 0
    fMin_1Hand_MarchMin = 0;
end

fMin_1Hand_MarchMin_Crit = fMin_1Hand_MarchMin+1;

%Case 2B: 2Hander - note that unlike 1Hand I am not 100% certain on pDIF
%numbers.

if CRatio_MarchMin2 <= 0.5
    fMax_2Hand_MarchMin = 0.4 + 1.2*CRatio_MarchMin2;
elseif CRatio_MarchMin2 <= 5/6
    fMax_2Hand_MarchMin = 1;
elseif CRatio_MarchMin2 < 2.2
    fMax_2Hand_MarchMin = 1.2*CRatio_MarchMin2;
elseif CRatio_MarchMin2 == 2.2
    fMax_2Hand_MarchMin = 1.2*CRatio_MarchMin2 + 0.05;
end

fMax_2Hand_MarchMin_Crit = (fMax_2Hand_MarchMin+1);
if fMax_2Hand_MarchMin_Crit > 3
    fMax_2Hand_MarchMin_Crit = 3;
end

fMax_2Hand_MarchMin_Crit = fMax_2Hand_MarchMin_Crit * 1.05;
fMax_2Hand_MarchMin = fMax_2Hand_MarchMin*1.05;

if CRatio_MarchMin2 <= 1.25
    fMin_2Hand_MarchMin = -0.5 + 1.2*CRatio_MarchMin2;
elseif CRatio_MarchMin2 <= 1.5;
    fMin_2Hand_MarchMin = 1;
elseif CRatio_MarchMin2 < 2.2
    fMin_2Hand_MarchMin = -0.8+1.2*CRatio_MarchMin2;
elseif CRatio_MarchMin2 == 2.2
    fMin_2Hand_MarchMin = -0.8+1.2*CRatio_MarchMin2;
end

if fMin_2Hand_MarchMin < 0
    fMin_2Hand_MarchMin = 0;
end
fMin_2Hand_MarchMin_Crit = fMin_2Hand_MarchMin+1;

%Case 2C: 1Hander WS

if WS_CRatio_MarchMin1 < 0.5
    WS_fMax_1Hand_MarchMin = 0.4 + 1.2*WS_CRatio_MarchMin1;
elseif WS_CRatio_MarchMin1 <= 5/6
    WS_fMax_1Hand_MarchMin = 1;
elseif WS_CRatio_MarchMin1 < 2
    WS_fMax_1Hand_MarchMin = 1.2*WS_CRatio_MarchMin1;
elseif WS_CRatio_MarchMin1 == 2
    WS_fMax_1Hand_MarchMin = 1.2*WS_CRatio_MarchMin1 + 0.05;
end

WS_fMax_1Hand_MarchMin_Crit = (WS_fMax_1Hand_MarchMin+1);
if WS_fMax_1Hand_MarchMin_Crit > 3
    WS_fMax_1Hand_MarchMin_Crit = 3;
end

WS_fMax_1Hand_MarchMin_Crit = WS_fMax_1Hand_MarchMin_Crit * 1.05;
WS_fMax_1Hand_MarchMin = WS_fMax_1Hand_MarchMin * 1.05;

if WS_CRatio_MarchMin1 < 1.25
    WS_fMin_1Hand_MarchMin = -0.5 + 1.2*WS_CRatio_MarchMin1;
elseif 1.25 < WS_CRatio_MarchMin1 <= 1.5
    WS_fMin_1Hand_MarchMin = 1;
elseif 1.5 < WS_CRatio_MarchMin1 < 2
    WS_fMin_1Hand_MarchMin = -0.8+1.2*WS_CRatio_MarchMin1;
elseif WS_CRatio_MarchMin1 == 2
    WS_fMin_1Hand_MarchMin = -0.82+1.2*WS_CRatio_MarchMin1;
end
if WS_fMin_1Hand_MarchMin < 0
    WS_fMin_1Hand_MarchMin = 0;
end

WS_fMin_1Hand_MarchMin_Crit = WS_fMin_1Hand_MarchMin+1;

%Case 2D: 2Hander WS

if WS_CRatio_MarchMin2 <= 0.5
    WS_fMax_2Hand_MarchMin = 0.4 + 1.2*WS_CRatio_MarchMin2;
elseif WS_CRatio_MarchMin2 <= 5/6
    WS_fMax_2Hand_MarchMin = 1;
elseif WS_CRatio_MarchMin2 < 2.2
    WS_fMax_2Hand_MarchMin = 1.2*WS_CRatio_MarchMin2;
elseif WS_CRatio_MarchMin2 == 2.2
    WS_fMax_2Hand_MarchMin = 1.2*WS_CRatio_MarchMin2 + 0.05;
end

WS_fMax_2Hand_MarchMin_Crit = (WS_fMax_2Hand_MarchMin+1);
if WS_fMax_2Hand_MarchMin_Crit > 3
    WS_fMax_2Hand_MarchMin_Crit = 3;
end

WS_fMax_2Hand_MarchMin_Crit = WS_fMax_2Hand_MarchMin_Crit * 1.05;
WS_fMax_2Hand_MarchMin = WS_fMax_2Hand_MarchMin*1.05;

if WS_CRatio_MarchMin2 <= 1.25
    WS_fMin_2Hand_MarchMin = -0.5 + 1.2*WS_CRatio_MarchMin2;
elseif WS_CRatio_MarchMin2 <= 1.5;
    WS_fMin_2Hand_MarchMin = 1;
elseif WS_CRatio_MarchMin2 < 2.2
    WS_fMin_2Hand_MarchMin = -0.8+1.2*WS_CRatio_MarchMin2;
elseif WS_CRatio_MarchMin2 == 2.2
    WS_fMin_2Hand_MarchMin = -0.8+1.2*WS_CRatio_MarchMin2;
end

if WS_fMin_2Hand_MarchMin < 0
    WS_fMin_2Hand_MarchMin = 0;
end
WS_fMin_2Hand_MarchMin_Crit = WS_fMin_2Hand_MarchMin+1;

%Case 2E: 1Hander WS with ATT Boost

if WS_First_CRatio_MarchMin1 < 0.5
    WS_First_fMax_1Hand_MarchMin = 0.4 + 1.2*WS_First_CRatio_MarchMin1;
elseif WS_First_CRatio_MarchMin1 <= 5/6
    WS_First_fMax_1Hand_MarchMin = 1;
elseif WS_First_CRatio_MarchMin1 < 2
    WS_First_fMax_1Hand_MarchMin = 1.2*WS_First_CRatio_MarchMin1;
elseif WS_First_CRatio_MarchMin1 == 2
    WS_First_fMax_1Hand_MarchMin = 1.2*WS_First_CRatio_MarchMin1 + 0.05;
end

WS_First_fMax_1Hand_MarchMin_Crit = (WS_First_fMax_1Hand_MarchMin+1);
if WS_First_fMax_1Hand_MarchMin_Crit > 3
    WS_First_fMax_1Hand_MarchMin_Crit = 3;
end

WS_First_fMax_1Hand_MarchMin_Crit = WS_First_fMax_1Hand_MarchMin_Crit * 1.05;
WS_First_fMax_1Hand_MarchMin = WS_First_fMax_1Hand_MarchMin * 1.05;

if WS_First_CRatio_MarchMin1 < 1.25
    WS_First_fMin_1Hand_MarchMin = -0.5 + 1.2*WS_First_CRatio_MarchMin1;
elseif 1.25 < WS_First_CRatio_MarchMin1 <= 1.5
    WS_First_fMin_1Hand_MarchMin = 1;
elseif 1.5 < WS_First_CRatio_MarchMin1 < 2
    WS_First_fMin_1Hand_MarchMin = -0.8+1.2*WS_First_CRatio_MarchMin1;
elseif WS_First_CRatio_MarchMin1 == 2
    WS_First_fMin_1Hand_MarchMin = -0.82+1.2*WS_First_CRatio_MarchMin1;
end
if WS_First_fMin_1Hand_MarchMin < 0
    WS_First_fMin_1Hand_MarchMin = 0;
end

WS_First_fMin_1Hand_MarchMin_Crit = WS_First_fMin_1Hand_MarchMin+1;

%Case 2F: 2Hander WS with ATT Boost

if WS_First_CRatio_MarchMin2 <= 0.5
    WS_First_fMax_2Hand_MarchMin = 0.4 + 1.2*WS_First_CRatio_MarchMin2;
elseif WS_First_CRatio_MarchMin2 <= 5/6
    WS_First_fMax_2Hand_MarchMin = 1;
elseif WS_First_CRatio_MarchMin2 < 2.2
    WS_First_fMax_2Hand_MarchMin = 1.2*WS_First_CRatio_MarchMin2;
elseif WS_First_CRatio_MarchMin2 == 2.2
    WS_First_fMax_2Hand_MarchMin = 1.2*WS_First_CRatio_MarchMin2 + 0.05;
end

WS_First_fMax_2Hand_MarchMin_Crit = (WS_First_fMax_2Hand_MarchMin+1);
if WS_First_fMax_2Hand_MarchMin_Crit > 3
    WS_First_fMax_2Hand_MarchMin_Crit = 3;
end

WS_First_fMax_2Hand_MarchMin_Crit = WS_First_fMax_2Hand_MarchMin_Crit * 1.05;
WS_First_fMax_2Hand_MarchMin = WS_First_fMax_2Hand_MarchMin*1.05;

if WS_First_CRatio_MarchMin2 <= 1.25
    WS_First_fMin_2Hand_MarchMin = -0.5 + 1.2*WS_First_CRatio_MarchMin2;
elseif WS_First_CRatio_MarchMin2 <= 1.5;
    WS_First_fMin_2Hand_MarchMin = 1;
elseif WS_First_CRatio_MarchMin2 < 2.2
    WS_First_fMin_2Hand_MarchMin = -0.8+1.2*WS_First_CRatio_MarchMin2;
elseif WS_First_CRatio_MarchMin2 == 2.2
    WS_First_fMin_2Hand_MarchMin = -0.8+1.2*WS_First_CRatio_MarchMin2;
end

if WS_First_fMin_2Hand_MarchMin < 0
    WS_First_fMin_2Hand_MarchMin = 0;
end
WS_First_fMin_2Hand_MarchMin_Crit = WS_First_fMin_2Hand_MarchMin+1;

Haste_MarchMin = Haste_Gear + Haste_Magic + Haste_JA; %Haste Total
if Haste_MarchMin > 0.8
    Haste_MarchMin = 0.8;
end

Round_Rate = 1/(1-Haste_MarchMin);
Time_To_100 = ((Delay/Round_Rate)*Hits_to_WS/(1+DA_Rate) + 120)/60;

%Going to make an assumption pdif is evenly distributed in the range min ->
%max.
pDIF_1Hand_MarchMin_avg = (fMin_1Hand_MarchMin+fMax_1Hand_MarchMin)/2;
pDIF_2Hand_MarchMin_avg = (fMin_2Hand_MarchMin+fMax_2Hand_MarchMin)/2;

pDIF_1Hand_MarchMin_avg_Crit = (fMin_1Hand_MarchMin_Crit+fMax_1Hand_MarchMin_Crit)/2;
pDIF_2Hand_MarchMin_avg_Crit = (fMin_2Hand_MarchMin_Crit+fMax_2Hand_MarchMin_Crit)/2;

pDIF_1Hand_MarchMin_avg_withCrit = ((1-Crit_Rate)*(pDIF_1Hand_MarchMin_avg)+(Crit_Rate)*(pDIF_1Hand_MarchMin_avg_Crit));
pDIF_2Hand_MarchMin_avg_withCrit = ((1-Crit_Rate)*(pDIF_2Hand_MarchMin_avg)+(Crit_Rate)*(pDIF_2Hand_MarchMin_avg_Crit));

WS_pDIF_1Hand_MarchMin_avg = (WS_fMin_1Hand_MarchMin+WS_fMax_1Hand_MarchMin)/2;
WS_pDIF_2Hand_MarchMin_avg = (WS_fMin_2Hand_MarchMin+WS_fMax_2Hand_MarchMin)/2;

WS_pDIF_1Hand_MarchMin_avg_Crit = (WS_fMin_1Hand_MarchMin_Crit+WS_fMax_1Hand_MarchMin_Crit)/2;
WS_pDIF_2Hand_MarchMin_avg_Crit = (WS_fMin_2Hand_MarchMin_Crit+WS_fMax_2Hand_MarchMin_Crit)/2;

WS_pDIF_1Hand_MarchMin_avg_withCrit = ((1-WS_Crit_Rate)*(WS_pDIF_1Hand_MarchMin_avg)+(WS_Crit_Rate)*(WS_pDIF_1Hand_MarchMin_avg_Crit));
WS_pDIF_2Hand_MarchMin_avg_withCrit = ((1-WS_Crit_Rate)*(WS_pDIF_2Hand_MarchMin_avg)+(WS_Crit_Rate)*(WS_pDIF_2Hand_MarchMin_avg_Crit));

WS_First_pDIF_1Hand_MarchMin_avg = (WS_First_fMin_1Hand_MarchMin+WS_First_fMax_1Hand_MarchMin)/2;
WS_First_pDIF_2Hand_MarchMin_avg = (WS_First_fMin_2Hand_MarchMin+WS_First_fMax_2Hand_MarchMin)/2;

WS_First_pDIF_1Hand_MarchMin_avg_Crit = (WS_First_fMin_1Hand_MarchMin_Crit+WS_First_fMax_1Hand_MarchMin_Crit)/2;
WS_First_pDIF_2Hand_MarchMin_avg_Crit = (WS_First_fMin_2Hand_MarchMin_Crit+WS_First_fMax_2Hand_MarchMin_Crit)/2;

WS_First_pDIF_1Hand_MarchMin_avg_withCrit = ((1-WS_First_Crit_Rate)*(WS_First_pDIF_1Hand_MarchMin_avg)+(WS_First_Crit_Rate)*(WS_First_pDIF_1Hand_MarchMin_avg_Crit));
WS_First_pDIF_2Hand_MarchMin_avg_withCrit = ((1-WS_First_Crit_Rate)*(WS_First_pDIF_2Hand_MarchMin_avg)+(WS_First_Crit_Rate)*(WS_First_pDIF_2Hand_MarchMin_avg_Crit));

Damage_To_100_1Hand_MarchMin = Hits_to_WS*WD_TP*pDIF_1Hand_MarchMin_avg_withCrit;
Damage_To_100_2Hand_MarchMin = Hits_to_WS*WD_TP*pDIF_2Hand_MarchMin_avg_withCrit;

if WS_Att_Boost == 1 %I've replaced pDIF averages on the first hit with the highest possible average here - as magic numbers. Sorry!
    if WS_Crits == 0
        WS_Damage_1Hand_MarchMin = (WD_WS)*WS_fTP*WS_First_pDIF_1Hand_MarchMin_avg + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_1Hand_MarchMin_avg;
        WS_Damage_2Hand_MarchMin = (WD_WS)*WS_fTP*WS_First_pDIF_2Hand_MarchMin_avg + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_2Hand_MarchMin_avg;
    else
        WS_Damage_1Hand_MarchMin = (WD_WS)*WS_fTP*WS_First_pDIF_1Hand_MarchMin_avg_withCrit + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_1Hand_MarchMin_avg_withCrit;
        WS_Damage_2Hand_MarchMin = (WD_WS)*WS_fTP*WS_First_pDIF_2Hand_MarchMin_avg_withCrit + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_2Hand_MarchMin_avg_withCrit;
    end
else
    if WS_Crits == 1
        WS_Damage_1Hand_MarchMin = (WD_WS)*WS_fTP*WS_pDIF_1Hand_MarchMin_avg_withCrit + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_1Hand_MarchMin_avg_withCrit;
        WS_Damage_2Hand_MarchMin = (WD_WS)*WS_fTP*WS_pDIF_2Hand_MarchMin_avg_withCrit + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*WS_pDIF_2Hand_MarchMin_avg_withCrit;
    else
        WS_Damage_1Hand_MarchMin = (WD_WS)*WS_fTP*(WS_pDIF_1Hand_MarchMin_avg) + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*(WS_pDIF_1Hand_MarchMin_avg);
        WS_Damage_2Hand_MarchMin = (WD_WS)*WS_fTP*(WS_pDIF_2Hand_MarchMin_avg) + (Hits_on_WS+WS_DA_Rate-1)*WD_WS_Extra*(WS_pDIF_2Hand_MarchMin_avg);
    end
end

DPS_1Hand_MarchMin = (WS_Damage_1Hand_MarchMin+Damage_To_100_1Hand_MarchMin)/Time_To_100
DPS_2Hand_MarchMin = (WS_Damage_2Hand_MarchMin+Damage_To_100_2Hand_MarchMin)/Time_To_100