Reverse.Script.txt

***Metadata***
***
Script.Name = "Reverse";
Script.AuthorLogin = "bigbang1112";
Script.Description = "{{{{REVERSE_DESCRIPTION}}}}";
Script.Compatibility.Collections = ["Canyon", "Stadium", "Valley", "Lagoon"];
***

Void Problem_BlockMissing(Text _BlockName, Int3 _Coord, Text _Direction) {
	declare SChProblem Problem_BlockMissing;
	Problem_BlockMissing.Name = "BLOCK_MISSING";

	declare SChApproxBlock Block;
	Block.Name = _BlockName;
	Block.Coord = _Coord;
	Block.Direction = _Direction;
	Problem_BlockMissing.ApproxBlocks.add(Block);

	Problem_BlockMissing.ShortDescription = "{{{{PROBLEM_BLOCK_MISSING}}}} - " ^ _BlockName;
	Problem_BlockMissing.LongDescription = "{{{{PROBLEM_BLOCK_MISSING_LONG}}}}";
	Problem_BlockMissing.Solutions.add(Solution("{{{{PROBLEM_BLOCK_MISSING_SOLUTION_1}}}}", "", True));
	Problem_BlockMissing.Solutions.add(Solution("{{{{PROBLEM_BLOCK_MISSING_SOLUTION_2}}}}", "", False));
	Problem_BlockMissing.Solutions.add(Solution("{{{{PROBLEM_BLOCK_MISSING_SOLUTION_3}}}}", "", True));
	Problem_BlockMissing.Solutions.add(Solution("{{{{PROBLEM_BLOCK_MISSING_SOLUTION_4}}}}", "", False));
	Problem(Problem_BlockMissing);
}

Void Problem_MultilapTrack(SChWaypoint _Multilap) {
	declare SChProblem Problem_MultilapTrack;
	Problem_MultilapTrack.Name = "MULTILAP_TRACK";
	Problem_MultilapTrack.Waypoints.add(_Multilap);
	Problem_MultilapTrack.ShortDescription = "{{{{PROBLEM_MULTILAP_TRACK}}}}";
	Problem_MultilapTrack.LongDescription = "{{{{PROBLEM_MULTILAP_TRACK_LONG_REVERSE}}}}";
	Problem(Problem_MultilapTrack);
}

Void Problem_ItemMultilap(SChItem _Item) {
	declare SChProblem Problem_ItemMultilap;
	Problem_ItemMultilap.Name = "ITEM_MULTILAP";
	Problem_ItemMultilap.Items.add(_Item);
	Problem_ItemMultilap.ShortDescription = "{{{{PROBLEM_MULTILAP_TRACK}}}}";
	Problem_ItemMultilap.LongDescription = "{{{{PROBLEM_MULTILAP_TRACK_LONG_REVERSE}}}}";
	Problem(Problem_ItemMultilap);
}

Void Problem_ItemStart(SChItem _Item) {
	declare SChProblem Problem_ItemStart;
	Problem_ItemStart.Name = "ITEM_START";
	Problem_ItemStart.Items.add(_Item);
	Problem_ItemStart.ShortDescription = "{{{{PROBLEM_CANNOT_REPLACE_START}}}}";
	Problem_ItemStart.LongDescription = "{{{{PROBLEM_CANNOT_REPLACE_START_LONG}}}}";
	Problem_ItemStart.Solutions.add(Solution("{{{{PROBLEM_CANNOT_REPLACE_START_SOLUTION_1}}}}", "", True));
	Problem(Problem_ItemStart);
}

Void Problem_ItemFinish(SChItem _Item) {
	declare SChProblem Problem_ItemFinish;
	Problem_ItemFinish.Name = "ITEM_FINISH";
	Problem_ItemFinish.Items.add(_Item);
	Problem_ItemFinish.ShortDescription = "{{{{PROBLEM_CANNOT_REPLACE_FINISH}}}}";
	Problem_ItemFinish.LongDescription = "{{{{PROBLEM_CANNOT_REPLACE_FINISH_LONG}}}}";
	Problem_ItemFinish.Solutions.add(Solution("{{{{PROBLEM_CANNOT_REPLACE_FINISH_SOLUTION_1}}}}", "", True));
	Problem(Problem_ItemFinish);
}

