itgmania212121/src/StepParityCost.cpp

#include "global.h"
#include "StepParityCost.h"
#include "NoteData.h"
#include "TechCounts.h"
#include "GameState.h"

using namespace StepParity;

namespace {
	template <typename T>
	bool isEmpty(const std::vector<T> & vec, int columnCount) {
		for (int i = 0; i < columnCount; i++)
		{
			if(static_cast<int>(vec[i]) != 0)
			{
				return false;
			}
		}
		return true;
	}
}

float StepParityCost::getActionCost(State * initialState, State * resultState, std::vector<Row>& rows, int rowIndex, float elapsedTime)
{
	Row &row = rows[rowIndex];
	int columnCount = row.columnCount;

	float cost = 0;

	// Mine weighting
	int leftHeel = INVALID_COLUMN;
	int leftToe = INVALID_COLUMN;
	int rightHeel = INVALID_COLUMN;
	int rightToe = INVALID_COLUMN;

	for (int i = 0; i < columnCount; i++) {
	  switch (resultState->columns[i]) {
		case NONE:
		  break;
		case LEFT_HEEL:
		  leftHeel = i;
		  break;
		case LEFT_TOE:
		  leftToe = i;
		  break;
		case RIGHT_HEEL:
		  rightHeel = i;
		  break;
		case RIGHT_TOE:
		  rightToe = i;
		  break;
	  default:
		  break;
	  }
	}

	bool movedLeft =
	  resultState->didTheFootMove[LEFT_HEEL] ||
	  resultState->didTheFootMove[LEFT_TOE];

	bool movedRight =
	  resultState->didTheFootMove[RIGHT_HEEL] ||
	  resultState->didTheFootMove[RIGHT_TOE];

	// Note that this is checking whether the previous state was a jump, not whether the current state is
	bool didJump =
	  ((initialState->didTheFootMove[LEFT_HEEL] &&
		!initialState->isTheFootHolding[LEFT_HEEL]) ||
		(initialState->didTheFootMove[LEFT_TOE] &&
		  !initialState->isTheFootHolding[LEFT_TOE])) &&
	  ((initialState->didTheFootMove[RIGHT_HEEL] &&
		!initialState->isTheFootHolding[RIGHT_HEEL]) ||
		(initialState->didTheFootMove[RIGHT_TOE] &&
		  !initialState->isTheFootHolding[RIGHT_TOE]));
	
	bool jackedLeft = didJackLeft(initialState, resultState, leftHeel, leftToe, movedLeft, didJump, columnCount);
	bool jackedRight = didJackRight(initialState, resultState, rightHeel, rightToe, movedRight, didJump, columnCount);
	
	cost += calcMineCost( initialState, resultState, row, columnCount);
	cost += calcHoldSwitchCost( initialState, resultState, row, columnCount);
	cost += calcBracketTapCost( initialState, resultState, row, leftHeel, leftToe, rightHeel, rightToe, elapsedTime, columnCount);
	cost += calcBracketJackCost( initialState, resultState, rows, rowIndex, movedLeft, movedRight, jackedLeft, jackedRight, didJump, columnCount);
	cost += calcDoublestepCost(initialState, resultState, rows, rowIndex, movedLeft, movedRight, jackedLeft, jackedRight, didJump, columnCount);
	cost += calcSlowBracketCost(row, movedLeft, movedRight, elapsedTime);
	cost += calcTwistedFootCost(resultState);
	cost += calcFacingCosts( initialState, resultState, columnCount);
	cost += calcSpinCosts(initialState, resultState, columnCount);
	cost += caclFootswitchCost( initialState, resultState, row, elapsedTime, columnCount);
	cost += calcSideswitchCost( initialState, resultState, columnCount);
	cost += calcMissedFootswitchCost( row, jackedLeft, jackedRight, columnCount);
	cost += calcJackCost( movedLeft, movedRight, jackedLeft, jackedRight, elapsedTime, columnCount);
	cost += calcBigMovementsQuicklyCost( initialState, resultState, elapsedTime, columnCount);

	return cost;
}

