crimboMining.ash

script "crimboMining.ash";
notify bombar;
since r15029;

string version = "1.14";

int maxFailsAllowed = 1; //How much bigger a set of continout interesting points can be more then 6, if you were to explore all in bigger chains, you are guarnteed a cave in
int maxCaves = 200; //Max caves to check against, mainly to solve for infinite loops just in case
boolean requireFreeMining = true; //Whether to force no turn used
boolean useDynamite = false;//Whether to use minin' dynamite
int numTurnsToLeave = 0;//How many turns you want to have left when finished mining, only applies if requireFreeMining=false

int delayBetweenMines = 0;//In seconds, This will allow you to add delays after each mining attempt, used to spread out server load espically if you are starting script and letting it run while you go do other things and don't care when it finishes

int maxExtraNuggets = -1;//Set to -1 if you don't want to use this value and just mine as many nuggets as you can

boolean mineOnlyPeppermints = false;//With this you can skip mining nuggets entirely since Jick has stated you will only need enough nuggets as you have molds
int minNumberTailingsPerCave = 3;//Number of tailing you want to get from each cave at a mininum, set to 26 if you want to get all of them (6 nuggets, 4 cave ins, 26 tailings per cave)

boolean useMafiaRestore = false;//Whether to use kol's healing script, if set to false will attempt custom logic to heal a point

//Determines if you will use a healing skill or just go to docs, a value of $skill[none] means goto doc, otherwise attempt to use skill provided, if that doesn't work then it will still go to docs
skill healingSkill = $skill[none];//Note only used if useMafiaRestore = false;
//copy and paste one of these skills over $skill[none] to try to use that skill before heading to docs, should work with non-listed skills just adding them for ease of use
//$skill[saucy salve], $skill[lasagna bandages], $skill[tongue of the walrus], $skill[cannelloni cocoon], $skill[shake it off]

record Spot {
	int row;
	int col;
	int counter;
	boolean isInteresting;
	boolean checkedForChain;
	int numDirects;
	int costToGetTo;
	boolean isCaveIn;
	string shortestRoute;
	boolean mined;
};

record Chain {
	int numSpotsInChain;
	Spot[int] spotsInChain;
	Spot entryPoint;
};

record Mine {
	Chain currentLongestChain;
	Spot[int] interestingSpots;
	Spot[int][int] spots;
	int nuggetsFound;
	int tailingsFound;
	Spot[int] tailingSpotsChecked;
};

record MiningOperation {
	int startingNumNuggets;
	int startingNumTailings;
	int numCavesSkipped;
	int numCavesFullyExplored;
	int numCaveIns;
	int numOilyLegsAtStart;
	int startTime;
};

Spot newSpot(int counter, int col, int row) {
	Spot result = new Spot();
	result.col = col;
	result.row = row;
	result.counter = counter;
	result.isInteresting = false;
	result.numDirects = 0;
	result.costToGetTo = 10000;
	result.isCaveIn = false;
	result.checkedForChain = false;
	result.shortestRoute = "";
	result.mined = false;
	return result;
}

Chain newChain() {
	Chain newChain = new Chain();
	newChain.numSpotsInChain = 0;
	clear(newChain.spotsInChain);
	return newChain;
}


Mine newMine() {
	Mine result = new Mine();
	result.currentLongestChain = newChain();
	clear(result.interestingSpots);
	clear(result.spots);
	result.nuggetsFound = 0;
	result.tailingsFound = 0;
	return result;
}

Mine currentMine;
MiningOperation currentOperation;

string printSpot(Spot currentSpot) {
	buffer result;
	result.append("(");
	result.append(currentSpot.col);
	result.append(",");
	result.append(currentSpot.row);
	result.append(")");
	return result;
}

void restoreMinHP() {
	if (useMafiaRestore) {
		restore_hp(1);
	} else if (healingSkill != $skill[none]) {
		//Attempt to use skill
		if (my_mp() > mp_cost(healingSkill))
			use_skill(healingSkill);
	}

	if (my_hp() == 0) {
		if (my_meat() < 10)
			abort("Don't have enought meat to heal");

		cli_execute("galaktik hp 1"); //Thanks to Ezandora for pointing this out.
	}
}

void restore_outfit(){
	outfit("Backup");
}

