MinaCalc.h

#pragma once
#include "../Models/NoteData/NoteDataStructures.h"
#include <string>
#include <vector>
#include <array>
#include <memory>
#include <unordered_map>
 
// For internal, must be preprocessor defined
#if defined(MINADLL_COMPILE) && defined(_WIN32)
#define MINACALC_API __declspec(dllexport)
#endif
 
// For Stepmania
#ifndef MINACALC_API
#define MINACALC_API
#endif
 
using MinaSD = std::vector<std::vector<float>>;
 
class Calc;
struct Bazoinkazoink;
 
static constexpr int default_interval_count = 1000;
 
static constexpr int max_intervals = 100000;
 
static constexpr int max_rows_for_single_interval = 50;
 
enum hands
{
    left_hand,
    right_hand,
    num_hands,
};
 
static constexpr hands both_hands[num_hands] = { left_hand, right_hand };
 
struct RowInfo
{
    unsigned row_notes = 0U;
 
    int row_count = 0;
 
    std::array<int, num_hands> hand_counts = { 0, 0 };
 
    float row_time = 0.F;
};
 
class Calc
{
  public:
    auto CalcMain(const std::vector<NoteInfo>& NoteInfo,
                  float music_rate,
                  float score_goal) -> std::vector<float>;
 
    bool debugmode = false;
 
    bool ssr = true;
 
    bool loadparams = false;
 
    unsigned keycount = 4;
    std::array<unsigned, num_hands> hand_col_masks = { 0U, 0U };
    std::vector<unsigned> col_masks{};
    std::shared_ptr<Bazoinkazoink> ulbu_in_charge;
 
  private:
    void InitializeKeycountLogic();
    std::unordered_map<unsigned, std::shared_ptr<Bazoinkazoink>> ulbu_collective{};
 
    auto InitializeHands(
      const std::vector<NoteInfo>& NoteInfo,
      float music_rate,
      float offset) -> bool;
 
    auto Chisel(float player_skill,
                float resolution,
                float score_goal,
                Skillset ss,
                bool stamina,
                bool debugoutput = false) -> float;
 
    static inline void InitAdjDiff(
      Calc& calc,
      const int& hand);
 
  public:
    Calc() { resize_interval_dependent_vectors(default_interval_count); }
    
    std::vector<std::array<RowInfo, max_rows_for_single_interval>>
      adj_ni;
 
    std::vector<int> itv_size{};
 
    std::array<std::vector<int>, num_hands> itv_points{};
 
    std::array<std::array<std::vector<float>, NUM_CalcPatternMod>,
               num_hands>
      pmod_vals{};
 
    std::array<std::array<std::vector<float>, NUM_CalcDiffValue>,
               num_hands>
      init_base_diff_vals{};
 
    std::array<std::array<std::vector<float>, NUM_Skillset>,
               num_hands>
      base_adj_diff{};
 
    std::array<std::array<std::vector<float>, NUM_Skillset>,
               num_hands>
      base_diff_for_stam_mod{};
 
    std::vector<float> stam_adj_diff{};
 
    std::array<std::vector<std::pair<float, float>>, num_hands> jack_diff{};
 
    // number of jacks by hand for intervals
    // std::array<std::vector<int>, num_hands>
    // itv_jack_diff_size{};
 
    std::array<std::vector<float>, num_hands> jack_loss{};
 
    std::array<std::vector<float>, num_hands> jack_stam_stuff{};
 
    std::array<float, max_rows_for_single_interval> tc_static{};
 
    std::array<float, max_rows_for_single_interval> cj_static{};
 
    int numitv = 0;
 
    float MaxPoints = 0;
 
    float grindscaler = 1.F;
 
    std::array<std::vector<std::vector<std::vector<float>>>, num_hands>
      debugValues{};
    std::array<std::array<std::vector<float>, NUM_Skillset>, num_hands> debugMSD{};
    std::array<std::array<std::vector<float>, NUM_Skillset>, num_hands> debugPtLoss{};
    std::array<std::array<std::vector<float>, NUM_Skillset>, num_hands> debugTotalPatternMod{};
 
    std::array<std::array<std::vector<std::pair<float, float>>, 2>, num_hands>
      debugMovingWindowCV{};
 
    std::array<std::vector<std::array<float, 4>>, num_hands> debugTechVals{};
 
    void resize_interval_dependent_vectors(size_t amt)
    {
        // there isn't a real need to make our vectors smaller
        if (amt < adj_ni.size())
            return;
        
        // grow each vector
        // resize is used to construct defaults, the space should be used immediately
        adj_ni.resize(amt);
        itv_size.resize(amt);
        for (auto& v : itv_points)
            v.resize(amt);
        for (auto& a : pmod_vals)
            for (auto& v : a)
                v.resize(amt);
        for (auto& a : init_base_diff_vals)
            for (auto& v : a)
                v.resize(amt);
        for (auto& a : base_adj_diff)
            for (auto& v : a)
                v.resize(amt);
        for (auto& a : base_diff_for_stam_mod)
            for (auto& v : a)
                v.resize(amt);
        stam_adj_diff.resize(amt);
    }
};
 
MINACALC_API auto
MinaSDCalc(const std::vector<NoteInfo>& NoteInfo,
           float musicrate,
           float goal,
           const unsigned keycount,
           Calc* calc) -> std::vector<float>;
MINACALC_API auto
MinaSDCalc(const std::vector<NoteInfo>& NoteInfo,
           const unsigned keycount,
           Calc* calc) -> MinaSD;
MINACALC_API void
MinaSDCalcDebug(
  const std::vector<NoteInfo>& NoteInfo,
  float musicrate,
  float goal,
  const unsigned keycount,
  std::vector<std::vector<std::vector<std::vector<float>>>>& handInfo,
  std::vector<std::string>& debugstrings,
  Calc& calc);
MINACALC_API auto
GetCalcVersion() -> int;