// Calculate the cost of avoiding a mine before the current step
// If a mine occurred just before a step, add to the cost
// ex:
// 00M0
// 0010 <- add cost
//
// 00M0
// 0100 <- no cost
float StepParityCost::calcMineCost(State * initialState, State * resultState, Row &row, int columnCount)
{
	float cost = 0;

	for (int i = 0; i < columnCount; i++) {
		if (resultState->combinedColumns[i] != NONE && row.mines[i] != 0) {
			cost += MINE;
			break;
		}
	}
	return cost;
}

// Calculate a cost from having to switch feet in the middle of a hold.
// Multiply the HOLDSWITCH cost by the distance that the "intial" foot
// that was holding the note had to travel to it's new position.
// If the initial foot doesn't move anywhere, then don't mulitply it by anything.
float StepParityCost::calcHoldSwitchCost(State * initialState, State * resultState, Row &row, int columnCount)
{
	float cost = 0;
	for (int c = 0; c < columnCount; c++)
	{
		if (row.holds[c].type == TapNoteType_Empty)
			continue;
		if (
			((resultState->combinedColumns[c] == LEFT_HEEL ||
			  resultState->combinedColumns[c] == LEFT_TOE) &&
			 initialState->combinedColumns[c] != LEFT_TOE &&
			 initialState->combinedColumns[c] != LEFT_HEEL) ||
			((resultState->combinedColumns[c] == RIGHT_HEEL ||
			  resultState->combinedColumns[c] == RIGHT_TOE) &&
			 initialState->combinedColumns[c] != RIGHT_TOE &&
			 initialState->combinedColumns[c] != RIGHT_HEEL)) {
		int previousFoot =initialState->whereTheFeetAre[resultState->combinedColumns[c]];
		cost +=
		  HOLDSWITCH *
		  (previousFoot == INVALID_COLUMN
			? 1
			: sqrt(
				layout.getDistanceSq(c, previousFoot)
			  ));
	  }
	}
	return cost;
}

// Calculate the cost of tapping a bracket during a hold note
//
// ex:
// 0200
// 0000
// 1000 <- maybe bracketable, if left heel is holding Down arrow
// 0300

float StepParityCost::calcBracketTapCost(State * initialState, State * resultState, Row &row, int leftHeel, int leftToe, int rightHeel, int rightToe, float elapsedTime, int columnCount)
{
	// Small penalty for trying to jack a bracket during a hold
	float cost = 0;
	if (leftHeel != INVALID_COLUMN && leftToe != INVALID_COLUMN)
	{
		float jackPenalty = 1;
		if (
			initialState->didTheFootMove[LEFT_HEEL] ||
			initialState->didTheFootMove[LEFT_TOE])
			jackPenalty = 1 / elapsedTime;
		if (
			row.holds[leftHeel].type != TapNoteType_Empty &&
			row.holds[leftToe].type == TapNoteType_Empty) {
		cost += BRACKETTAP * jackPenalty;
	  }
	  if (
		row.holds[leftToe].type != TapNoteType_Empty &&
		row.holds[leftHeel].type == TapNoteType_Empty
	  ) {
		cost += BRACKETTAP * jackPenalty;
	  }
	}

	if (rightHeel != INVALID_COLUMN && rightToe != INVALID_COLUMN) {
	  float jackPenalty = 1;
	  if (
		initialState->didTheFootMove[RIGHT_TOE] ||
		initialState->didTheFootMove[RIGHT_HEEL]
	  )
		jackPenalty = 1 / elapsedTime;

	  if (
		row.holds[rightHeel].type != TapNoteType_Empty &&
		row.holds[rightToe].type == TapNoteType_Empty
	  ) {
		cost += BRACKETTAP * jackPenalty;
	  }
	  if (
		row.holds[rightToe].type != TapNoteType_Empty &&
		row.holds[rightHeel].type == TapNoteType_Empty
	  ) {
		cost += BRACKETTAP * jackPenalty;
	  }
	}
	return cost;
}

