split initadjdiff logic into keymodes

src/Etterna/MinaCalc/MinaCalc.cpp

@@ -830,59 +830,14 @@ Calc::InitAdjDiff(Calc& calc, const int& hand)
 			// start diff values at adjusted nps base
 			*adj_diff = adj_npsbase;
 			*stam_base = adj_npsbase;
-			switch (ss) {
-				// do funky special case stuff here
-				case Skill_Stream:
-					break;
-
-				/* test calculating stam for js/hs on max js/hs diff, also we
-				 * want hs to count against js so they are mutually exclusive,
-				 * don't know how this functionally interacts with the stam base
-				 * stuff, but it might be one reason why js is more problematic
-				 * than hs? */
-				case Skill_Jumpstream: {
-					*adj_diff /= max<float>(calc.pmod_vals.at(hand).at(HS).at(i), 1.F);
-					*adj_diff /=
-					  fastsqrt(calc.pmod_vals.at(hand).at(OHJumpMod).at(i) * 0.95F);
-
-					auto a = *adj_diff;
-					auto b = calc.init_base_diff_vals.at(hand).at(NPSBase).at(i) *
-							 pmod_product_cur_interval[Skill_Handstream];
-					*stam_base = max<float>(a, b);
-				} break;
-				case Skill_Handstream: {
-
-					// adj_diff /=
-					// fastsqrt(doot.at(hi).at(OHJump).at(i));
-					auto a = adj_npsbase;
-					auto b = calc.init_base_diff_vals.at(hand).at(NPSBase).at(i) *
-							 pmod_product_cur_interval[Skill_Jumpstream];
-					*stam_base = max<float>(a, b);
-				} break;
-				case Skill_JackSpeed:
-					break;
-				case Skill_Chordjack:
-					/*
-					*adj_diff =
-					  calc.init_base_diff_vals.at(hand).at(CJBase).at(i) *
-					  basescalers.at(Skill_Chordjack) *
-					  pmod_product_cur_interval[Skill_Chordjack];
-					// we leave stam_base alone here, still based on nps
-					*/
-					break;
-				case Skill_Technical:
-					*adj_diff =
-					  calc.init_base_diff_vals.at(hand).at(TechBase).at(i) *
-					  pmod_product_cur_interval.at(ss) * basescalers.at(ss) /
-					  max<float>(
-						fastpow(calc.pmod_vals.at(hand).at(CJ).at(i)+0.05F, 2.F),
-						1.F);
-					*adj_diff *=
-					  fastsqrt(calc.pmod_vals.at(hand).at(OHJumpMod).at(i));
-					break;
-				default:
-					break;
-			}
+
+			calc.ulbu_in_charge->adj_diff_func(i,
+											   hand,
+											   adj_diff,
+											   stam_base,
+											   adj_npsbase,
+											   ss,
+											   pmod_product_cur_interval);
 		}
 	}
 }

src/Etterna/MinaCalc/Ulbu.h

@@ -245,6 +245,72 @@ struct TheGreatBazoinkazoinkInTheSky : public Bazoinkazoink
 	{
 		return basescalers;
 	}
