revert cj again to cjbase instead of msbase | 479

lol i guess
approx equivalent to calc 396

Author: poco0317

src/Etterna/MinaCalc/Agnostic/HA_PatternMods/CJ.h

@@ -18,17 +18,17 @@ struct CJMod
 
 	float total_prop_min = min_mod;
 	float total_prop_max = max_mod;
-	float total_prop_scaler = 1.5F;
+	float total_prop_scaler = 5.428F;
 
-	float jack_base = 1.F;
+	float jack_base = 2.F;
 	float jack_min = 0.625F;
 	float jack_max = 1.F;
 	float jack_scaler = 1.F;
 
-	float not_jack_pool = 1.15F;
-	float not_jack_min = 0.9F;
+	float not_jack_pool = 1.2F;
+	float not_jack_min = 0.4F;
 	float not_jack_max = 1.F;
-	float not_jack_scaler = 1.75F;
+	float not_jack_scaler = 1.F;
 
 	float vibro_flag = 1.F;
 	float decay_factor = 0.1F;

src/Etterna/MinaCalc/Agnostic/HA_PatternMods/CJDensity.h

@@ -12,14 +12,14 @@ struct CJDensityMod
 
 #pragma region params
 
-	float min_mod = 0.85F;
-	float max_mod = 1.15F;
+	float min_mod = 0.98F;
+	float max_mod = 1.08F;
 	float base = 0.F;
 
 	float single_scaler = 1.F;
-	float jump_scaler = 1.6F;
+	float jump_scaler = 1.25F;
 	float hand_scaler = 0.9F;
