RankingCriteriaChecker.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import json\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#MODIFY THE CODE BELOW ACCORDING TO INSTRUCTIONS\n",
    "#Change the following variable to 1 if there is a lawless difficulty, or 0 if there is not a lawless difficulty\n",
    "lawless = 0\n",
    "#Change the following integer to an integer from 0-4 with 0 corresponding to the lowest standard difficulty, 1 corresponding to the second lowest standard difficulty, etc\n",
    "difficulty = 1\n",
    "#Change the following variable to one of the words \"True\", \"Standard\", or \"Tech\" EXACTLY with the quotation marks that corresponds to the category of the map.\n",
    "category = \"Tech\" \n",
    "#Add the relative paths to the difficulty and info files below\n",
    "diffPath = 'accsaber-maps/3cba5 (Hypnotized - Viking & Taddus)/ExpertPlusStandard.dat' #Replace with the difficulty file's relative path\n",
    "infoPath = 'accsaber-maps/3cba5 (Hypnotized - Viking & Taddus)/Info.dat' #Replace with the info file's relative path\n",
    "madeUsingSeveralVersions = False #Make this boolean \"True\" if the map was made using several versions of Chromapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading json data\n",
    "def get_pythagoras(x, y):\n",
    "    return math.sqrt(x ** 2 + y ** 2)\n",
    "\n",
    "with open(diffPath) as diff_json_data:\n",
    "    diffData = json.load(diff_json_data)\n",
    "\n",
    "with open(infoPath) as info_json_data:\n",
    "    infoData = json.load(info_json_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Parse BPM changes if they exist\n",
    "initialBPM = infoData.get('_beatsPerMinute')\n",
    "diffDict = infoData.get('_difficultyBeatmapSets')[lawless].get('_difficultyBeatmaps')[difficulty]\n",
    "njs = diffDict.get('_noteJumpMovementSpeed')\n",
    "#If the exception is caught, then the map was created using Chromaper\n",
    "IsChromapper = False\n",
    "try:\n",
    "    bpmChangesDict = diffData.get('_customData').get('_BPMChanges')\n",
    "except:\n",
    "    IsChromapper = True\n",
    "\n",
    "if madeUsingSeveralVersions == True:\n",
    "    IsChromapper = True\n",
    "\n",
    "#First we will deal with maps created using MMA2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create columns\n",
    "if (IsChromapper == False):\n",
    "    df_BPMChanges = pd.DataFrame(bpmChangesDict)\n",
    "    df = pd.DataFrame(diffData['_notes'])\n",
    "    df['_yCenter'] = df.loc[:, ('_lineLayer')].apply(lambda x: 1 + x * 0.55)\n",
    "    df['_xCenter'] = df.loc[:, ('_lineIndex')].apply(lambda x: -0.9 + x * 0.6)\n",
    "\n",
    "    #Add bpm column\n",
    "    df['_bpm'] = initialBPM\n",
    "    for i in range(len(df)):\n",
    "        currentTime = df.loc[i, '_time']\n",
    "        currentRow = 0\n",
    "        for j in range(len(df_BPMChanges)):\n",
    "            if currentTime >= df_BPMChanges.loc[j, '_time']:\n",
    "                df['_bpm'] = df_BPMChanges.loc[j, '_BPM']\n",
    "   \n",
    "   \n",
    "    left = (df[df['_type'] == 0]) #All left handed notes\n",
    "    right = (df[df['_type'] == 1]) #All right handed notes\n",
    "\n",
    "    num_notes = len(left) + len(right)\n",
    "\n",
    "    left['_timeChange'] = left.loc[:, ['_time']].diff().fillna(0)\n",
    "    right['_timeChange'] = right.loc[:, ['_time']].diff().fillna(0)\n",
    "\n",
    "\n",
    "    left['_timeChangeSeconds'] = (60 * left['_timeChange']) / left['_bpm']\n",
    "    right['_timeChangeSeconds'] = (60 * right['_timeChange']) / right['_bpm']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Account for sliders and stacks\n",
    "if (IsChromapper == False):\n",
    "    EPSILON = 0.059\n",
    "    firstLeftSwingIndex = left.head(1).index[0]\n",
    "    firstRightSwingIndex = right.head(1).index[0]\n",
    "\n",
    "    df_newLeftSwing = left[((((60 * left['_timeChange']) / left['_bpm']) > EPSILON) | (left.index == firstLeftSwingIndex))]\n",
    "    df_newRightSwing = right[((((60 * right['_timeChange']) / right['_bpm']) > EPSILON) | (right.index == firstRightSwingIndex))]\n",
    "    df_leftSliders = left[(((60 * left['_timeChange']) / left['_bpm']) < EPSILON) & (left['_timeChange'] != 0)]\n",
    "    df_rightSliders = right[(((60 * right['_timeChange']) / right['_bpm']) < EPSILON) & (right['_timeChange'] != 0)]\n",
    "\n",
    "    hasSliders = False\n",
    "    if (len(df_leftSliders) + len(df_rightSliders) > 0):\n",
    "        hasSliders = True\n",
    "\n",
    "    #Create and update columns\n",
    "    df_newLeftSwing['_xMovement'] = df_newLeftSwing.loc[:, ['_xCenter']].diff().fillna(0)\n",
    "    df_newLeftSwing['_yMovement'] = df_newLeftSwing.loc[:, ['_yCenter']].diff().fillna(0)\n",
    "    df_newLeftSwing['_totMovement'] = df_newLeftSwing.apply(lambda x: get_pythagoras(x['_xMovement'], x['_yMovement']), axis=1).fillna(0) \n",
    "    df_newLeftSwing['_angleMagnitudeChange'] = abs(df_newLeftSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
    "    df_newLeftSwing['_timeChange'] = df_newLeftSwing.loc[:, ['_time']].diff().fillna(0)\n",
    "    df_newLeftSwing['_timeChangeSeconds'] = (60 * df_newLeftSwing['_timeChange']) / df_newLeftSwing['_bpm']\n",
    "\n",
    "    df_newRightSwing['_xMovement'] = df_newRightSwing.loc[:, ['_xCenter']].diff().fillna(0)\n",
    "    df_newRightSwing['_yMovement'] = df_newRightSwing.loc[:, ['_yCenter']].diff().fillna(0)\n",
    "    df_newRightSwing['_totMovement'] = df_newRightSwing.apply(lambda x: get_pythagoras(x['_xMovement'], x['_yMovement']), axis=1).fillna(0)\n",
    "    df_newRightSwing['_angleMagnitudeChange'] = abs(df_newRightSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
    "    df_newRightSwing['_timeChange'] = df_newRightSwing.loc[:, ['_time']].diff().fillna(0)\n",
    "    df_newRightSwing['_timeChangeSeconds'] = (60 * df_newRightSwing['_timeChange']) / df_newRightSwing['_bpm']\n",
    "\n",
    "    df_newSwing = pd.concat([df_newLeftSwing, df_newRightSwing])\n",
    "\n",
    "    df_newSwing = df_newSwing.sort_values('_time')\n",
    "    df_newSwing['_timeChange'] = df_newSwing.loc[:, ['_time']].diff().fillna(0)\n",
    "    df_newSwing['_timeChangeSeconds'] = (60 * df_newSwing['_timeChange']) / df_newSwing['_bpm']\n",
    "\n",
    "\n",
    "    df_newLeftSwing['_seconds'] = df_newLeftSwing['_timeChangeSeconds'].cumsum()\n",
    "    df_newRightSwing['_seconds'] = df_newRightSwing['_timeChangeSeconds'].cumsum()\n",
    "    df_newSwing['_seconds'] = df_newSwing['_timeChangeSeconds'].cumsum()\n",
    "\n",
    "    df_ignoreDoubles = df_newSwing.groupby('_seconds', as_index=False).agg('first')\n",
    "\n",
    "\n",
    "    #Statistics \n",
    "    left_swings = len(df_newLeftSwing)\n",
    "    right_swings = len(df_newRightSwing)\n",
    "    total_swings = len(df_newSwing)\n",
    "    left_time = df_newLeftSwing['_timeChangeSeconds'].sum()\n",
    "    right_time = df_newRightSwing['_timeChangeSeconds'].sum()\n",
    "    right_avg_sps = right_swings / right_time\n",
    "    left_avg_sps = left_swings / left_time\n",
    "    left_avg_angleChange = df_newLeftSwing['_angleMagnitudeChange'].mean()\n",
    "    right_avg_angleChange = df_newRightSwing['_angleMagnitudeChange'].mean()\n",
    "    avg_angleChange = df_newSwing['_angleMagnitudeChange'].mean()\n",
    "    total_time = df_newSwing['_timeChangeSeconds'].sum()\n",
    "    avg_sps = total_swings / total_time\n",
    "    num_doubles = len(df_newSwing) - len(df_ignoreDoubles)\n",
    "    avg_true_acc_sps = len(df_ignoreDoubles) / df_ignoreDoubles['_timeChangeSeconds'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The code in this cell is adapted from Uninstaller's sps calculator\n",
    "\n",
    "if (IsChromapper == False):\n",
    "    def calculate_swings_list(df_current):\n",
    "        swing_list = df_current['_seconds'].tolist()\n",
    "        last = math.floor(df_current['_seconds'].max())\n",
    "        array = [0 for x in range(math.floor(last) + 1)]\n",
    "        for swing in swing_list:\n",
    "            array[math.floor(swing)] += 1\n",
    "        return array\n",
    "\n",
    "    \n",
    "\n",
    "    def calculate_max_sps(swings_list, interval = 10):\n",
    "    \n",
    "        current_sps_sum = sum(swings_list[:interval])\n",
    "        max_sps_sum = current_sps_sum\n",
    "        for x in range(0, len(swings_list) - interval):\n",
    "            current_sps_sum = current_sps_sum - swings_list[x] + swings_list[x + interval]\n",
    "            max_sps_sum = max(max_sps_sum, current_sps_sum)\n",
    "        return round(max_sps_sum / interval, 2)\n",
    "\n",
    "    #peak sps statistics\n",
    "\n",
    "    \n",
    "    peak_left_sps = calculate_max_sps(calculate_swings_list(df_newLeftSwing))\n",
    "    peak_right_sps = calculate_max_sps(calculate_swings_list(df_newRightSwing))\n",
    "    peak_sps = calculate_max_sps(calculate_swings_list(df_newSwing))\n",
    "    peak_true_acc_sps = calculate_max_sps(calculate_swings_list(df_ignoreDoubles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create columns to help with bombs\n",
    "if (IsChromapper == False):\n",
    "    df['_timeChangeBefore'] = df.loc[:, ['_time']].diff().fillna(0)\n",
    "    df['_timeChangeBefore'] = (60 * df['_timeChangeBefore']) / df['_bpm']\n",
    "    df['_timeChangeAfter'] = abs(df.loc[:, ['_time']].diff(periods = -1).fillna(0))\n",
    "    df['_timeChangeAfter'] = (60 * df['_timeChangeAfter']) / df['_bpm']\n",
    "\n",
    "    #Bombs\n",
    "    minReactTimeBefore = float('inf')\n",
    "    minReactTimeAfter = float('inf')\n",
    "\n",
    "    firstType = df.loc[0, '_time']\n",
    "    secondType = df.loc[1, '_time']\n",
    "    secondLastType = df.loc[len(df) - 2, '_time']\n",
    "    lastType = df.loc[len(df) - 1, '_time']\n",
    "\n",
    "    #Check for bomb at start\n",
    "    if (firstType == 3) & (secondType != 3):\n",
    "        minReactTimeAfter = df.loc[0, '_timeChangeAfter'] * 1000\n",
    "\n",
    "    #Check for bomb at end\n",
    "    if (lastType == 3) & (secondLastType != 3):\n",
    "        if (minReactTimeBefore == float('inf')) | (minReactTimeBefore > df.loc[len(df) - 1, '_timeChangeBefore']):\n",
    "            minReactTimeBefore = df.loc[len(df) - 1, '_timeChangeBefore'] \n",
    "\n",
    "    #Find the minimum time before and after a bomb, ignoring bombs outside the swing's path\n",
    "    for i in range(len(df) - 2):\n",
    "        previousType = df.loc[i, '_type']\n",
    "        thisType = df.loc[i + 1, '_type']\n",
    "        nextType = df.loc[i + 2, '_type']\n",
    "        if thisType == 3:\n",
    "            bombException = False\n",
    "\n",
    "            #Calculate minimum time before a bomb\n",
    "            if (previousType == 0) | (previousType == 1):\n",
    "                #Check for conditions where bomb is out of path of saber\n",
    "                if (df.loc[i, '_lineLayer'] == 0) & (df.loc[i + 1, '_lineLayer'] == 2): #Note is in bottom layer and bomb is in top layer\n",
    "                    if (df.loc[i, '_cutDirection'] == 2) | (df.loc[i, '_cutDirection'] == 3) | (df.loc[i, '_cutDirection'] == 8): #Note direction is left, right, or dot\n",
    "                        bombException = True\n",
    "                elif (df.loc[i, '_type'] == 0): #Note is red\n",
    "                    if (df.loc[i, '_lineLayer'] == 0): #Note is bottom layer\n",
    "                        if (df.loc[i, '_lineIndex'] == 0): #Note has leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 2) | (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in second rightmost or rightmost index\n",
    "                                #Note direction is up, down, up left, down left, or dot\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 4) | (df.loc[i, '_cutDirection'] == 6) | (df.loc[i, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                        elif (df.loc[i, '_lineIndex'] == 1): #Note has second leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in rightmost index\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                        else: #Note is in second rightmost or rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0): #Bomb is in leftmost index\n",
    "                                #Note direction is up, down, down right, or dot\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 7) | (df.loc[i, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                    elif (df.loc[i, '_lineLayer'] == 2): #Note is in top layer\n",
    "                        if (df.loc[i, '_lineIndex'] == 0): #Note has leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 2) | (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in second rightmost or rightmost index\n",
    "                                #Note direction is up, down, up left, down left, or dot\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 4) | (df.loc[i, '_cutDirection'] == 6) | (df.loc[i, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                        elif (df.loc[i, '_lineIndex'] == 1): #Note has second leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in rightmost index\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                        else: #Note is in second rightmost or rightmost index\n",
    "                            if df.loc[i + 1, '_lineIndex'] == 0: #Bomb is in leftmost index\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                elif (df.loc[i, '_type'] == 1): #Note is blue\n",
    "                    if (df.loc[i, '_lineLayer'] == 0): #Note is bottom layer\n",
    "                        if (df.loc[i, '_lineIndex'] == 3): #Note has rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0) | (df.loc[i + 1, '_lineIndex'] == 1): #Bomb is in second leftmost or leftmost index\n",
    "                                #Note direction is up, down, up right, down right, or dot\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 5) | (df.loc[i, '_cutDirection'] == 7) | (df.loc[i, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                        elif (df.loc[i, '_lineIndex'] == 2): #Note has second rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0): #Bomb is in leftmost index\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                        else: #Note is in second leftmost or leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in rightmost index\n",
    "                                #Note direction is up, down, down left, or dot\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 6) | (df.loc[i, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                    elif (df.loc[i, '_lineLayer'] == 2): #Note is in top layer\n",
    "                        if (df.loc[i, '_lineIndex'] == 3): #Note has rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0) | (df.loc[i + 1, '_lineIndex'] == 1): #Bomb is in second leftmost or leftmost index\n",
    "                                #Note direction is up, down, up right, down right, or dot\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 5) | (df.loc[i, '_cutDirection'] == 7) | (df.loc[i, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                        elif (df.loc[i, '_lineIndex'] == 2): #Note has second rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0): #Bomb is in leftmost index\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                        else: #Note is in second leftmost or leftmost index\n",
    "                            if df.loc[i + 1, '_lineIndex'] == 3: #Bomb is in rightmost index\n",
    "                                if (df.loc[i, '_cutDirection'] == 0) | (df.loc[i, '_cutDirection'] == 1) | (df.loc[i, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "\n",
    "                #Update the minimum time before a bomb if needed\n",
    "                if (bombException == False) & ((minReactTimeBefore == float('inf')) | (minReactTimeBefore > df.loc[i + 1, '_timeChangeBefore'])):\n",
    "                    minReactTimeBefore = df.loc[i + 1, '_timeChangeBefore']\n",
    "\n",
    "            #Calculate minimum time after a bomb\n",
    "            if (nextType == 0) | (nextType == 1):\n",
    "                #Check for conditions where bomb is out of path of saber\n",
    "                if (df.loc[i + 2, '_lineLayer'] == 0) & (df.loc[i + 1, '_lineLayer'] == 2): #Note is in bottom layer and bomb is in top layer\n",
    "                    if (df.loc[i + 2, '_cutDirection'] == 2) | (df.loc[i + 2, '_cutDirection'] == 3) | (df.loc[i + 2, '_cutDirection'] == 8): #Note direction is left, right, or dot\n",
    "                        bombException = True\n",
    "                elif (df.loc[i + 2, '_type'] == 0): #Note is red\n",
    "                    if (df.loc[i + 2, '_lineLayer'] == 0): #Note is bottom layer\n",
    "                        if (df.loc[i + 2, '_lineIndex'] == 0): #Note has leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 2) | (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in second rightmost or rightmost index\n",
    "                                #Note direction is up, down, up left, down left, or dot\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 4) | (df.loc[i + 2, '_cutDirection'] == 6) | (df.loc[i + 2, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                        elif (df.loc[i + 2, '_lineIndex'] == 1): #Note has second leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in rightmost index\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                        else: #Note is in second rightmost or rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0): #Bomb is in leftmost index\n",
    "                                #Note direction is up, down, down right, or dot\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 7) | (df.loc[i + 2, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                    elif (df.loc[i + 2, '_lineLayer'] == 2): #Note is in top layer\n",
    "                        if (df.loc[i + 2, '_lineIndex'] == 0): #Note has leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 2) | (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in second rightmost or rightmost index\n",
    "                                #Note direction is up, down, up left, down left, or dot\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 4) | (df.loc[i + 2, '_cutDirection'] == 6) | (df.loc[i + 2, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                        elif (df.loc[i + 2, '_lineIndex'] == 1): #Note has second leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in rightmost index\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                        else: #Note is in second rightmost or rightmost index\n",
    "                            if df.loc[i + 1, '_lineIndex'] == 0: #Bomb is in leftmost index\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                elif (df.loc[i + 2, '_type'] == 1): #Note is blue\n",
    "                    if (df.loc[i + 2, '_lineLayer'] == 0): #Note is bottom layer\n",
    "                        if (df.loc[i + 2, '_lineIndex'] == 3): #Note has rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0) | (df.loc[i + 1, '_lineIndex'] == 1): #Bomb is in second leftmost or leftmost index\n",
    "                                #Note direction is up, down, up right, down right, or dot\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 5) | (df.loc[i + 2, '_cutDirection'] == 7) | (df.loc[i + 2, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                        elif (df.loc[i + 2, '_lineIndex'] == 2): #Note has second rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0): #Bomb is in leftmost index\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                        else: #Note is in second leftmost or leftmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 3): #Bomb is in rightmost index\n",
    "                                #Note direction is up, down, down left, or dot\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 6) | (df.loc[i + 2, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                    elif (df.loc[i + 2, '_lineLayer'] == 2): #Note is in top layer\n",
    "                        if (df.loc[i + 2, '_lineIndex'] == 3): #Note has rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0) | (df.loc[i + 1, '_lineIndex'] == 1): #Bomb is in second leftmost or leftmost index\n",
    "                                #Note direction is up, down, up right, down right, or dot\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 5) | (df.loc[i + 2, '_cutDirection'] == 7) | (df.loc[i + 2, '_cutDirection'] == 8):\n",
    "                                    bombException = True\n",
    "                        elif (df.loc[i + 2, '_lineIndex'] == 2): #Note has second rightmost index\n",
    "                            if (df.loc[i + 1, '_lineIndex'] == 0): #Bomb is in leftmost index\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "                        else: #Note is in second leftmost or leftmost index\n",
    "                            if df.loc[i + 1, '_lineIndex'] == 3: #Bomb is in rightmost index\n",
    "                                if (df.loc[i + 2, '_cutDirection'] == 0) | (df.loc[i + 2, '_cutDirection'] == 1) | (df.loc[i + 2, '_cutDirection'] == 8): #Note direction is up, down, or dot\n",
    "                                    bombException = True\n",
    "\n",
    "                #Update the minimum time after a bomb if needed\n",
    "                if (bombException == False) & ((minReactTimeAfter == float('inf')) | (minReactTimeAfter > df.loc[i + 1, '_timeChangeAfter'])):\n",
    "                    minReactTimeAfter = df.loc[i + 1, '_timeChangeAfter']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def FindSectionsBreakingPeakSps(swings_list, category, interval = 10):\n",
    "    data = []\n",
    "    peak_sps_limit = 5.75\n",
    "    \n",
    "    if (category == \"True\"):\n",
    "        peak_sps_limit = 1.75\n",
    "\n",
    "    current_sps_sum = sum(swings_list[:interval])\n",
    "    \n",
    "    for x in range(0, len(swings_list) - interval):\n",
    "        current_sps_sum = current_sps_sum - swings_list[x] + swings_list[x + interval]\n",
    "        if ((current_sps_sum / interval) > peak_sps_limit):\n",
    "            start = x\n",
    "            end = x + 10\n",
    "            data.append(str(start) + ' seconds to ' + str(end) + ' seconds (' + str(current_sps_sum/interval) + ' sps)' )\n",
    "    return data\n",
    "\n",
    "def PrintPeakSpsLog(category):\n",
    "    if (category == \"True\"):\n",
    "        swings = calculate_swings_list(df_ignoreDoubles)\n",
    "    else:\n",
    "        swings = calculate_swings_list(df_newSwing)\n",
    "    failed_sections = FindSectionsBreakingPeakSps(swings, category)\n",
    "    print('The sections that broke the peak sps are')\n",
    "    for x in failed_sections:\n",
    "        print(str(x))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Criteria Check\n",
    "#This script does not check for towers or sliders in maps that are not tech acc\n",
    "passLog = \"\"\n",
    "failLog = \"\"\n",
    "passTests = True\n",
    "if (IsChromapper == False):\n",
    "    if (minReactTimeBefore != float('inf')):\n",
    "        minReactTimeBefore = math.floor(minReactTimeBefore * 1000)\n",
    "    if (minReactTimeAfter != float('inf')):\n",
    "        minReactTimeAfter = math.floor(minReactTimeAfter * 1000)\n",
    "    avg_sps = round(avg_sps, 2)\n",
    "    peak_sps = round(peak_sps, 2)\n",
    "    avg_true_acc_sps = round(avg_true_acc_sps, 2)\n",
    "    peak_true_acc_sps = round(peak_true_acc_sps, 2)\n",
    "    total_time = round(total_time, 2)\n",
    "\n",
    "    #General criteria checks\n",
    "\n",
    "    #Check if time between first and last note is between 2-6 minutes inclusive\n",
    "    if ((total_time < 120) | (total_time > 300)):\n",
    "        passTests = False\n",
    "        failLog += \"Fail: The time between the first and last note is \" + str(total_time) + \" seconds which is outside of the range of 120 to 300 seconds\\n\"\n",
    "    else:\n",
    "        passLog += \"Pass: The time between the first and last note is \" + str(total_time) + \" seconds which is between 120 and 300 seconds\\n\"\n",
    "    if (((df_newLeftSwing.iloc[0].loc['_cutDirection'] != 1) & (df_newLeftSwing.iloc[0].loc['_cutDirection'] != 8) & (df_newLeftSwing.iloc[0].loc['_cutDirection'] != 6) & (df_newLeftSwing.iloc[0].loc['_cutDirection'] != 7)) | ((df_newRightSwing.iloc[0].loc['_cutDirection'] != 1) & (df_newRightSwing.iloc[0].loc['_cutDirection'] != 8) & (df_newRightSwing.iloc[0].loc['_cutDirection'] != 6) & (df_newRightSwing.iloc[0].loc['_cutDirection'] != 7))):\n",
    "        passTests = False\n",
    "        failLog += \"Fail: At least one of the hands does not start on a downswing\\n\"\n",
    "    else:\n",
    "        passLog += \"Pass: Both hands start on a downswing\\n\"\n",
    "    if (num_notes < 115):\n",
    "        passTests = False\n",
    "        failLog += \"Fail: There are \" + str(num_notes) + \" notes, which is less than 115\\n\"\n",
    "    else: \n",
    "        passLog += \"Pass: There are \" + str(num_notes) + \" notes, which is at least 115\\n\"\n",
    "    if ((minReactTimeAfter != float('inf')) & (minReactTimeAfter < 200)):\n",
    "        passTests = False\n",
    "        failLog += \"Fail: The minimum reaction time after a bomb is \" + str(minReactTimeAfter) + \" miliseconds, which is less than 200\\n\"\n",
    "    else:\n",
    "        passLog += \"Pass: The minimum reaction time after a bomb is \" + str(minReactTimeAfter) + \" miliseconds, which is at least 200\\n\"\n",
    "\n",
    "    #Category specific criteria checks\n",
    "    if (category == \"True\"):\n",
    "        if (num_notes != len(df_newSwing)):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: There are sliders, stacks, towers, or windows in this map\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: There are no sliders, stacks, towers, or windows in this map\\n\"\n",
    "        if (njs > 12):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The njs is \" + str(njs) + \" which is greater than 12\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The njs is \" + str(njs) + \" which is no more than 12\\n\"\n",
    "        if ((minReactTimeBefore != float('inf')) & (minReactTimeBefore < 500)):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is less than 500\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is at least 500\\n\"\n",
    "        if (avg_true_acc_sps > 1.5):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The average sps counting doubles as one swing is \" + str(avg_true_acc_sps) + \" swings per second, which is more than 1.5\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The average sps counting doubles as one swing is \" + str(avg_true_acc_sps) + \" swings per second, which is no more than 1.5\\n\"\n",
    "        if (peak_true_acc_sps > 1.75):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The peak sps counting doubles as one swing is \" + str(peak_true_acc_sps) + \" swings per second, which is more than 1.75\\n\"\n",
    "            PrintPeakSpsLog(\"True\")\n",
    "        else:\n",
    "            passLog += \"Pass: The peak sps counting doubles as one swing is \" + str(peak_true_acc_sps) + \" swings per second, which is no more than 1.75\\n\"\n",
    "    elif (category == \"Standard\"):\n",
    "        if (njs > 16):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The njs is \" + str(njs) + \" which is greater than 16\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The njs is \" + str(njs) + \" which is no more than 16\\n\"\n",
    "        if ((minReactTimeBefore != float('inf')) & (minReactTimeBefore < 350)):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is less than 350\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is at least 350\\n\"\n",
    "        if (avg_sps > 4):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The average sps is \" + str(avg_sps) + \" which is greater than 4 sps\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The average sps is \" + str(avg_sps) + \" which is no more than 4 sps\\n\"\n",
    "        if (peak_sps > 5.75):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The peak sps is \" + str(peak_sps) + \" which is greater than 5.75 sps\\n\"\n",
    "            PrintPeakSpsLog(\"Standard\")\n",
    "        else:\n",
    "            passLog += \"Pass: The peak sps is \" + str(peak_sps) + \" which is no more than 5.75 sps\\n\"\n",
    "        if (hasSliders == True):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: This map has sliders\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: This map does not have sliders\\n\"\n",
    "    elif (category == \"Tech\"):\n",
    "        if (njs > 16):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The njs is \" + str(njs) + \" which is greater than 16\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The njs is \" + str(njs) + \" which is no more than 16\\n\"\n",
    "        if ((minReactTimeBefore != float('inf')) & (minReactTimeBefore < 300)):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is less than 300\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is at least 300\\n\"\n",
    "        if (avg_sps > 4):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The average sps is \" + str(avg_sps) + \" which is greater than 4 sps\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The average sps is \" + str(avg_sps) + \" which is no more than 4 sps\\n\"\n",
    "        if (peak_sps > 5.75):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The peak sps is \" + str(peak_sps) + \" which is greater than 5.75 sps\\n\"\n",
    "            PrintPeakSpsLog(\"Tech\")\n",
    "        else:\n",
    "            passLog += \"Pass: The peak sps is \" + str(peak_sps) + \" which is no more than 5.75 sps\\n\"\n",
    "    else:\n",
    "        print(\"Check your category variable for spelling errors\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3730009744.py:35: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  left['_timeChange'] = left.loc[:, ['b']].diff().fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3730009744.py:36: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  right['_timeChange'] = right.loc[:, ['b']].diff().fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3730009744.py:39: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  left['_timeChangeSeconds'] = (60 * left['_timeChange']) / left['_bpm']\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3730009744.py:40: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  right['_timeChangeSeconds'] = (60 * right['_timeChange']) / right['_bpm']\n"
     ]
    }
   ],
   "source": [
    "#Now we will deal with maps created using Chromapper\n",
    "#Create columns\n",
    "if (IsChromapper == True):\n",
    "    temp_array = diffPath.split('/')\n",
    "    \n",
    "    bpmPath = temp_array[0] + '/' + temp_array[1] + '/BPMInfo.dat'\n",
    "    with open(bpmPath) as bpm_json_data:\n",
    "        bpmData = json.load(bpm_json_data)\n",
    "    song_frequency = bpmData.get('_songFrequency')\n",
    "    bpmChangesDict = bpmData.get('_regions')\n",
    "    df_BPMChanges = pd.DataFrame(bpmChangesDict)\n",
    "    df_BPMChanges['_change_in_time'] = (df_BPMChanges['_endSampleIndex'] - df_BPMChanges['_startSampleIndex']) / song_frequency\n",
    "    df_BPMChanges['_BPM'] = (df_BPMChanges['_endBeat'] - df_BPMChanges['_startBeat']) * (60 / df_BPMChanges['_change_in_time'])\n",
    "    df_BPMChanges['_time'] = df_BPMChanges['_change_in_time'].cumsum()\n",
    "\n",
    "    df = pd.DataFrame(diffData['colorNotes'])\n",
    "    df['_yCenter'] = df.loc[:, ('y')].apply(lambda x: 1 + x * 0.55)\n",
    "    df['_xCenter'] = df.loc[:, ('x')].apply(lambda x: -0.9 + x * 0.6)\n",
    "\n",
    "    #Add bpm column\n",
    "    df['_bpm'] = initialBPM\n",
    "    for i in range(len(df)):\n",
    "        currentTime = df.loc[i, 'b']\n",
    "        currentRow = 0\n",
    "        for j in range(len(df_BPMChanges)):\n",
    "            if currentTime >= df_BPMChanges.loc[j, '_time']:\n",
    "                df['_bpm'] = df_BPMChanges.loc[j, '_BPM']\n",
    "   \n",
    "   \n",
    "    left = (df[df['c'] == 0]) #All left handed notes\n",
    "    right = (df[df['c'] == 1]) #All right handed notes\n",
    "\n",
    "    num_notes = len(left) + len(right)\n",
    "\n",
    "    left['_timeChange'] = left.loc[:, ['b']].diff().fillna(0)\n",
    "    right['_timeChange'] = right.loc[:, ['b']].diff().fillna(0)\n",
    "\n",
    "\n",
    "    left['_timeChangeSeconds'] = (60 * left['_timeChange']) / left['_bpm']\n",
    "    right['_timeChangeSeconds'] = (60 * right['_timeChange']) / right['_bpm']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:17: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newLeftSwing['_xMovement'] = df_newLeftSwing.loc[:, ['_xCenter']].diff().fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:18: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newLeftSwing['_yMovement'] = df_newLeftSwing.loc[:, ['_yCenter']].diff().fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:19: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newLeftSwing['_totMovement'] = df_newLeftSwing.apply(lambda x: get_pythagoras(x['_xMovement'], x['_yMovement']), axis=1).fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:20: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  df_newLeftSwing['_angleMagnitudeChange'] = abs(df_newLeftSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:20: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  df_newLeftSwing['_angleMagnitudeChange'] = abs(df_newLeftSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newLeftSwing['_angleMagnitudeChange'] = abs(df_newLeftSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newLeftSwing['_timeChange'] = df_newLeftSwing.loc[:, ['b']].diff().fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:22: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newLeftSwing['_timeChangeSeconds'] = (60 * df_newLeftSwing['_timeChange']) / df_newLeftSwing['_bpm']\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:24: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newRightSwing['_xMovement'] = df_newRightSwing.loc[:, ['_xCenter']].diff().fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:25: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newRightSwing['_yMovement'] = df_newRightSwing.loc[:, ['_yCenter']].diff().fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:26: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newRightSwing['_totMovement'] = df_newRightSwing.apply(lambda x: get_pythagoras(x['_xMovement'], x['_yMovement']), axis=1).fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:27: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  df_newRightSwing['_angleMagnitudeChange'] = abs(df_newRightSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:27: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  df_newRightSwing['_angleMagnitudeChange'] = abs(df_newRightSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:27: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newRightSwing['_angleMagnitudeChange'] = abs(df_newRightSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:28: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newRightSwing['_timeChange'] = df_newRightSwing.loc[:, ['b']].diff().fillna(0)\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newRightSwing['_timeChangeSeconds'] = (60 * df_newRightSwing['_timeChange']) / df_newRightSwing['_bpm']\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:37: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newLeftSwing['_seconds'] = df_newLeftSwing['_timeChangeSeconds'].cumsum()\n",
      "/var/folders/hx/8pb__z8x49q872rhs7wcd7_m0000gn/T/ipykernel_4511/3772083690.py:38: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_newRightSwing['_seconds'] = df_newRightSwing['_timeChangeSeconds'].cumsum()\n"
     ]
    }
   ],
   "source": [
    "#Account for sliders and stacks\n",
    "if (IsChromapper == True):\n",
    "    EPSILON = 0.059\n",
    "    firstLeftSwingIndex = left.head(1).index[0]\n",
    "    firstRightSwingIndex = right.head(1).index[0]\n",
    "\n",
    "    df_newLeftSwing = left[((((60 * left['_timeChange']) / left['_bpm']) > EPSILON) | (left.index == firstLeftSwingIndex))]\n",
    "    df_newRightSwing = right[((((60 * right['_timeChange']) / right['_bpm']) > EPSILON) | (right.index == firstRightSwingIndex))]\n",
    "    df_leftSliders = left[(((60 * left['_timeChange']) / left['_bpm']) < EPSILON) & (left['_timeChange'] != 0)]\n",
    "    df_rightSliders = right[(((60 * right['_timeChange']) / right['_bpm']) < EPSILON) & (right['_timeChange'] != 0)]\n",
    "    \n",
    "    hasSliders = False\n",
    "    if (len(df_leftSliders) + len(df_rightSliders) > 0):\n",
    "        hasSliders = True\n",
    "\n",
    "    #Create and update columns\n",
    "    df_newLeftSwing['_xMovement'] = df_newLeftSwing.loc[:, ['_xCenter']].diff().fillna(0)\n",
    "    df_newLeftSwing['_yMovement'] = df_newLeftSwing.loc[:, ['_yCenter']].diff().fillna(0)\n",
    "    df_newLeftSwing['_totMovement'] = df_newLeftSwing.apply(lambda x: get_pythagoras(x['_xMovement'], x['_yMovement']), axis=1).fillna(0) \n",
    "    df_newLeftSwing['_angleMagnitudeChange'] = abs(df_newLeftSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
    "    df_newLeftSwing['_timeChange'] = df_newLeftSwing.loc[:, ['b']].diff().fillna(0)\n",
    "    df_newLeftSwing['_timeChangeSeconds'] = (60 * df_newLeftSwing['_timeChange']) / df_newLeftSwing['_bpm']\n",
    "\n",
    "    df_newRightSwing['_xMovement'] = df_newRightSwing.loc[:, ['_xCenter']].diff().fillna(0)\n",
    "    df_newRightSwing['_yMovement'] = df_newRightSwing.loc[:, ['_yCenter']].diff().fillna(0)\n",
    "    df_newRightSwing['_totMovement'] = df_newRightSwing.apply(lambda x: get_pythagoras(x['_xMovement'], x['_yMovement']), axis=1).fillna(0)\n",
    "    df_newRightSwing['_angleMagnitudeChange'] = abs(df_newRightSwing.apply(lambda x: math.atan(x['_yMovement']/x['_xMovement']), axis=1))\n",
    "    df_newRightSwing['_timeChange'] = df_newRightSwing.loc[:, ['b']].diff().fillna(0)\n",
    "    df_newRightSwing['_timeChangeSeconds'] = (60 * df_newRightSwing['_timeChange']) / df_newRightSwing['_bpm']\n",
    "\n",
    "    df_newSwing = pd.concat([df_newLeftSwing, df_newRightSwing])\n",
    "    df_newSwing = df_newSwing.sort_values('b')\n",
    "    df_newSwing['_timeChange'] = df_newSwing.loc[:, ['b']].diff().fillna(0)\n",
    "    df_newSwing['_timeChangeSeconds'] = (60 * df_newSwing['_timeChange']) / df_newSwing['_bpm']\n",
    "\n",
    "\n",
    "    df_newLeftSwing['_seconds'] = df_newLeftSwing['_timeChangeSeconds'].cumsum()\n",
    "    df_newRightSwing['_seconds'] = df_newRightSwing['_timeChangeSeconds'].cumsum()\n",
    "    df_newSwing['_seconds'] = df_newSwing['_timeChangeSeconds'].cumsum()\n",
    "\n",
    "    df_ignoreDoubles = df_newSwing.groupby('_seconds', as_index=False).agg('first')\n",
    "\n",
    "\n",
    "    #Statistics \n",
    "    left_swings = len(df_newLeftSwing)\n",
    "    right_swings = len(df_newRightSwing)\n",
    "    total_swings = len(df_newSwing)\n",
    "    left_time = df_newLeftSwing['_timeChangeSeconds'].sum()\n",
    "    right_time = df_newRightSwing['_timeChangeSeconds'].sum()\n",
    "    right_avg_sps = right_swings / right_time\n",
    "    left_avg_sps = left_swings / left_time\n",
    "    left_avg_angleChange = df_newLeftSwing['_angleMagnitudeChange'].mean()\n",
    "    right_avg_angleChange = df_newRightSwing['_angleMagnitudeChange'].mean()\n",
    "    avg_angleChange = df_newSwing['_angleMagnitudeChange'].mean()\n",
    "    total_time = df_newSwing['_timeChangeSeconds'].sum()\n",
    "    avg_sps = total_swings / total_time\n",
    "    num_doubles = len(df_newSwing) - len(df_ignoreDoubles)\n",
    "    avg_true_acc_sps = len(df_ignoreDoubles) / df_ignoreDoubles['_timeChangeSeconds'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The code in this cell is adapted from Uninstaller's sps calculator\n",
    "if (IsChromapper == True):\n",
    "    def calculate_swings_list(df_current):\n",
    "        swing_list = df_current['_seconds'].tolist()\n",
    "        last = math.floor(df_current['_seconds'].max())\n",
    "        array = [0 for x in range(math.floor(last) + 1)]\n",
    "        for swing in swing_list:\n",
    "            array[math.floor(swing)] += 1\n",
    "        return array\n",
    "\n",
    "    \n",
    "\n",
    "    def calculate_max_sps(swings_list, interval = 10):\n",
    "    \n",
    "        current_sps_sum = sum(swings_list[:interval])\n",
    "        max_sps_sum = current_sps_sum\n",
    "        for x in range(0, len(swings_list) - interval):\n",
    "            current_sps_sum = current_sps_sum - swings_list[x] + swings_list[x + interval]\n",
    "            max_sps_sum = max(max_sps_sum, current_sps_sum)\n",
    "        return round(max_sps_sum / interval, 2)\n",
    "\n",
    "    #peak sps statistics\n",
    "    peak_left_sps = calculate_max_sps(calculate_swings_list(df_newLeftSwing))\n",
    "    peak_right_sps = calculate_max_sps(calculate_swings_list(df_newRightSwing))\n",
    "    peak_sps = calculate_max_sps(calculate_swings_list(df_newSwing))\n",
    "    peak_true_acc_sps = calculate_max_sps(calculate_swings_list(df_ignoreDoubles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create columns to help with bombs\n",
    "if (IsChromapper == True):\n",
    "    df['_timeChangeBefore'] = df.loc[:, ['b']].diff().fillna(0)\n",
    "    df['_timeChangeBefore'] = (60 * df['_timeChangeBefore']) / df['_bpm']\n",
    "    df['_timeChangeAfter'] = abs(df.loc[:, ['b']].diff(periods = -1).fillna(0))\n",
    "    df['_timeChangeAfter'] = (60 * df['_timeChangeAfter']) / df['_bpm']\n",
    "\n",
    "    #Bombs\n",
    "    minReactTimeBefore = float('inf')\n",
    "    minReactTimeAfter = float('inf')\n",
    "\n",
    "   \n",
    "    df_bombs = pd.DataFrame(diffData['bombNotes'])\n",
    "\n",
    "    if (len(df_bombs) > 0):\n",
    "        \n",
    "        #Add bomb columns\n",
    "        df_bombs['c'] = 3\n",
    "        df_bombs['d'] = 8\n",
    "        df_bombs['a'] = 0\n",
    "\n",
    "        df_bombs['_yCenter'] = df_bombs.loc[:, ('y')].apply(lambda x: 1 + x * 0.55)\n",
    "        df_bombs['_xCenter'] = df_bombs.loc[:, ('x')].apply(lambda x: -0.9 + x * 0.6)\n",
    "\n",
    "        #Add bpm column\n",
    "        df_bombs['_bpm'] = initialBPM\n",
    "        for i in range(len(df_bombs)):\n",
    "            currentTime = df_bombs.loc[i, 'b']\n",
    "            currentRow = 0\n",
    "            for j in range(len(df_BPMChanges)):\n",
    "                if currentTime >= df_BPMChanges.loc[j, '_time']:\n",
    "                    df_bombs['_bpm'] = df_BPMChanges.loc[j, '_BPM']\n",
    "\n",
    "        df_bombs['_timeChange'] = df_bombs.loc[:, ['b']].diff().fillna(0)\n",
    "        df_bombs['_timeChangeSeconds'] = (60 * df_bombs['_timeChange']) / df_bombs['_bpm']\n",
    "\n",
    "        df_combined = pd.concat([df, df_bombs]).sort_values('b').reset_index(drop=True)\n",
    "        df_combined.drop(['_timeChange', '_timeChangeSeconds', '_timeChangeBefore', '_timeChangeAfter'], axis = 1)\n",
    "        df_combined['_timeChangeBefore'] = df_combined.loc[:, ['b']].diff().fillna(0)\n",
    "        df_combined['_timeChangeBefore'] = (60 * df_combined['_timeChangeBefore']) / df['_bpm']\n",
    "        df_combined['_timeChangeAfter'] = abs(df_combined.loc[:, ['b']].diff(periods = -1).fillna(0))\n",
    "        df_combined['_timeChangeAfter'] = (60 * df_combined['_timeChangeAfter']) / df['_bpm']\n",
    "\n",
    "        firstType = df_combined.loc[0, 'c']\n",
    "        secondType = df_combined.loc[1, 'c']\n",
    "        secondLastType = df_combined.loc[len(df_combined) - 2, 'c']\n",
    "        lastType = df_combined.loc[len(df_combined) - 1, 'c']\n",
    "\n",
    "        #Check for bomb at start\n",
    "        if (firstType == 3) & (secondType != 3):\n",
    "            minReactTimeAfter = df_combined.loc[0, '_timeChangeAfter'] * 1000\n",
    "\n",
    "        #Check for bomb at end\n",
    "        if (lastType == 3) & (secondLastType != 3):\n",
    "            if (minReactTimeBefore == float('inf')) | (minReactTimeBefore > df_combined.loc[len(df) - 1, '_timeChangeBefore']):\n",
    "                minReactTimeBefore = df_combined.loc[len(df_combined) - 1, '_timeChangeBefore'] \n",
    "\n",
    "\n",
    "        #Find the minimum time before and after a bomb, ignoring bombs outside the swing's path\n",
    "        for i in range(len(df_combined) - 2):\n",
    "            previousType = df_combined.loc[i, 'c']\n",
    "            thisType = df_combined.loc[i + 1, 'c']\n",
    "            nextType = df_combined.loc[i + 2, 'c']\n",
    "            if thisType == 3:\n",
    "                bombException = False\n",
    "\n",
    "                #Calculate minimum time before a bomb\n",
    "                if (previousType == 0) | (previousType == 1):\n",
    "                    #Check for conditions where bomb is out of path of saber\n",
    "                    if (df_combined.loc[i, 'y'] == 0) & (df_combined.loc[i + 1, 'y'] == 2): #Note is in bottom layer and bomb is in top layer\n",
    "                        if (df_combined.loc[i, 'd'] == 2) | (df_combined.loc[i, 'd'] == 3) | (df_combined.loc[i, 'd'] == 8): #Note direction is left, right, or dot\n",
    "                            bombException = True\n",
    "                    elif (df_combined.loc[i, 'c'] == 0): #Note is red\n",
    "                        if (df_combined.loc[i, 'y'] == 0): #Note is bottom layer\n",
    "                            if (df_combined.loc[i, 'x'] == 0): #Note has leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 2) | (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in second rightmost or rightmost index\n",
    "                                    #Note direction is up, down, up left, down left, or dot\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 4) | (df_combined.loc[i, 'd'] == 6) | (df_combined.loc[i, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                            elif (df_combined.loc[i, 'x'] == 1): #Note has second leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in rightmost index\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                            else: #Note is in second rightmost or rightmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 0): #Bomb is in leftmost index\n",
    "                                    #Note direction is up, down, down right, or dot\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 7) | (df_combined.loc[i, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                        elif (df_combined.loc[i, 'y'] == 2): #Note is in top layer\n",
    "                            if (df_combined.loc[i, 'x'] == 0): #Note has leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 2) | (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in second rightmost or rightmost index\n",
    "                                    #Note direction is up, down, up left, down left, or dot\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 4) | (df_combined.loc[i, 'd'] == 6) | (df_combined.loc[i, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                            elif (df_combined.loc[i, 'x'] == 1): #Note has second leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in rightmost index\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                            else: #Note is in second rightmost or rightmost index\n",
    "                                if df_combined.loc[i + 1, 'x'] == 0: #Bomb is in leftmost index\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                        elif (df_combined.loc[i, 'c'] == 1): #Note is blue\n",
    "                            if (df_combined.loc[i, 'y'] == 0): #Note is bottom layer\n",
    "                                if (df_combined.loc[i, 'x'] == 3): #Note has rightmost index\n",
    "                                    if (df_combined.loc[i + 1, 'x'] == 0) | (df_combined.loc[i + 1, 'x'] == 1): #Bomb is in second leftmost or leftmost index\n",
    "                                        #Note direction is up, down, up right, down right, or dot\n",
    "                                        if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 5) | (df_combined.loc[i, 'd'] == 7) | (df_combined.loc[i, 'd'] == 8):\n",
    "                                            bombException = True\n",
    "                            elif (df_combined.loc[i, 'x'] == 2): #Note has second rightmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 0): #Bomb is in leftmost index\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                            else: #Note is in second leftmost or leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in rightmost index\n",
    "                                    #Note direction is up, down, down left, or dot\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 6) | (df_combined.loc[i, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                        elif (df_combined.loc[i, 'y'] == 2): #Note is in top layer\n",
    "                            if (df_combined.loc[i, 'x'] == 3): #Note has rightmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 0) | (df_combined.loc[i + 1, 'x'] == 1): #Bomb is in second leftmost or leftmost index\n",
    "                                    #Note direction is up, down, up right, down right, or dot\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 5) | (df_combined.loc[i, 'd'] == 7) | (df_combined.loc[i, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                            elif (df_combined.loc[i, 'x'] == 2): #Note has second rightmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 0): #Bomb is in leftmost index\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                            else: #Note is in second leftmost or leftmost index\n",
    "                                if df_combined.loc[i + 1, 'x'] == 3: #Bomb is in rightmost index\n",
    "                                    if (df_combined.loc[i, 'd'] == 0) | (df_combined.loc[i, 'd'] == 1) | (df_combined.loc[i, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "\n",
    "                    #Update the minimum time before a bomb if needed\n",
    "                    if (bombException == False) & ((minReactTimeBefore == float('inf')) | (minReactTimeBefore > df_combined.loc[i + 1, '_timeChangeBefore'])):\n",
    "                        minReactTimeBefore = df_combined.loc[i + 1, '_timeChangeBefore']\n",
    "\n",
    "                #Calculate minimum time after a bomb\n",
    "                if (nextType == 0) | (nextType == 1):\n",
    "                    #Check for conditions where bomb is out of path of saber\n",
    "                    if (df_combined.loc[i + 2, 'y'] == 0) & (df_combined.loc[i + 1, 'y'] == 2): #Note is in bottom layer and bomb is in top layer\n",
    "                        if (df_combined.loc[i + 2, 'd'] == 2) | (df_combined.loc[i + 2, 'd'] == 3) | (df_combined.loc[i + 2, 'd'] == 8): #Note direction is left, right, or dot\n",
    "                            bombException = True\n",
    "                    elif (df_combined.loc[i + 2, 'c'] == 0): #Note is red\n",
    "                        if (df_combined.loc[i + 2, 'y'] == 0): #Note is bottom layer\n",
    "                            if (df_combined.loc[i + 2, 'x'] == 0): #Note has leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 2) | (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in second rightmost or rightmost index\n",
    "                                    #Note direction is up, down, up left, down left, or dot\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 4) | (df_combined.loc[i + 2, 'd'] == 6) | (df_combined.loc[i + 2, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                            elif (df_combined.loc[i + 2, 'x'] == 1): #Note has second leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in rightmost index\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                            else: #Note is in second rightmost or rightmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 0): #Bomb is in leftmost index\n",
    "                                    #Note direction is up, down, down right, or dot\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 7) | (df_combined.loc[i + 2, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                        elif (df_combined.loc[i + 2, 'y'] == 2): #Note is in top layer\n",
    "                            if (df_combined.loc[i + 2, 'x'] == 0): #Note has leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 2) | (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in second rightmost or rightmost index\n",
    "                                    #Note direction is up, down, up left, down left, or dot\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 4) | (df_combined.loc[i + 2, 'd'] == 6) | (df_combined.loc[i + 2, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                            elif (df_combined.loc[i + 2, 'x'] == 1): #Note has second leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in rightmost index\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                            else: #Note is in second rightmost or rightmost index\n",
    "                                if df_combined.loc[i + 1, 'x'] == 0: #Bomb is in leftmost index\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                    elif (df_combined.loc[i + 2, 'c'] == 1): #Note is blue\n",
    "                        if (df_combined.loc[i + 2, 'y'] == 0): #Note is bottom layer\n",
    "                            if (df_combined.loc[i + 2, 'x'] == 3): #Note has rightmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 0) | (df_combined.loc[i + 1, 'x'] == 1): #Bomb is in second leftmost or leftmost index\n",
    "                                    #Note direction is up, down, up right, down right, or dot\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 5) | (df_combined.loc[i + 2, 'd'] == 7) | (df_combined.loc[i + 2, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                            elif (df_combined.loc[i + 2, 'x'] == 2): #Note has second rightmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 0): #Bomb is in leftmost index\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                            else: #Note is in second leftmost or leftmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 3): #Bomb is in rightmost index\n",
    "                                    #Note direction is up, down, down left, or dot\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 6) | (df_combined.loc[i + 2, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                        elif (df_combined.loc[i + 2, 'y'] == 2): #Note is in top layer\n",
    "                            if (df_combined.loc[i + 2, 'x'] == 3): #Note has rightmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 0) | (df_combined.loc[i + 1, 'x'] == 1): #Bomb is in second leftmost or leftmost index\n",
    "                                    #Note direction is up, down, up right, down right, or dot\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 5) | (df_combined.loc[i + 2, 'd'] == 7) | (df_combined.loc[i + 2, 'd'] == 8):\n",
    "                                        bombException = True\n",
    "                            elif (df_combined.loc[i + 2, 'x'] == 2): #Note has second rightmost index\n",
    "                                if (df_combined.loc[i + 1, 'x'] == 0): #Bomb is in leftmost index\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "                            else: #Note is in second leftmost or leftmost index\n",
    "                                if df_combined.loc[i + 1, 'x'] == 3: #Bomb is in rightmost index\n",
    "                                    if (df_combined.loc[i + 2, 'd'] == 0) | (df_combined.loc[i + 2, 'd'] == 1) | (df_combined.loc[i + 2, 'd'] == 8): #Note direction is up, down, or dot\n",
    "                                        bombException = True\n",
    "\n",
    "                    #Update the minimum time after a bomb if needed\n",
    "                    if (bombException == False) & ((minReactTimeAfter == float('inf')) | (minReactTimeAfter > df_combined.loc[i + 1, '_timeChangeAfter'])):\n",
    "                        minReactTimeAfter = df_combined.loc[i + 1, '_timeChangeAfter']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Criteria Check\n",
    "#This script does not check for towers or sliders in maps that are not tech acc\n",
    "if (IsChromapper == True):\n",
    "    if (minReactTimeBefore != float('inf')):\n",
    "        minReactTimeBefore = math.floor(minReactTimeBefore * 1000)\n",
    "    if (minReactTimeAfter != float('inf')):\n",
    "        minReactTimeAfter = math.floor(minReactTimeAfter * 1000)\n",
    "    avg_sps = round(avg_sps, 2)\n",
    "    peak_sps = round(peak_sps, 2)\n",
    "    avg_true_acc_sps = round(avg_true_acc_sps, 2)\n",
    "    peak_true_acc_sps = round(peak_true_acc_sps, 2)\n",
    "    total_time = round(total_time, 2)\n",
    "\n",
    "    #General criteria checks\n",
    "\n",
    "    #Check if time between first and last note is between 2-6 minutes inclusive\n",
    "    if ((total_time < 120) | (total_time > 300)):\n",
    "        passTests = False\n",
    "        failLog += \"Fail: The time between the first and last note is \" + str(total_time) + \" seconds which is outside of the range of 120 to 300 seconds\\n\"\n",
    "    else:\n",
    "        passLog += \"Pass: The time between the first and last note is \" + str(total_time) + \" seconds which is between 120 and 300 seconds\\n\"\n",
    "    if (((df_newLeftSwing.iloc[0].loc['d'] != 1) & (df_newLeftSwing.iloc[0].loc['d'] != 8) & (df_newLeftSwing.iloc[0].loc['d'] != 6) & (df_newLeftSwing.iloc[0].loc['d'] != 7)) | ((df_newRightSwing.iloc[0].loc['d'] != 1) & (df_newRightSwing.iloc[0].loc['d'] != 8) & (df_newRightSwing.iloc[0].loc['d'] != 6) & (df_newRightSwing.iloc[0].loc['d'] != 7))):\n",
    "        passTests = False\n",
    "        failLog += \"Fail: At least one of the hands does not start on a downswing\\n\"\n",
    "    else:\n",
    "        passLog += \"Pass: Both hands start on a downswing\\n\"\n",
    "    if (num_notes < 115):\n",
    "        passTests = False\n",
    "        failLog += \"Fail: There are \" + str(num_notes) + \" notes, which is less than 115\\n\"\n",
    "    else: \n",
    "        passLog += \"Pass: There are \" + str(num_notes) + \" notes, which is at least 115\\n\"\n",
    "    if ((minReactTimeAfter != float('inf')) & (minReactTimeAfter < 200)):\n",
    "        passTests = False\n",
    "        failLog += \"Fail: The minimum reaction time after a bomb is \" + str(minReactTimeAfter) + \" miliseconds, which is less than 200\\n\"\n",
    "    else:\n",
    "        passLog += \"Pass: The minimum reaction time after a bomb is \" + str(minReactTimeAfter) + \" miliseconds, which is at least 200\\n\"\n",
    "\n",
    "    #Category specific criteria checks\n",
    "    if (category == \"True\"):\n",
    "        if (num_notes != len(df_newSwing)):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: There are sliders, stacks, towers, or windows in this map\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: There are no sliders, stacks, towers, or windows in this map\\n\"\n",
    "        if (njs > 12):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The njs is \" + str(njs) + \" which is greater than 12\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The njs is \" + str(njs) + \" which is no more than 12\\n\"\n",
    "        if ((minReactTimeBefore != float('inf')) & (minReactTimeBefore < 500)):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is less than 500\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is at least 500\\n\"\n",
    "        if (avg_true_acc_sps > 1.5):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The average sps counting doubles as one swing is \" + str(avg_true_acc_sps) + \" swings per second, which is more than 1.5\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The average sps counting doubles as one swing is \" + str(avg_true_acc_sps) + \" swings per second, which is no more than 1.5\\n\"\n",
    "        if (peak_true_acc_sps > 1.75):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The peak sps counting doubles as one swing is \" + str(peak_true_acc_sps) + \" swings per second, which is more than 1.75\\n\"\n",
    "            PrintPeakSpsLog(\"True\")\n",
    "        else:\n",
    "            passLog += \"Pass: The peak sps counting doubles as one swing is \" + str(peak_true_acc_sps) + \" swings per second, which is no more than 1.75\\n\"\n",
    "    elif (category == \"Standard\"):\n",
    "        if (njs > 16):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The njs is \" + str(njs) + \" which is greater than 16\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The njs is \" + str(njs) + \" which is no more than 16\\n\"\n",
    "        if ((minReactTimeBefore != float('inf')) & (minReactTimeBefore < 350)):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is less than 350\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is at least 350\\n\"\n",
    "        if (avg_sps > 4):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The average sps is \" + str(avg_sps) + \" which is greater than 4 sps\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The average sps is \" + str(avg_sps) + \" which is no more than 4 sps\\n\"\n",
    "        if (peak_sps > 5.75):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The peak sps is \" + str(peak_sps) + \" which is greater than 5.75 sps\\n\"\n",
    "            PrintPeakSpsLog(\"Standard\")\n",
    "        else:\n",
    "            passLog += \"Pass: The peak sps is \" + str(peak_sps) + \" which is no more than 5.75 sps\\n\"\n",
    "        if (hasSliders == True):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: This map has sliders\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: This map does not have sliders\\n\"\n",
    "    elif (category == \"Tech\"):\n",
    "        if (njs > 16):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The njs is \" + str(njs) + \" which is greater than 16\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The njs is \" + str(njs) + \" which is no more than 16\\n\"\n",
    "        if ((minReactTimeBefore != float('inf')) & (minReactTimeBefore < 300)):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is less than 300\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The minimum reaction time before a bomb is \" + str(minReactTimeBefore) + \" miliseconds, which is at least 300\\n\"\n",
    "        if (avg_sps > 4):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The average sps is \" + str(avg_sps) + \" which is greater than 4 sps\\n\"\n",
    "        else:\n",
    "            passLog += \"Pass: The average sps is \" + str(avg_sps) + \" which is no more than 4 sps\\n\"\n",
    "        if (peak_sps > 5.75):\n",
    "            passTests = False\n",
    "            failLog += \"Fail: The peak sps is \" + str(peak_sps) + \" which is greater than 5.75 sps\\n\"\n",
    "            PrintPeakSpsLog(\"Tech\")\n",
    "        else:\n",
    "            passLog += \"Pass: The peak sps is \" + str(peak_sps) + \" which is no more than 5.75 sps\\n\"\n",
    "    else:\n",
    "        print(\"Check your category variable for spelling errors\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This map passed all the Accsaber ranking critera for the Tech category that were checked! Triangles and other criteria that are obvious during playtests were not checked. If you wish to know detailed statistics about this map, run the following cell.\n"
     ]
    }
   ],
   "source": [
    "#Print command\n",
    "if (passTests == True):\n",
    "    print(\"This map passed all the Accsaber ranking critera for the \" + category + \" category that were checked! Triangles and other criteria that are obvious during playtests were not checked. If you wish to know detailed statistics about this map, run the following cell.\")\n",
    "    if (category != \"Tech\"):\n",
    "        print(\"Make sure the map has no windows.\")\n",
    "elif (passTests == False):\n",
    "    print(\"This map failed the Accsaber ranking critera for the \" + category + \" category. The failed tests that were checked are displayed below. Triangles and other criteria that are obvious during playtests were not checked. If you wish to see what tests passed, run the following cell.\\n\" + failLog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pass: The time between the first and last note is 188.75 seconds which is between 120 and 300 seconds\n",
      "Pass: Both hands start on a downswing\n",
      "Pass: There are 726 notes, which is at least 115\n",
      "Pass: The minimum reaction time after a bomb is inf miliseconds, which is at least 200\n",
      "Pass: The njs is 15.0 which is no more than 16\n",
      "Pass: The minimum reaction time before a bomb is inf miliseconds, which is at least 300\n",
      "Pass: The average sps is 3.81 which is no more than 4 sps\n",
      "Pass: The peak sps is 4.6 which is no more than 5.75 sps\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Passed tests\n",
    "print(passLog)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}