+	void adj_diff_func(
+	  const size_t& itv,
+	  const int& hand,
+	  float*& adj_diff,
+	  float*& stam_base,
+	  const float& adj_npsbase,
+	  const int& ss,
+	  std::array<float, NUM_Skillset>& pmod_product_cur_interval) override
+	{
+		switch (ss) {
+			case Skill_Stream:
+				break;
+			/* test calculating stam for js/hs on max js/hs diff, also we
+			 * want hs to count against js so they are mutually exclusive,
+             * don't know how this functionally interacts with the stam base
+			 * stuff, but it might be one reason why js is more problematic
+			 * than hs? */
+			case Skill_Jumpstream: {
+				*adj_diff /=
+				  std::max<float>(_calc.pmod_vals.at(hand).at(HS).at(itv), 1.F);
+				*adj_diff /= fastsqrt(
+				  _calc.pmod_vals.at(hand).at(OHJumpMod).at(itv) * 0.95F);
+
+				auto a = *adj_diff;
+				auto b =
+				  _calc.init_base_diff_vals.at(hand).at(NPSBase).at(itv) *
+				  pmod_product_cur_interval[Skill_Handstream];
+				*stam_base = std::max<float>(a, b);
+			} break;
+			case Skill_Handstream: {
+
+				// adj_diff /=
+				// fastsqrt(doot.at(hi).at(OHJump).at(i));
+				auto a = adj_npsbase;
+				auto b =
+				  _calc.init_base_diff_vals.at(hand).at(NPSBase).at(itv) *
+				  pmod_product_cur_interval[Skill_Jumpstream];
+				*stam_base = std::max<float>(a, b);
+			} break;
+			case Skill_JackSpeed:
+				break;
+			case Skill_Chordjack:
+				/*
+				 *adj_diff =
+				 * calc.init_base_diff_vals.at(hand).at(CJBase).at(i) *
+				 * basescalers.at(Skill_Chordjack) *
+				 * pmod_product_cur_interval[Skill_Chordjack];
+				 // we leave
+				 * stam_base alone here, still based on nps
+				 */
+				break;
+			case Skill_Technical:
+				*adj_diff =
+				  _calc.init_base_diff_vals.at(hand).at(TechBase).at(itv) *
+				  pmod_product_cur_interval.at(ss) * basescalers.at(ss) /
+				  std::max<float>(
+					fastpow(_calc.pmod_vals.at(hand).at(CJ).at(itv) + 0.05F,
+							2.F),
+					1.F);
+				*adj_diff *=
+				  fastsqrt(_calc.pmod_vals.at(hand).at(OHJumpMod).at(itv));
+				break;
+			default:
+				break;
+		}
+	}
 
 
 	void operator()() override

src/Etterna/MinaCalc/UlbuBase.h

@@ -67,6 +67,35 @@ struct Bazoinkazoink
 	{
 		return basescalers;
 	}
+	virtual void adj_diff_func(
+	  const size_t& itv,
+	  const int& hand,
+	  float*& adj_diff,
+	  float*& stam_base,
+	  const float& adj_npsbase,
+	  const int& ss,
+	  std::array<float, NUM_Skillset>& pmod_product_cur_interval)
+	{
+		switch (ss) {
+			case Skill_Stream:
+				break;
+			case Skill_Jumpstream: {
+			} break;
+			case Skill_Handstream: {
+			} break;
+			case Skill_JackSpeed:
+				break;
+			case Skill_Chordjack:
+				break;
+			case Skill_Technical:
+				*adj_diff =
+				  _calc.init_base_diff_vals.at(hand).at(TechBase).at(itv) *
+				  pmod_product_cur_interval.at(ss) * basescalers.at(ss);
+				break;
+			default:
+				break;
+		}
+	}
 
 	/// these are the base diffs which actually must be reset
 	/// between calc runs or else things break

src/Etterna/MinaCalc/UlbuSevenKey.h

@@ -60,6 +60,45 @@ struct TheSevenFootedBazoinkazoink : public Bazoinkazoink
 	{
 		return basescalers;
 	}
+	void adj_diff_func(
+	  const size_t& itv,
+	  const int& hand,
+	  float*& adj_diff,
+	  float*& stam_base,
+	  const float& adj_npsbase,
+	  const int& ss,
+	  std::array<float, NUM_Skillset>& pmod_product_cur_interval) override
+	{
+		switch (ss) {
+			case Skill_Stream:
+				break;
+			case Skill_Jumpstream: {
+				auto a = *adj_diff;
+				auto b =
+				  _calc.init_base_diff_vals.at(hand).at(NPSBase).at(itv) *
+				  pmod_product_cur_interval[Skill_Handstream];
+				*stam_base = std::max<float>(a, b);
+			} break;
+			case Skill_Handstream: {
+				auto a = adj_npsbase;
+				auto b =
+				  _calc.init_base_diff_vals.at(hand).at(NPSBase).at(itv) *
+				  pmod_product_cur_interval[Skill_Jumpstream];
+				*stam_base = std::max<float>(a, b);
+			} break;
+			case Skill_JackSpeed:
+				break;
+			case Skill_Chordjack:
+				break;
+			case Skill_Technical:
+				*adj_diff =
+				  _calc.init_base_diff_vals.at(hand).at(TechBase).at(itv) *
+				  pmod_product_cur_interval.at(ss) * basescalers.at(ss);
+				break;
+			default:
+				break;
+		}
+	}
 
 	void operator()() override
 	{