void endMiningOperation() {
	restore_outfit();
	int numNuggets = item_amount($item[nugget of Crimbonium]) - currentOperation.startingNumNuggets;
	int numTailings = item_amount($item[peppermint tailings]) - currentOperation.startingNumTailings;

	int numMSTaken = gametime_to_int() - currentOperation.startTime;
	float numSecondsTaken = numMSTaken / 1000;

	print("Number of Fully Explored Caves: " + currentOperation.numCavesFullyExplored, "blue");
	print("Number of Caves Skipped because chain to large: " + currentOperation.numCavesSkipped, "blue");
	print("Number of Cave Ins that occurred: " + currentOperation.numCaveIns, "blue");
	print("Number of " + $item[peppermint tailings] + " found: " + numTailings, "blue");
	print("Number of " + $item[nugget of Crimbonium] + " found: " + numNuggets, "blue");
	print("Number of seconds it took: " + numSecondsTaken, "blue");
}

void abortMining(string reason) {
	endMiningOperation();
	abort(reason);
}
void processSpotForChain(Chain currentChain, Spot currentSpot) {
	//Add to chain, marked off as being checked
	int numInChain = count(currentChain.spotsInChain);
	currentChain.spotsInChain[numInChain] = currentSpot;
	currentSpot.checkedForChain = true;

	int row = currentSpot.row;
	int col = currentSpot.col;

	//Check Left
	if (col != 1) {
		Spot checkSpot = currentMine.spots[col - 1][row];
		if (checkSpot.isInteresting) {
			currentSpot.numDirects += 1;
			if (!checkSpot.checkedForChain)
				processSpotForChain(currentChain, checkSpot);
		}
	}

	//Check Right
	if (col != 6) {
		Spot checkSpot = currentMine.spots[col + 1][row];
		if (checkSpot.isInteresting) {
			currentSpot.numDirects += 1;
			if (!checkSpot.checkedForChain)
				processSpotForChain(currentChain, checkSpot);
		}
	}

	//Check Above
	if (row != 1) {
		Spot checkSpot = currentMine.spots[col][row - 1];
		if (checkSpot.isInteresting) {
			currentSpot.numDirects += 1;
			if (!checkSpot.checkedForChain)
				processSpotForChain(currentChain, checkSpot);
		}
	}

	//Check Below
	if (row != 6) {
		Spot checkSpot = currentMine.spots[col][row + 1];
		if (checkSpot.isInteresting) {
			currentSpot.numDirects += 1;
			if (!checkSpot.checkedForChain)
				processSpotForChain(currentChain, checkSpot);
		}
	}


}

void calculateLongestChain() {
	Chain currentChain = newChain();
	Spot currentSpot;
	foreach spotNdx in currentMine.interestingSpots {
		currentSpot = currentMine.interestingSpots[spotNdx];
		if (currentSpot.isInteresting && !currentSpot.checkedForChain) {
			processSpotForChain(currentChain, currentSpot);
		}

		if (count(currentChain.spotsInChain) >= 6) // Found the chain we need, only chains 6 and longer here are the ones we are looking for
			break;
		else {
			foreach tmpSpotNdx in currentChain.spotsInChain {
				Spot tmpSpot = currentChain.spotsInChain[tmpSpotNdx];
				tmpSpot.isCaveIn = true;
			}
		}
	}

	currentMine.currentLongestChain = currentChain;

	foreach spotNdx in currentMine.interestingSpots {
		currentSpot = currentMine.interestingSpots[spotNdx];
		if (currentSpot.isInteresting && !currentSpot.checkedForChain)
			currentSpot.isCaveIn = true;
	}
}

void parseMine() {
	//string page = visit_url("place.php?whichplace=desertbeach&action=db_crimbo14mine");
	buffer page = visit_url("mining.php?mine=5");
	if (page.contains_text("<table cellpadding=0 cellspacing=0 border=0 background=")) {
		page.substring(page.index_of("<table cellpadding=0 cellspacing=0 border=0 background="));
		for counter from 0 to 54 {
			int rowNdx = counter / 8;
			int colNdx = counter % 8;
			if (rowNdx > 0 && rowNdx < 7) {
				if (colNdx > 0 && colNdx < 7) {
					Spot newSpot = newSpot(counter, colNdx, rowNdx);
					currentMine.spots[colNdx][rowNdx] = newSpot;

					if (page.contains_text("Promising Chunk of Wall (" + colNdx + "," + rowNdx + ")")) {
						currentMine.interestingSpots[count(currentMine.interestingSpots)] = newSpot;
						newSpot.isInteresting = true;
						if (rowNdx >= 5)
							newSpot.isCaveIn = true;
					}
				}
			}
		}
	}
}