// Calculate a cost for moving the same foot while the other
// isn't on the pad.
//
float StepParityCost::calcMovingFootWhileOtherIsntOnPadCost(State * initialState, State * resultState, int columnCount)
{
	float cost = 0;
	// Weighting for moving a foot while the other isn't on the pad (so marked doublesteps are less bad than this)
	if (std::any_of(initialState->combinedColumns.begin(), initialState->combinedColumns.end(), [](Foot elem) { return elem != NONE;  }))
	{
		for (auto f : resultState->movedFeet)
		{
			switch (f)
			{
			case LEFT_HEEL:
			case LEFT_TOE:
				if (
					!(
						initialState->whereTheFeetAre[RIGHT_HEEL] != INVALID_COLUMN ||
						initialState->whereTheFeetAre[RIGHT_TOE] != INVALID_COLUMN))
					cost += OTHER;
				break;
			case RIGHT_HEEL:
			case RIGHT_TOE:
				if (
					!(
						initialState->whereTheFeetAre[LEFT_HEEL] != INVALID_COLUMN ||
						initialState->whereTheFeetAre[LEFT_TOE] != INVALID_COLUMN))
					cost += OTHER;
				break;
			default:
				break;
			}
		}
	}
	return cost;
}

float StepParityCost::calcBracketJackCost(State * initialState, State * resultState, std::vector<Row> & rows, int rowIndex, bool movedLeft, bool movedRight, bool jackedLeft, bool jackedRight, bool didJump, int columnCount)
{
	float cost = 0;
	if (
		movedLeft != movedRight &&
		(movedLeft || movedRight) &&
		isEmpty(resultState->holdFeet, columnCount) &&
		!didJump)
	{

	  if (
		jackedLeft &&
		resultState->didTheFootMove[LEFT_HEEL] &&
		resultState->didTheFootMove[LEFT_TOE]
	  ) {
		cost += BRACKETJACK;
	  }

	  if (
		jackedRight &&
		resultState->didTheFootMove[RIGHT_HEEL] &&
		resultState->didTheFootMove[RIGHT_TOE]
	  ) {
		cost += BRACKETJACK;
	  }
	}
	return cost;
}

float StepParityCost::calcDoublestepCost(State * initialState, State * resultState, std::vector<Row> & rows, int rowIndex, bool movedLeft, bool movedRight, bool jackedLeft, bool jackedRight, bool didJump, int columnCount)
{
	float cost = 0;
	if (
		movedLeft != movedRight &&
		(movedLeft || movedRight) &&
		isEmpty(resultState->holdFeet, columnCount) &&
		!didJump)
	{
		bool doublestepped = didDoubleStep(initialState, resultState, rows, rowIndex, movedLeft, jackedLeft, movedRight, jackedRight, columnCount);

		if (doublestepped) {
			cost += DOUBLESTEP;
		}
	}
	return cost;

}
float StepParityCost::calcJumpCost(Row & row, bool movedLeft, bool movedRight, float elapsedTime, int columnCount)
{
	float cost = 0;
	if (
		movedLeft &&
		movedRight &&
		std::count_if(row.notes.begin(), row.notes.end(), [](StepParity::IntermediateNoteData note)
					  { return note.type != TapNoteType_Empty; }) >= 2)
	{
		cost += JUMP / elapsedTime;
	}

	return cost;
}