Void Problem_MultipleFinishes(SChWaypoint[] _Finishes) {
	declare SChProblem Problem_MultipleFinishes;
	Problem_MultipleFinishes.Name = "MULTIPLE_FINISHES";
	Problem_MultipleFinishes.Waypoints = _Finishes;
	Problem_MultipleFinishes.ShortDescription = "{{{{PROBLEM_MULTIPLE_FINISHES}}}}";
	Problem_MultipleFinishes.LongDescription = "{{{{PROBLEM_MULTIPLE_FINISHES_LONG}}}}";
	Problem_MultipleFinishes.Solutions.add(Solution("{{{{PROBLEM_MULTIPLE_FINISHES_SOLUTION_1}}}}", "", True));
	Problem_MultipleFinishes.Solutions.add(Solution("{{{{PROBLEM_MULTIPLE_FINISHES_SOLUTION_2}}}}", "", True));
	Problem_MultipleFinishes.Solutions.add(Solution("{{{{PROBLEM_MULTIPLE_FINISHES_SOLUTION_3}}}}", "", True));
	Problem(Problem_MultipleFinishes);
}

Void Problem_CannotRemoveStart(SChWaypoint _Start) {
	declare SChProblem P;
	P.Name = "CANNOT_REMOVE_START";
	P.Waypoints.add(_Start);
	P.ShortDescription = "{{{{PROBLEM_CANNOT_REMOVE_START}}}} - " ^ _Start.Block.Name;
	P.LongDescription = "This start anchor can't be removed via script. The anchor is possibly ghost block or weirdly placed.";
	P.Solutions.add(Solution("Replace the start manually with possible finish variant.", "", True));
	P.Solutions.add(Solution("Replace the start manually with possible finish ghost variant.", "", True));
	Problem(P);
}

Void Problem_CannotRemoveFinish(SChWaypoint _Finish) {
	declare SChProblem P;
	P.Name = "CANNOT_REMOVE_FINISHLINE";
	P.Waypoints.add(_Finish);
	P.ShortDescription = "{{{{CANNOT_REMOVE_FINISHLINE}}}} -  " ^ _Finish.Block.Name;
	P.LongDescription = "This finish can't be removed via script. The block is possibly ghost or weirdly placed.";
	P.Solutions.add(Solution("Replace the finish manually with possible start variant.", "", True));
	P.Solutions.add(Solution("Replace the finish manually with possible start ghost variant.", "", True));
	Problem(P);
}

Void Problem_CannotRemoveMultilap(SChWaypoint _Multilap) {
	declare SChProblem P;
	P.Name = "CANNOT_REMOVE_MULTILAP";
	P.Waypoints.add(_Multilap);
	P.ShortDescription = "{{{{CANNOT_REMOVE_MULTILAP}}}} -  " ^ _Multilap.Block.Name;
	P.LongDescription = "This multilap can't be removed via script. The block is possibly ghost or weirdly placed.";
	P.Solutions.add(Solution("Replace the multilap manually with possible finish variant.", "", True));
	P.Solutions.add(Solution("Replace the multilap manually with possible finish ghost variant.", "", True));
	Problem(P);
}

***Main***
***
SetStatusStage("{{{{ANALYZING}}}}...");
SetStatusMessage("{{{{SEARCHING_ALL_STARTS}}}}...");
declare StartLines = GetStartLines();
SetStatusMessage("{{{{SEARCHING_ALL_MULTILAPS}}}}...");
declare Multilaps = GetMultilaps();
SetStatusMessage("{{{{SEARCHING_ALL_FINISHES}}}}...");
declare FinishLines = GetFinishLines();
SetStatusMessage("{{{{SEARCHING_MAP_INFO}}}}...");
declare MapInfo = GetMapInfo();
declare Environment = MapInfo.CollectionName;