void figureRoute() {
	int cheapestPath = 100000;
	Spot firstSpot;

	foreach spotNdx in currentMine.currentLongestChain.spotsInChain {
		Spot currentSpot = currentMine.currentLongestChain.spotsInChain[spotNdx];
		if (currentSpot.costToGetTo < cheapestPath){
			cheapestPath = currentSpot.costToGetTo;
			firstSpot = currentSpot;
			currentMine.currentLongestChain.entryPoint = currentSpot;
		}
	}

	//print("Starting point will be: " + printSpot(firstSpot) + " path: " + firstSpot.shortestRoute);
}

void printMine() {
	for rowNdx from 1 to 6 {
	if (rowNdx == 1)
		print("=======================================");
	else
		print("----------------------------------------");
	buffer row;
	row.append("| ");

	for colNdx from 1 to 6 {
		if (currentMine.spots[colNdx][rowNdx].isCaveIn)
			row.append(" c ");
		else if (currentMine.spots[colNdx][rowNdx].isInteresting)
			row.append(" " + currentMine.spots[colNdx][rowNdx].numDirects + " ");
		else
			row.append(" X ");
		row.append(" |");
	}
	print(row);

	}
}

void printPaths() {
	for rowNdx from 1 to 6 {
		if (rowNdx == 1)
			print("=======================================");
		else
			print("----------------------------------------");
		buffer row;
		row.append("| ");

		for colNdx from 1 to 6 {
			row.append(" " + currentMine.spots[colNdx][rowNdx].costToGetTo + " ");
			row.append(" |");
		}
		print(row);

	}

}

void calcPathsFromSpot(Spot currentSpot, string pathSoFar, int lengthSoFar) {
	int increment = 1;
	if (currentSpot.isCaveIn)
		increment = 6;

	int tmpLength = lengthSoFar + increment;
	if (tmpLength < currentSpot.costToGetTo) {
		currentSpot.costToGetTo = tmpLength;
		pathSoFar = pathSoFar + currentSpot.counter +  ";";
		currentSpot.shortestRoute = pathSoFar;
		if (currentSpot.col > 1)
			calcPathsFromSpot(currentMine.spots[currentSpot.col - 1][currentSpot.row], pathSoFar, currentSpot.costToGetTo);
		if (currentSpot.row > 1)
			calcPathsFromSpot(currentMine.spots[currentSpot.col][currentSpot.row - 1], pathSoFar, currentSpot.costToGetTo);
		if (currentSpot.col < 6)
			calcPathsFromSpot(currentMine.spots[currentSpot.col + 1][currentSpot.row], pathSoFar, currentSpot.costToGetTo);
	}
}

void calcShortestPathsToAllSpots() {
	for colNdx from 1 to 6 by 1 {
		Spot startSpot = currentMine.spots[colNdx][6];
		calcPathsFromSpot(startSpot, "", 0);
	}
}


void gotoNextMine() {
	visit_url("mining.php?mine=5&reset=1&pwd");
	currentMine = newMine();
}