// Jumps should be prioritized over brackets below a certain speed
float StepParityCost::calcSlowBracketCost(Row & row, bool movedLeft, bool movedRight, float elapsedTime)
{
	float cost = 0;
	if(elapsedTime > SLOW_BRACKET_THRESHOLD && movedLeft != movedRight &&
	   std::count_if(row.notes.begin(), row.notes.end(), [](StepParity::IntermediateNoteData note)
					 { return note.type != TapNoteType_Empty; }) >= 2)
	{
		float timediff = elapsedTime - SLOW_BRACKET_THRESHOLD;
		cost += timediff * SLOW_BRACKET;
	}
	return cost;
}

// Does this placement result in one of the feet being twisted around?
// This should probably be getting filtered out as an invalid positioning before
// we even get to calculating costs.
float StepParityCost::calcTwistedFootCost(State * resultState)
{
	float cost = 0;
	int leftHeel = resultState->whatNoteTheFootIsHitting[LEFT_HEEL];
	int leftToe = resultState->whatNoteTheFootIsHitting[LEFT_TOE];
	int rightHeel = resultState->whatNoteTheFootIsHitting[RIGHT_HEEL];
	int rightToe = resultState->whatNoteTheFootIsHitting[RIGHT_TOE];

	StagePoint leftPos = layout.averagePoint(leftHeel, leftToe);
	StagePoint rightPos = layout.averagePoint(rightHeel, rightToe);

	bool crossedOver = rightPos.x < leftPos.x;
	bool rightBackwards = rightHeel != INVALID_COLUMN && rightToe != INVALID_COLUMN ? layout.columns[rightToe].y < layout.columns[rightHeel].y : false;
	bool leftBackwards = leftHeel != INVALID_COLUMN && leftToe != INVALID_COLUMN ? layout.columns[leftToe].y < layout.columns[leftHeel].y : false;

	if(!crossedOver && (rightBackwards || leftBackwards))
	{
		cost += TWISTED_FOOT;
	}
	return cost;
}

float StepParityCost::calcMissedFootswitchCost(Row & row, bool jackedLeft, bool jackedRight, int columnCount)
{
	float cost = 0;
	if (
		(jackedLeft || jackedRight) &&
		(std::any_of(row.mines.begin(), row.mines.end(), [](int mine)
					 { return mine != 0; }) ||
		 std::any_of(row.fakeMines.begin(), row.fakeMines.end(), [](int mine)
					 { return mine != 0; })))
	{
		cost += MISSED_FOOTSWITCH;
	}

	return cost;
}

float StepParityCost::calcFacingCosts(State * initialState, State * resultState, int columnCount)
{

	float cost = 0;

	int endLeftHeel = INVALID_COLUMN;
	int endLeftToe = INVALID_COLUMN;
	int endRightHeel = INVALID_COLUMN;
	int endRightToe = INVALID_COLUMN;

	for (int i = 0; i < columnCount; i++) {
	  switch (resultState->combinedColumns[i]) {
		case NONE:
		  break;
		case LEFT_HEEL:
		  endLeftHeel = i;
		  break;
		case LEFT_TOE:
		  endLeftToe = i;
		  break;
		case RIGHT_HEEL:
		  endRightHeel = i;
		  break;
		case RIGHT_TOE:
		  endRightToe = i;
		default:
		  break;
	  }
	}

	if (endLeftToe == INVALID_COLUMN) endLeftToe = endLeftHeel;
	if (endRightToe == INVALID_COLUMN) endRightToe = endRightHeel;

	// facing backwards gives a bit of bad weight (scaled heavily the further back you angle, so crossovers aren't Too bad; less bad than doublesteps)
	float heelFacing =
	  endLeftHeel != INVALID_COLUMN && endRightHeel != INVALID_COLUMN
		? layout.getXDifference(endLeftHeel, endRightHeel)
		: 0;
	float toeFacing =
	  endLeftToe != INVALID_COLUMN && endRightToe != INVALID_COLUMN
		? layout.getXDifference(endLeftToe, endRightToe)
		: 0;
	float leftFacing =
	  endLeftHeel != INVALID_COLUMN && endLeftToe != INVALID_COLUMN
		? layout.getYDifference(endLeftHeel, endLeftToe)
		: 0;
	float rightFacing =
	  endRightHeel != INVALID_COLUMN && endRightToe != INVALID_COLUMN
		? layout.getYDifference(endRightHeel, endRightToe)
		: 0;


	float heelFacingPenalty = pow(-1 * std::min(heelFacing, 0.0f), 1.8) * 100;
	float toesFacingPenalty = pow(-1 * std::min(toeFacing, 0.0f), 1.8) * 100;
	float leftFacingPenalty = pow(-1 * std::min(leftFacing, 0.0f), 1.8) * 100;
	float rightFacingPenalty = pow(-1 * std::min(rightFacing, 0.0f), 1.8) * 100;


	if (heelFacingPenalty > 0)
		cost += heelFacingPenalty * FACING;
	if (toesFacingPenalty > 0)
		cost += toesFacingPenalty * FACING;
	if (leftFacingPenalty > 0)
		cost += leftFacingPenalty * FACING;
	if (rightFacingPenalty > 0)
		cost += rightFacingPenalty * FACING;

	return cost;
}