SetStatusMessage("{{{{CONSIDERING_MULTILAP_TRACK}}}}...");

declare IsOneLapWithFinish = Multilaps.count == 1 && FinishLines.count > 0 && MapInfo.TMObjective_NbLaps == 1;
declare IsMultilap = Multilaps.count == 1 && !IsOneLapWithFinish;

SetStatusStage("{{{{MODIFYING}}}}...");
SetStatusProgress(.5);

if(IsOneLapWithFinish) {
	declare Multilap = Multilaps[0];
	if(Multilap.IsItem) Problem_ItemMultilap(Multilap.Item);
	else if(Multilap.IsBlock) {
		foreach(Relation, GetRelation_MultilapFinishTwoway()[Environment]) {
			declare MultilapBlock = Relation[0];
			declare FinishTwowayBlock = Relation[1];
			if(Multilap.Block.Name == MultilapBlock.Name) {
				declare Removed = RemoveSpecificBlock(Multilap.Block);
				if(Removed) {
					if(IsSpecialBlock(FinishTwowayBlock.Name)) {
						declare Block = PlaceBlock(FinishTwowayBlock.Name, Multilap.Block.Coord, Multilap.Block.Direction);
						if(Block.Placed) SetStatusMessage(MultilapBlock.Name ^ " {{{{replaced_with}}}} " ^ FinishTwowayBlock.Name ^ ".");
						else Problem_BlockMissing(FinishTwowayBlock.Name, Multilap.Block.Coord, Multilap.Block.Direction);
					}
				}
				else Problem_CannotRemoveMultilap(Multilap);
			}
		}
	}
	else Problem();
}
else if(IsMultilap) {
	declare Multilap = Multilaps[0];
	if(Multilap.IsItem) Problem_ItemMultilap(Multilap.Item);
	else if(Multilap.IsBlock) {
		declare Removed = RemoveSpecificBlock(Multilap.Block);
		if(Removed) {
			declare BlockName = Multilap.Block.Name;
			if(BlockName == "RoadRaceMultilap") BlockName = "RoadRaceMultilapMirror"; // Fix for specific Canyon multilap block
			else if(BlockName == "RoadRaceMultilapMirror") BlockName = "RoadRaceMultilap";

			declare Block = PlaceBlock(BlockName, Multilap.Block.Coord, OppositeDirection(Multilap.Block.Direction));
			if(!Block.Placed) Problem();
		}
		else Problem();
	}
	else Problem();
}
else {
	declare Start = StartLines[0];
	if(Start.IsItem) Problem_ItemStart(Start.Item);
	else if(Start.IsBlock) {
		foreach(Relation, GetRelation_StartFinish()[Environment]) {
			declare StartBlock = Relation[0];
			declare FinishBlock = Relation[1];

			if(Start.Block.Name == StartBlock.Name) {
				declare Removed = RemoveSpecificBlock(Start.Block);
				if(Removed) {
					declare Block = PlaceBlock(FinishBlock.Name, Start.Block.Coord, OppositeDirection(Start.Block.Direction));
					if(Block.Placed) SetStatusMessage(StartBlock.Name ^ " {{{{replaced_with}}}} " ^ FinishBlock.Name ^ ".");
					else Problem_BlockMissing(FinishBlock.Name, Start.Block.Coord, OppositeDirection(Start.Block.Direction));
				}
				else Problem_CannotRemoveStart(Start);
			}
		}
	}
	else Problem();
}

SetStatusProgress(1.);
if(!IsMultilap && FinishLines.count > 1) Problem_MultipleFinishes(FinishLines);