void mineSpot(Spot spotToMine) {
	if (my_hp() == 0) {
		restoreMinHP();
	}

	int numDynamite = item_amount($item[minin' dynamite]);
	int numTurnsOilyLegs = have_effect($effect[oily legs]);

	if (requireFreeMining && numDynamite == 0 && numTurnsOilyLegs == 0) {
		abortMining("Currently no free mining attempts left, stopping script");
	}

	if (requireFreeMining && spotToMine.isInteresting && numTurnsOilyLegs == 0) {
		abortMining("No turns remaining of Oily Legs, and you have specified to only use free mining");
	}

	if (!requireFreeMining && my_adventures() <= numTurnsToLeave)
		abortMining("At mininum number of turns left");

	string result = visit_url("mining.php?mine=5&which=" + spotToMine.counter + "&pwd");
	int[item] itemsFound = extract_items(result);
	if (count(itemsFound) > 0) {
		foreach itemFound in itemsFound {
			if (itemFound == $item[nugget of Crimbonium])
				currentMine.nuggetsFound += 1;
			if (itemFound == $item[peppermint tailings])
				currentMine.tailingsFound += 1;
		}
	} else {
		currentOperation.numCaveIns += 1;
	}


	spotToMine.mined = true;

	if ( delayBetweenMines > 0 )
		waitq(delayBetweenMines);
}

void mineChainSpot(Spot spotToMine) {
	if (spotToMine.mined)
		return;
	if (!spotToMine.isInteresting)
		return;
	if (currentMine.nuggetsFound >= 6)
		return;//Already found 6 nuggets here so rest of chain is cave ins

	if (spotToMine.isInteresting) {
		if (!spotToMine.mined)
			mineSpot(spotToMine);
		if (spotToMine.row != 1)
			mineChainSpot(currentMine.spots[spotToMine.col][spotToMine.row - 1]);
		if (spotToMine.col != 1)
			mineChainSpot(currentMine.spots[spotToMine.col - 1][spotToMine.row]);
		if (spotToMine.col != 6)
			mineChainSpot(currentMine.spots[spotToMine.col + 1][spotToMine.row]);
		if (spotToMine.row != 4)
			mineChainSpot(currentMine.spots[spotToMine.col][spotToMine.row + 1]);
	}

}

Spot findSpotByCounter(string counterString) {
	int counter = to_int(counterString);
	int row = counter / 8;
	int col = counter % 8;

	return currentMine.spots[col][row];
}

void handleRoute() {
	Spot entryPoint = currentMine.currentLongestChain.entryPoint;
	string routeToEntry = entryPoint.shortestRoute;
	string[int] spots = split_string(routeToEntry, ";");
	foreach ndx in spots {
		if (entryPoint.counter != to_int(spots[ndx]))
			mineSpot(findSpotByCounter(spots[ndx]));

	}

	mineChainSpot(entryPoint);
}
/*
void useTestMine(int testMineNumber) {
	int ndxISpots = 0;
	buffer testMineBuffer;
	switch (testMineNumber) {
		case 1:
			testMineBuffer.append("WWWWWWWW");
			testMineBuffer.append("W00IIIIW");
			testMineBuffer.append("W00000IW");
			testMineBuffer.append("W00000IW");
			testMineBuffer.append("W000II0W");
			testMineBuffer.append("W000000W");
			testMineBuffer.append("W0000IIW");
			break;
		default:
			testMineBuffer.append("WWWWWWWW");
			testMineBuffer.append("WIIII00W");
			testMineBuffer.append("W0II000W");
			testMineBuffer.append("W00I000W");
			testMineBuffer.append("W000000W");
			testMineBuffer.append("W00000IW");
			testMineBuffer.append("W000II0W");
			break;
	}
	for counter from 0 to 54 {
		int rowNdx = counter / 8;
		int colNdx = counter % 8;
		if (rowNdx > 0 && rowNdx < 7) {
			if (colNdx > 0 && colNdx < 7) {
				Spot newSpot = newSpot(counter, colNdx, rowNdx);
				currentMine.spots[colNdx][rowNdx] = newSpot;
				if (testMineBuffer.char_at(counter) == 'I') {
					currentMine.interestingSpots[ndxISpots] = newSpot;
					newSpot.isInteresting = true;
					ndxISpots += 1;
					if (rowNdx >= 5)
						newSpot.isCaveIn = true;
				}
			}
		}
	}
}
*/

void mineSingleSpot() {
	Spot singleSpot = currentMine.spots[1][6];
	while (singleSpot.isCaveIn) {
		singleSpot = currentMine.spots[singleSpot.col + 1][6];
	}
	mineSpot(singleSpot);
}


void mineTailingSpot(Spot currentSpot) {

	if (!currentSpot.mined && !currentSpot.isInteresting) {
		mineSpot(currentSpot);
	}

	currentMine.tailingSpotsChecked[currentSpot.counter] = currentSpot;

	if (currentSpot.mined) {
		Spot nextSpot;
		if (currentMine.tailingsFound < minNumberTailingsPerCave && currentSpot.col != 1) {
			nextSpot = currentMine.spots[currentSpot.col - 1][currentSpot.row];
			if (!(currentMine.tailingSpotsChecked contains nextSpot.counter))
				mineTailingSpot(nextSpot);
		}

		if (currentMine.tailingsFound < minNumberTailingsPerCave && currentSpot.row != 1) {
			nextSpot = currentMine.spots[currentSpot.col][currentSpot.row - 1];
			if (!(currentMine.tailingSpotsChecked contains nextSpot.counter))
				mineTailingSpot(nextSpot);
		}

		if (currentMine.tailingsFound < minNumberTailingsPerCave && currentSpot.col != 6) {
			nextSpot = currentMine.spots[currentSpot.col + 1][currentSpot.row];
			if (!(currentMine.tailingSpotsChecked contains nextSpot.counter))
				mineTailingSpot(nextSpot);
		}
	}
}

void mineTailings() {
	Spot startSpot = currentMine.spots[1][6];

	while (startSpot.isCaveIn) {
		startSpot = currentMine.spots[startSpot.col + 1][6];
	}
	int colCounter = startSpot.col;
	while (colCounter <= 6 &&  currentMine.tailingsFound < minNumberTailingsPerCave) {
		mineTailingSpot(startSpot);

		if (colCounter != 6)
			startSpot = currentMine.spots[startSpot.col + 1][6];

		colCounter += 1;
	}
}

void handleCurrentMine() {
	if (have_effect($effect[Crimbonar]) == 0 && have_effect($effect[object detection]) == 0) {
		abortMining("This script requires that you have the " + $effect[Crimbonar] + " or " + $effect[object detection] + " effect active while starting the mining process");
	}

	if ( maxExtraNuggets >= 0 && item_amount( $ item[nugget of crimbonium] ) > (( item_amount( $ item[cylindrical mold])) + maxExtraNuggets)){
		mineOnlyPeppermints = true;
	} else {
		mineOnlyPeppermints = false;
	}

	if (mineOnlyPeppermints) {
		if (minNumberTailingsPerCave < 12) {
			print("You have selected to only mine peppermints, but the min number of peppermints is quite low, setting min number ot peppermints to a higher number to reduce kol server load of getting new cave walls.", "red");
			minNumberTailingsPerCave = 20;
		}
		maxFailsAllowed = 5;//If only mining peppermints all caves are valid.
	}

	parseMine(); //First thing to do is parse the mine
	//useTestMine(0);
	calculateLongestChain(); //Then calculate longest chain

	//printMine();

	int numAllowedAttempts = 6 + maxFailsAllowed;
	if (count(currentMine.currentLongestChain.spotsInChain) > numAllowedAttempts || count(currentMine.currentLongestChain.spotsInChain) < 6 )  {
		print("Would fail too many times on this mine, need to go to next");
		mineSingleSpot();
		currentOperation.numCavesSkipped += 1;
	} else {
		if (!mineOnlyPeppermints) {
			calcShortestPathsToAllSpots();
			//Figure route to mine
			figureRoute();
			handleRoute();
		}
		if (currentMine.tailingsFound < minNumberTailingsPerCave) {
			mineTailings();
		}

		currentOperation.numCavesFullyExplored += 1;
	}
}

void initMiningOperations() {
	cli_execute("outfit save Backup");
	outfit("High-Radiation Mining Gear");

	if (item_amount($item[Xiblaxian holo-wrist-puter]) > 0) {
		equip($slot[acc2], $item[Xiblaxian holo-wrist-puter]);
	}

	currentOperation = new MiningOperation();
	currentOperation.startingNumNuggets = item_amount($item[nugget of Crimbonium]);
	currentOperation.startingNumTailings = item_amount($item[peppermint tailings]);
	currentOperation.numCaveIns = 0;
	currentOperation.numCavesSkipped = 0;
	currentOperation.numCavesFullyExplored = 0;
	currentOperation.startTime = gametime_to_int();

	if (!useDynamite) {
		put_closet(item_amount($item[minin' dynamite]), $item[minin' dynamite]);
	}
}
void main() {
	initMiningOperations();

	int counter = 0;

	while(counter < maxCaves && my_adventures() > 0) {
		gotoNextMine();
		handleCurrentMine();
		counter += 1;
	}
	endMiningOperation();
}