float StepParityCost::calcSpinCosts(State * initialState, State * resultState, int columnCount)
{
	float cost = 0;

	int endLeftHeel = INVALID_COLUMN;
	int endLeftToe = INVALID_COLUMN;
	int endRightHeel = INVALID_COLUMN;
	int endRightToe = INVALID_COLUMN;

	for (int i = 0; i < columnCount; i++) {
	  switch (resultState->combinedColumns[i]) {
		case NONE:
		  break;
		case LEFT_HEEL:
		  endLeftHeel = i;
		  break;
		case LEFT_TOE:
		  endLeftToe = i;
		  break;
		case RIGHT_HEEL:
		  endRightHeel = i;
		  break;
		case RIGHT_TOE:
		  endRightToe = i;
		default:
		  break;
	  }
	}

	if (endLeftToe == INVALID_COLUMN) endLeftToe = endLeftHeel;
	if (endRightToe == INVALID_COLUMN) endRightToe = endRightHeel;

	// spin
	StagePoint previousLeftPos = layout.averagePoint(
	 initialState->whereTheFeetAre[LEFT_HEEL],
	 initialState->whereTheFeetAre[LEFT_TOE]
	);
	StagePoint previousRightPos = layout.averagePoint(
	 initialState->whereTheFeetAre[RIGHT_HEEL],
	 initialState->whereTheFeetAre[RIGHT_TOE]
	);
	StagePoint leftPos = layout.averagePoint(endLeftHeel, endLeftToe);
	StagePoint rightPos = layout.averagePoint(endRightHeel, endRightToe);

	if (
	  rightPos.x < leftPos.x &&
	  previousRightPos.x < previousLeftPos.x &&
	  rightPos.y < leftPos.y &&
	  previousRightPos.y > previousLeftPos.y
	) {
	  cost += SPIN;
	}
	if (
	  rightPos.x < leftPos.x &&
	  previousRightPos.x < previousLeftPos.x &&
	  rightPos.y > leftPos.y &&
	  previousRightPos.y < previousLeftPos.y
	) {
	  cost += SPIN;
	}
	return cost;
}