-	float quad_scaler = 0.7F;
+	float quad_scaler = 1.15F;
 
 	const std::vector<std::pair<std::string, float*>> _params{
 		{ "min_mod", &min_mod },

src/Etterna/MinaCalc/Dependent/HD_PatternMods/CJOHAnchor.h

@@ -14,7 +14,7 @@ struct CJOHAnchorMod
 #pragma region params
 
 	float min_mod = 1.F;
-	float max_mod = 1.2F;
+	float max_mod = 1.F;
 
 	float anchor_len_weight = 1.F;
 	float len_scaler = 0.175F;

src/Etterna/MinaCalc/Dependent/HD_PatternMods/CJOHJ.h

@@ -13,7 +13,7 @@ struct CJOHJumpMod
 
 #pragma region params
 
-	float min_mod = 0.5F;
+	float min_mod = 1.F;
 	float max_mod = 1.F;
 
 	float prop_pool = 1.4F;

src/Etterna/MinaCalc/MinaCalc.cpp

@@ -683,7 +683,7 @@ Calc::Chisel(const float player_skill,
 				for (auto i = 0; i < numitv; ++i) {
 					debugTotalPatternMod.at(hand).at(ss).at(i) =
 					  base_adj_diff.at(hand).at(ss).at(i) /
-					  init_base_diff_vals.at(hand)[MSBase].at(i);
+					  init_base_diff_vals.at(hand)[CJBase].at(i);
 				}
 			} else {
 				// everything else uses nps base
@@ -780,8 +780,8 @@ Calc::InitAdjDiff(Calc& calc, const int& hand)
 	  // chordjack
 	  {
 		CJ,
-		// CJDensity,
-		CJOHJump, // SQRTD BELOW
+		CJDensity,
+		CJOHJump,
 		CJOHAnchor,
 		VOHTrill,
 		// WideRangeAnchor,
@@ -887,7 +887,7 @@ Calc::InitAdjDiff(Calc& calc, const int& hand)
 					break;
 				case Skill_Chordjack:
 					*adj_diff =
-					  calc.init_base_diff_vals.at(hand).at(MSBase).at(i) *
+					  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
@@ -1004,7 +1004,7 @@ MinaSDCalcDebug(
 	}
 }
 
-int mina_calc_version = 478;
+int mina_calc_version = 479;
 auto
 GetCalcVersion() -> int
 {

src/Etterna/MinaCalc/MinaCalc.h

@@ -235,6 +235,11 @@ class Calc
 	*/
 	std::array<float, max_rows_for_single_interval> tc_static{};
 
+	/** Base Chordjack difficulty per row of current interval being scanned.
+	* See struct ceejay for the intense details ...
+	*/
+	std::array<float, max_rows_for_single_interval> cj_static{};
+
 	/// Total number of intervals for the current file/rate (one per half second)
 	int numitv = 0;
 

src/Etterna/MinaCalc/SequencedBaseDiffCalc.h

@@ -215,6 +215,133 @@ struct nps
 	}
 };
 
+struct ceejay
+{
+	void update_flags(const unsigned& row_notes, const int& row_count)
+	{
+		is_cj = last_row_count > 1 && row_count > 1;
+		was_cj = last_row_count > 1 && last_last_row_count > 1;
+
+		is_scj = (row_count == 1 && last_row_count > 1) &&
+				 ((row_notes & last_row_notes) != 0u);
+
+		is_at_least_3_note_anch =
+		  ((row_notes & last_row_notes) & last_last_row_notes) != 0u;
+
+		last_last_row_count = last_row_count;
+		last_row_count = row_count;
+
+		last_last_row_notes = last_row_notes;
+		last_row_notes = row_notes;
+
+		last_was_3_note_anch = is_at_least_3_note_anch;
+	}
+
+	void advance_base(const float& any_ms, Calc& calc)
+	{
+		if (row_counter >= max_rows_for_single_interval) {
+			{
+				{
+					return;
+				}
+			}
+		}
+
+		// pushing back ms values, so multiply to nerf
+		float pewpew = 3.F;
+
+		if (is_at_least_3_note_anch && last_was_3_note_anch) {
+			// biggy boy anchors and beyond
+			pewpew = 1.F;
+		} else if (is_at_least_3_note_anch) {
+			// big boy anchors
+			pewpew = 1.F;
+		} else {
+			// single note
+			if (!is_cj) {
+				if (is_scj) {
+					// was cj a little bit ago..
+					if (was_cj) {
+						// single note jack with 2 chords behind it
+						pewpew = 1.25F;
+					} else {
+						// single note, not a jack, 2 chords behind
+						// it
+						pewpew = 1.5F;
+					}
+				}
+			} else {
+				// actual cj
+				if (was_cj) {
+					// cj now and was cj before, but not necessarily
+					// with strong anchors
+					pewpew = 1.15F;
+				} else {
+					// cj now but wasn't even cj before
+					pewpew = 1.25F;
+				}
+			}
+		}
+
+		// single note streams / regular jacks should retain the 3x
+		// multiplier
+
+		calc.cj_static.at(row_counter) = std::max(75.F, any_ms * pewpew);
+		++row_counter;
+	}
+
+	// final output difficulty for this interval
+	auto get_itv_diff(Calc& calc) const -> float
+	{
+		if (row_counter == 0) {
+			return 0.F;
+		}
+
+		float ms_total = 0.F;
+		for (int i = 0; i < row_counter; ++i) {
+			{
+				{
+					ms_total += calc.cj_static.at(i);
+				}
+			}
+		}
+
+		float ms_mean = ms_total / static_cast<float>(row_counter);
+		return ms_to_scaled_nps(ms_mean);
+	}
+
+	void interval_end() { row_counter = 0; }
+	void full_reset()
+	{
+		is_cj = false;
+		was_cj = false;
+		is_scj = false;
+		is_at_least_3_note_anch = false;
+		last_was_3_note_anch = false;
+
+		last_row_count = 0;
+		last_last_row_count = 0;
+
+		last_row_notes = 0U;
+		last_last_row_notes = 0U;
+	}
+
+  private:
+	int row_counter = 0;
+
+	bool is_cj = false;
+	bool was_cj = false;
+	bool is_scj = false;
+	bool is_at_least_3_note_anch = false;
+	bool last_was_3_note_anch = false;
+
+	int last_row_count = 0;
+	int last_last_row_count = 0;
+
+	unsigned last_row_notes = 0U;
+	unsigned last_last_row_notes = 0U;
+};
+
 struct techyo
 {
 	// if this looks ridiculous, that's because it is
@@ -342,8 +469,17 @@ struct diffz
 {
 	nps _nps;
 	techyo _tc;
+	ceejay _cj;
 
-	void interval_end() { _tc.interval_end(); }
+	void interval_end()
+	{
+		_tc.interval_end();
+		_cj.interval_end();
+	}
 
-	void full_reset() { interval_end(); }
+	void full_reset()
+	{
+		interval_end();
+		_cj.full_reset();
+	}
 };

src/Etterna/MinaCalc/Ulbu.h

@@ -339,7 +339,8 @@ struct TheGreatBazoinkazoinkInTheSky
 	void update_sequenced_base_diffs(const col_type& ct,
 									 const int& itv,
 									 const int& jack_counter,
-									 const float& row_time)
+									 const float& row_time,
+									 const float& any_ms)
 	{
 		auto thing =
 		  std::pair{ row_time,
@@ -352,6 +353,9 @@ struct TheGreatBazoinkazoinkInTheSky
 		// _between either column_ for _this row_
 		_calc.jack_diff.at(hand).push_back(thing);
 
+		// chordjack updates
+		_diffz._cj.advance_base(any_ms, _calc);
+
 		// tech updates with a convoluted mess of garbage
 		_diffz._tc.advance_base(_seq, ct, _calc);
 		_diffz._tc.advance_rm_comp(_rm.get_highest_anchor_difficulty());
@@ -363,6 +367,9 @@ struct TheGreatBazoinkazoinkInTheSky
 		// loop _calc->soap.at(hand)[JackBase].at(itv) =
 		// _diffz._jk.get_itv_diff();
 
+		_calc.init_base_diff_vals.at(hand)[CJBase].at(itv) =
+		  _diffz._cj.get_itv_diff(_calc);
+
 		// kinda jank but includes a weighted average vs nps base to prevent
 		// really silly stuff from becoming outliers
 		_calc.init_base_diff_vals.at(hand)[TechBase].at(itv) =
@@ -417,6 +424,9 @@ struct TheGreatBazoinkazoinkInTheSky
 
 					ct = determine_col_type(row_notes, ids);
 
+					// cj must always update
+					_diffz._cj.update_flags(row_notes, row_count);
+
 					// handle any special cases that need to be executed on
 					// empty rows for this hand here before moving on, aside
 					// from whatever is in this block _nothing_ else should
@@ -450,7 +460,7 @@ struct TheGreatBazoinkazoinkInTheSky
 					 * (jack might not be for the moment actually) nps base
 					 * is still calculated in the old way */
 					update_sequenced_base_diffs(
-					  ct, itv, jack_counter, row_time);
+					  ct, itv, jack_counter, row_time, any_ms);
 					++jack_counter;
 
 					// only ohj uses this atm (and probably into the future)

src/Etterna/Models/Misc/GameConstantsAndTypes.cpp

@@ -262,7 +262,7 @@ LuaXType(CalcPatternMod);
 static const char* CalcDiffValueNames[] = { "NPSBase",
 											"MSBase",
 											// "JackBase",
-											// "CJBase",
+											"CJBase",
 											"TechBase",
 											"RMABase",
 											"MSD" };

src/Etterna/Models/NoteData/NoteDataStructures.h

@@ -82,7 +82,7 @@ enum CalcDiffValue
 	NPSBase,
 	MSBase,
 	// JackBase,
-	// CJBase,
+	CJBase,
 	TechBase,
 	RMABase,
 	MSD,