if(FinishLines.count == 1) {
	declare Finish = FinishLines[0];

	if(Finish.IsItem) Problem_ItemFinish(Finish.Item);
	else {
		foreach(Relation, GetRelation_StartFinish()[Environment]) {
			declare StartBlock = Relation[0];
			declare FinishBlock = Relation[1];
			
			if(Finish.Block.Name == FinishBlock.Name) {
				declare Removed = RemoveSpecificBlock(Finish.Block);
				if(Removed) {
					declare Block = PlaceBlock(StartBlock.Name, Finish.Block.Coord, OppositeDirection(Finish.Block.Direction));
					if(Block.Placed) SetStatusMessage(FinishBlock.Name ^ " {{{{replaced_with}}}} " ^ StartBlock.Name ^ ".");
					else Problem_BlockMissing(StartBlock.Name, Finish.Block.Coord, OppositeDirection(Finish.Block.Direction));
				}
				else Problem_CannotRemoveFinish(Finish);
			}
		}
	}
}
***

***Solver***
***
switch(Solver_Problem.Name) {
	case "MULTIPLE_FINISHES": {
		declare MapInfo = GetMapInfo();
		declare Environment = MapInfo.CollectionName;

		declare Finish = Solver_Problem.Waypoints[Solver_Point];
		if(Finish.IsBlock) {
			foreach(Relation, GetRelation_StartFinish()[Environment]) {
				declare StartBlock = Relation[0];
				declare FinishBlock = Relation[1];
				
				if(Finish.Block.Name == FinishBlock.Name) {
					if(!RemoveSpecificBlock(Finish.Block)) {
						Editor.EditMode = CMapEditorPlugin::EditMode::Erase;
						ShowEditor();
						while(Exists(Finish.Block)) sleep(100);
						HideEditor();
					}

					if(!PlaceBlock(StartBlock.Name, Finish.Block.Coord, OppositeDirection(Finish.Block.Direction)).Placed) { 
						ShowEditor();
						declare SChApproxBlock B;
						B.Name = StartBlock.Name;
						B.Coord = Finish.Block.Coord;
						B.Direction = OppositeDirection(Finish.Block.Direction);
						while(ExistsApprox(B)) sleep(100);
						HideEditor();
					}
					break;
				}
			}
		}

		switch(Solver_Solution) {
			case 0: {
				Solver_Success = True;
			}
			case 1: {
				declare Removed = Solver_Problem.Waypoints.removekey(Solver_Point);
				foreach(Finish, Solver_Problem.Waypoints) {
					if(Finish.IsBlock) {
						if(!RemoveSpecificBlock(Finish.Block)) {
							Editor.EditMode = CMapEditorPlugin::EditMode::Erase;
							ShowEditor();
							Focus(Finish.Block);
							while(Exists(Finish.Block)) sleep(100);
							HideEditor();
						}
					}
					else if(Finish.IsItem) {
						if(!RemoveItem(Finish.Item)) {
							ShowEditor();
							while(Exists(Finish.Item)) sleep(100);
							HideEditor();
						}
					}
				}
				Solver_Success = True;
			}
			case 2: {
				declare Removed = Solver_Problem.Waypoints.removekey(Solver_Point);
				foreach(Finish, Solver_Problem.Waypoints) {
					if(Finish.IsBlock) {
						if(!DisableWaypoint(Finish)) { // Then just delete
							Editor.EditMode = CMapEditorPlugin::EditMode::Erase;
							ShowEditor();
							Focus(Finish.Block);
							while(Exists(Finish.Block)) sleep(100);
							HideEditor();
							DisableWaypoint(Finish);
						}
					}
					else if(Finish.IsItem) {
						if(!RemoveItem(Finish.Item)) {
							ShowEditor();
							while(Exists(Finish.Item)) sleep(100);
							HideEditor();
						}
					}
				}
				Solver_Success = True;
			}
		}

		Editor.EditMode = CMapEditorPlugin::EditMode::FreeLook;
	}
	case "ITEM_START": {
		ShowEditor();
		
		declare StartPos = Solver_Problem.Items[0].Position;
		declare Replaced = False;
		while(!Replaced) {
			declare Starts = GetStartLines();
			declare Finishes = GetFinishLines();
			declare Boolean StartExists;
			foreach(Start, Starts) {
				if(Start.IsItem) {
					if(Start.Item.Position == StartPos) {
						StartExists = True;
					}
				}
			}
			
			foreach(Finish, Finishes) {
				if(Finish.IsItem) {
					if(!StartExists && MathLib::Distance(StartPos, Finish.Item.Position) < 16.) {
						Replaced = True;
					}
				}
			}
			sleep(100);
		}

		HideEditor();

		Solver_Success = True;
	}
	case "ITEM_FINISH": {
		ShowEditor();
		
		declare FinishPos = Solver_Problem.Items[0].Position;
		declare Replaced = False;
		while(!Replaced) {
			declare Starts = GetStartLines();
			declare Finishes = GetFinishLines();
			declare Boolean FinishExists;
			foreach(Finish, Finishes) {
				if(Finish.IsItem) {
					if(Finish.Item.Position == FinishPos) {
						FinishExists = True;
					}
				}
			}
			
			foreach(Start, Starts) {
				if(Start.IsItem) {
					if(!FinishExists && MathLib::Distance(FinishPos, Start.Item.Position) < 16.) {
						Replaced = True;
					}
				}
			}
			sleep(100);
		}

		HideEditor();

		Solver_Success = True;
	}
	case "CANNOT_REMOVE_START": {
		ShowEditor();

		declare Start = Solver_Problem.Waypoints[0];
		while(Exists(Start.Block)) sleep(100);

		declare MapInfo = GetMapInfo();
		declare Environment = MapInfo.CollectionName;

		foreach(Relation, GetRelation_StartFinish()[Environment]) {
			declare StartBlock = Relation[0];
			declare FinishBlock = Relation[1];

			if(Start.Block.Name == StartBlock.Name) {
				declare Block = PlaceBlock(FinishBlock.Name, Start.Block.Coord, OppositeDirection(Start.Block.Direction));
				if(Block.Placed)
					Solver_Success = True;
				else {
					declare SChApproxBlock B;
					B.Name = FinishBlock.Name;
					B.Coord = Start.Block.Coord;
					B.Direction = OppositeDirection(Start.Block.Direction);
					while(!ExistsApprox(B)) sleep(100);
					Solver_Success = True;
				}
				break;
			}
		}

		HideEditor();
	}
	
	case "CANNOT_REMOVE_FINISHLINE": {
		ShowEditor();

		declare Finish = Solver_Problem.Waypoints[0];
		while(Exists(Finish.Block)) sleep(100);

		declare MapInfo = GetMapInfo();
		declare Environment = MapInfo.CollectionName;

		foreach(Relation, GetRelation_StartFinish()[Environment]) {
			declare StartBlock = Relation[0];
			declare FinishBlock = Relation[1];

			if(Finish.Block.Name == FinishBlock.Name) {
				declare Block = PlaceBlock(StartBlock.Name, Finish.Block.Coord, OppositeDirection(Finish.Block.Direction));
				if(Block.Placed)
					Solver_Success = True;
				else {
					declare SChApproxBlock B;
					B.Name = StartBlock.Name;
					B.Coord = Finish.Block.Coord;
					B.Direction = OppositeDirection(Finish.Block.Direction);
					while(!ExistsApprox(B)) sleep(100);
					Solver_Success = True;
				}
				break;
			}
		}

		HideEditor();
	}
	case "BLOCK_MISSING": {
		switch(Solver_Solution) {
			case 0: {
				OpenLink("https://discord.gg/v6TW88m", ::LinkType::ExternalBrowser);
			}
			case 1: {

			}
			case 2: {
				ShowEditor();
				declare Finish = Solver_Problem.ApproxBlocks[0];
				SetCursorBlock(Finish.Name);
				Editor.EnableMixMapping = True;
				Editor.PlaceMode = CMapEditorPlugin::PlaceMode::GhostBlock;
				while(!ExistsApprox(Finish)) sleep(100);
				Editor.EditMode = CMapEditorPlugin::EditMode::FreeLook;
				HideEditor();
				Solver_Success = True;
			}
			case 3: {

			}
		}
	}
}
***