// Footswitches are harder to do when they get too slow.
// Notes with an elapsed time greater than this will incur a penalty
float StepParityCost::caclFootswitchCost(State * initialState, State * resultState, Row & row, float elapsedTime, int columnCount)
{
	float cost = 0;
	if (elapsedTime >= SLOW_FOOTSWITCH_THRESHOLD && elapsedTime < SLOW_FOOTSWITCH_IGNORE) {
		// footswitching has no penalty if there's a mine nearby
		if (
			std::all_of(row.mines.begin(), row.mines.end(), [](int mine)
						{ return mine == 0; }) &&
			std::all_of(row.fakeMines.begin(), row.fakeMines.end(), [](int mine)
						{ return mine == 0; }))
		{
			float timeScaled = elapsedTime - SLOW_FOOTSWITCH_THRESHOLD;

			for (int i = 0; i < columnCount; i++)
			{
				if (
					initialState->combinedColumns[i] == NONE ||
					resultState->columns[i] == NONE)
					continue;

				if (
					initialState->combinedColumns[i] != resultState->columns[i] &&
					initialState->combinedColumns[i] != OTHER_PART_OF_FOOT[resultState->columns[i]]
					)
				{
					cost += (timeScaled / (SLOW_FOOTSWITCH_THRESHOLD + timeScaled)) * FOOTSWITCH;
					break;
				}
			}
		}
	}
	  return cost;
}

float StepParityCost::calcSideswitchCost(State * initialState, State * resultState, int columnCount)
{
	float cost = 0;
	for(auto c : layout.sideArrows)
	{
		if (
			initialState->combinedColumns[c] != resultState->columns[c] &&
			resultState->columns[c] != NONE &&
			initialState->combinedColumns[c] != NONE &&
			!resultState->didTheFootMove[initialState->combinedColumns[c]])
		{
			cost += SIDESWITCH;
		}
	}
	return cost;
}

// Jacks are harder to do the faster they are.
// Add a penalty when they get faster than 16ths at 150bpm (0.1 seconds)
float StepParityCost::calcJackCost(bool movedLeft, bool movedRight, bool jackedLeft, bool jackedRight, float elapsedTime, int columnCount)
{
	float cost = 0;
	// weighting for jacking two notes too close to eachother
	if (elapsedTime < JACK_THRESHOLD && movedLeft != movedRight) {
	  float timeScaled = JACK_THRESHOLD - elapsedTime;
	  if (jackedLeft || jackedRight) {
		cost += (1 / timeScaled - 1 / JACK_THRESHOLD) * JACK;
	  }
	}

	return cost;
}

float StepParityCost::calcBigMovementsQuicklyCost(State * initialState, State * resultState, float elapsedTime, int columnCount)
{
	float cost = 0;
	for (StepParity::Foot foot : resultState->movedFeet)
	{
		if(foot == NONE)
		{
			continue;
		}

		int initialPosition = initialState->whereTheFeetAre[foot];
		if(initialPosition == INVALID_COLUMN)
		{
			continue;
		}

		int resultPosition = resultState->whatNoteTheFootIsHitting[foot];


		// If we're bracketing something, and the toes are now where the heel
		// was, then we don't need to worry about it, we're not actually moving
		// the foot very far
		bool isBracketing = resultState->whatNoteTheFootIsHitting[OTHER_PART_OF_FOOT[foot]] != INVALID_COLUMN;
		if(isBracketing && resultState->whatNoteTheFootIsHitting[OTHER_PART_OF_FOOT[foot]] == initialPosition)
		{
			continue;
		}

		float dist = (sqrt(layout.getDistanceSq(initialPosition, resultPosition)) * DISTANCE) / elapsedTime;
		// Otherwise if we're still bracketing, this is probably a less drastic movement
		if(isBracketing)
		{
			dist = dist * 0.2;
		}
		cost += dist;
	}

	return cost;
}

// Are we trying to bracket a column that the other foot was just on,
// or are we trying to hit a note that the other foot was just bracketing?

float StepParityCost::calcCrowdedBracketCost(State * initialState, State * resultState, float elapsedTime, int columnCount)
{
	float cost = 0;

	bool resultLeftBracket = resultState->whatNoteTheFootIsHitting[LEFT_HEEL] > INVALID_COLUMN && resultState->whatNoteTheFootIsHitting[LEFT_TOE] > INVALID_COLUMN;
	bool resultRightBracket = resultState->whatNoteTheFootIsHitting[RIGHT_HEEL] > INVALID_COLUMN && resultState->whatNoteTheFootIsHitting[RIGHT_TOE] > INVALID_COLUMN;

	bool initialLeftBracket = initialState->whereTheFeetAre[LEFT_HEEL] > INVALID_COLUMN && initialState->whereTheFeetAre[LEFT_TOE] > INVALID_COLUMN;
	bool initialRightBracket = initialState->whereTheFeetAre[RIGHT_HEEL] > INVALID_COLUMN && initialState->whereTheFeetAre[RIGHT_TOE] > INVALID_COLUMN;

	// if we're trying to bracket with left foot, does it overlap the right foot
	// in previous state?
	if(
	   (resultLeftBracket)
	   && (
		   initialState->combinedColumns[resultState->whatNoteTheFootIsHitting[LEFT_HEEL]] == RIGHT_HEEL ||
		   initialState->combinedColumns[resultState->whatNoteTheFootIsHitting[LEFT_HEEL]] == RIGHT_TOE ||
		   initialState->combinedColumns[resultState->whatNoteTheFootIsHitting[LEFT_TOE]] == RIGHT_HEEL ||
		   initialState->combinedColumns[resultState->whatNoteTheFootIsHitting[LEFT_TOE]] == RIGHT_TOE
		   )
	   )
	{
		cost += CROWDED_BRACKET / elapsedTime;
	}
	else if(initialLeftBracket
		&& (
			resultState->columns[initialState->whereTheFeetAre[LEFT_HEEL]] == RIGHT_HEEL ||
			resultState->columns[initialState->whereTheFeetAre[LEFT_HEEL]] == RIGHT_TOE ||
			resultState->columns[initialState->whereTheFeetAre[LEFT_TOE]] == RIGHT_HEEL ||
			resultState->columns[initialState->whereTheFeetAre[LEFT_TOE]] == RIGHT_TOE
			)
		)
	{
		cost += CROWDED_BRACKET / elapsedTime;
	}

	// and if we're trying to bracket with right foot, does it overlap the left ?
	if((resultRightBracket )
	   && (
		   initialState->combinedColumns[resultState->whatNoteTheFootIsHitting[RIGHT_HEEL]] == LEFT_HEEL ||
		   initialState->combinedColumns[resultState->whatNoteTheFootIsHitting[RIGHT_HEEL]] == LEFT_TOE ||
		   initialState->combinedColumns[resultState->whatNoteTheFootIsHitting[RIGHT_TOE]] == LEFT_HEEL ||
		   initialState->combinedColumns[resultState->whatNoteTheFootIsHitting[RIGHT_TOE]] == LEFT_TOE
		   )
	   )
	{
		cost += CROWDED_BRACKET / elapsedTime;
	}
	else if( initialRightBracket
		&& (
			resultState->columns[initialState->whereTheFeetAre[RIGHT_HEEL]] == LEFT_HEEL ||
			resultState->columns[initialState->whereTheFeetAre[RIGHT_HEEL]] == LEFT_TOE ||
			resultState->columns[initialState->whereTheFeetAre[RIGHT_TOE]] == LEFT_HEEL ||
			resultState->columns[initialState->whereTheFeetAre[RIGHT_TOE]] == LEFT_TOE
			)
		)
	{
		cost += CROWDED_BRACKET / elapsedTime;
	}

	return cost;
}


bool StepParityCost::didDoubleStep(State * initialState, State * resultState, std::vector<Row> & rows, int rowIndex, bool movedLeft, bool jackedLeft, bool movedRight, bool jackedRight, int columnCount)
{
	Row &row = rows[rowIndex];
	bool doublestepped = false;
	if (
		movedLeft &&
		!jackedLeft &&
		((initialState->didTheFootMove[LEFT_HEEL] &&
		  !initialState->isTheFootHolding[LEFT_HEEL]) ||
		 (initialState->didTheFootMove[LEFT_TOE] &&
		  !initialState->isTheFootHolding[LEFT_TOE])))
	{
		doublestepped = true;
	}
	  if (
		movedRight &&
		!jackedRight &&
		((initialState->didTheFootMove[RIGHT_HEEL] &&
		  !initialState->isTheFootHolding[RIGHT_HEEL]) ||
		  (initialState->didTheFootMove[RIGHT_TOE] &&
			!initialState->isTheFootHolding[RIGHT_TOE]))
	  )
		doublestepped = true;


	  if (rowIndex - 1 > -1)
	  {
		StepParity::Row &lastRow = rows[rowIndex - 1];
		for (StepParity::IntermediateNoteData hold: lastRow.holds) {
		  if (hold.type == TapNoteType_Empty) continue;
		  float endBeat = row.beat;
		  float startBeat = lastRow.beat;
		  // if a hold tail extends past the last row & ends in between, we can doublestep
		  if (
			hold.beat + hold.hold_length > startBeat &&
			hold.beat + hold.hold_length < endBeat
		  )
			doublestepped = false;
		  // if the hold tail extends past this row, we can doublestep
		  if (hold.beat + hold.hold_length >= endBeat) doublestepped = false;
		}
	  }
	  return doublestepped;
}

bool StepParityCost::didJackLeft(State * initialState, State * resultState, int leftHeel, int leftToe, bool movedLeft, bool didJump, int columnCount)
{
	bool jackedLeft = false;
	if(!didJump && movedLeft)
	{

			if ( leftHeel > INVALID_COLUMN &&
			initialState->combinedColumns[leftHeel] == LEFT_HEEL &&
			!resultState->isTheFootHolding[LEFT_HEEL] &&
			((initialState->didTheFootMove[LEFT_HEEL] &&
				!initialState->isTheFootHolding[LEFT_HEEL]) ||
				(initialState->didTheFootMove[LEFT_TOE] &&
				!initialState->isTheFootHolding[LEFT_TOE]))
				) {
				jackedLeft = true;
			}
			if (
				leftToe > INVALID_COLUMN &&
			initialState->combinedColumns[leftToe] == LEFT_TOE &&
			!resultState->isTheFootHolding[LEFT_TOE] &&
			((initialState->didTheFootMove[LEFT_HEEL] &&
				!initialState->isTheFootHolding[LEFT_HEEL]) ||
				(initialState->didTheFootMove[LEFT_TOE] &&
				!initialState->isTheFootHolding[LEFT_TOE]))
				){
					jackedLeft = true;
				}

	}
	return jackedLeft;
}

bool StepParityCost::didJackRight(State * initialState, State * resultState, int rightHeel, int rightToe, bool movedRight, bool didJump, int columnCount)
{
	bool jackedRight = false;
	if(!didJump && movedRight)
	{
		if ( rightHeel > INVALID_COLUMN &&
		  initialState->combinedColumns[rightHeel] == RIGHT_HEEL &&
		  !resultState->isTheFootHolding[RIGHT_HEEL] &&
		  ((initialState->didTheFootMove[RIGHT_HEEL] &&
			!initialState->isTheFootHolding[RIGHT_HEEL]) ||
			(initialState->didTheFootMove[RIGHT_TOE] &&
			  !initialState->isTheFootHolding[RIGHT_TOE]))
			) {
				jackedRight = true;
			}
		if ( rightToe > INVALID_COLUMN &&
		  initialState->combinedColumns[rightToe] == RIGHT_TOE &&
		  !resultState->isTheFootHolding[RIGHT_TOE] &&
		  ((initialState->didTheFootMove[RIGHT_HEEL] &&
			!initialState->isTheFootHolding[RIGHT_HEEL]) ||
			(initialState->didTheFootMove[RIGHT_TOE] &&
			  !initialState->isTheFootHolding[RIGHT_TOE]))
			) {
				jackedRight = true;
			}
	}
	return jackedRight;
}