AoC2023/Day 10/main.cpp

#pragma region Hidden Setup Stuff
#define OLC_PGE_APPLICATION
#include "olcPixelGameEngine.h"

using namespace olc;

enum Run{
	FILE1,
	FILE2
};

// Override base class with your custom functionality
class AoC2023 : public olc::PixelGameEngine
{
std::vector<std::string>lines;
bool waitForRender=false;

void wait(int pauseMs=0){
	waitForRender=true;
	while(waitForRender);
	std::this_thread::sleep_for(std::chrono::milliseconds(pauseMs));
}

#pragma endregion

const int DAY = 10;
Run runInput=FILE2;

struct Pipe{
	bool down=false;
	bool up=false;
	bool left=false;
	bool right=false;
	char originalChar;
	bool traversed=false;
	int distance=0;
};

std::vector<std::vector<Pipe>>pipes;

vi2d startingPipe;

std::optional<Pipe*>GetPipe(vi2d coords){
	if(coords.x<0||coords.y<0||coords.y>=pipes.size()||coords.x>=pipes[coords.y].size())return {};
	return &pipes[coords.y][coords.x];
}

std::vector<vi2d>pipesRemaining;

void doStuff(){
	while(true){ //lines is accessible as a global.
		for(std::string&line:lines){
			std::vector<Pipe>row;
			for(int i=0;i<line.length();i++){
				switch(line[i]){
					case '|':{
						row.push_back(Pipe{.down=true,.up=true,.originalChar=line[i]});
					}break;
					case '-':{
						row.push_back(Pipe{.left=true,.right=true,.originalChar=line[i]});
					}break;
					case 'L':{
						row.push_back(Pipe{.up=true,.right=true,.originalChar=line[i]});
					}break;
					case 'J':{
						row.push_back(Pipe{.up=true,.left=true,.originalChar=line[i]});
					}break;
					case '7':{
						row.push_back(Pipe{.down=true,.left=true,.originalChar=line[i]});
					}break;
					case 'F':{
						row.push_back(Pipe{.down=true,.right=true,.originalChar=line[i]});
					}break;
					case 'S':{
						startingPipe={int(row.size()),int(pipes.size())};
					}
					default:{
						row.push_back({.originalChar=line[i]});
					}
				}
			}
			pipes.push_back(row);
		}
		
		pipesRemaining.push_back(startingPipe);
		int maxDistance=0;
		auto AddPipe=[&](vi2d coords,int distance){
			GetPipe(coords).value()->traversed=true;
			GetPipe(coords).value()->distance=distance;
			if(distance>maxDistance)maxDistance=distance;
			pipesRemaining.push_back(coords);
		};
		while(pipesRemaining.size()>0){
			std::optional<Pipe*>pipe=GetPipe(pipesRemaining.front());
			if(pipe){
				pipe.value()->traversed=true;
				int distance=pipe.value()->distance;
				vi2d checkCoord=pipesRemaining.front()+vi2d{0,1};
				std::optional<Pipe*>downPipe=GetPipe(checkCoord);
				if((pipesRemaining.front()==startingPipe||pipe.value()->down)&&downPipe&&downPipe.value()->up&&!downPipe.value()->traversed)AddPipe(checkCoord,distance+1);
				
				checkCoord=pipesRemaining.front()+vi2d{0,-1};
				std::optional<Pipe*>upPipe=GetPipe(checkCoord);
				if((pipesRemaining.front()==startingPipe||pipe.value()->up)&&upPipe&&upPipe.value()->down&&!upPipe.value()->traversed)AddPipe(checkCoord,distance+1);
				
				checkCoord=pipesRemaining.front()+vi2d{-1,0};
				std::optional<Pipe*>leftPipe=GetPipe(checkCoord);
				if((pipesRemaining.front()==startingPipe||pipe.value()->left)&&leftPipe&&leftPipe.value()->right&&!leftPipe.value()->traversed)AddPipe(checkCoord,distance+1);
				
				checkCoord=pipesRemaining.front()+vi2d{1,0};
				std::optional<Pipe*>rightPipe=GetPipe(checkCoord);
				if((pipesRemaining.front()==startingPipe||pipe.value()->right)&&rightPipe&&rightPipe.value()->left&&!rightPipe.value()->traversed)AddPipe(checkCoord,distance+1);
				//wait(10);
			}else{
				throw;
			}
			pipesRemaining.erase(pipesRemaining.begin());
		}
		std::cout<<maxDistance<<std::endl;
		break;
		//wait(0); //Wait for 0ms and render the screen (calls draw())
	}
}

void draw(){ //Only use Sprites! If using decals, you must reference global variables!
	Clear(BLACK);
	int count=0;
	for(int y=0;std::vector<Pipe>&row:pipes){
		for(int x=0;Pipe&pipe:row){
			vi2d coords={x,y};
			auto found=std::find(pipesRemaining.begin(),pipesRemaining.end(),coords);
			Pixel col=GREY;
			if(found!=pipesRemaining.end()){
				col=YELLOW;
			}
			DrawString(coords*8,std::to_string(pipe.distance),col);
			x++;
		}
		y++;
	}
}

#pragma region Hidden Engine Stuff
public:
	AoC2023()
	{
		// Name your application
		std::string fileName="day"+std::to_string(DAY)+"_1.txt";
		if(runInput==FILE2){fileName="day"+std::to_string(DAY)+"_2.txt";}
		std::ifstream file(fileName);
		while(file.good()){
			std::string line;
			std::getline(file,line);
			lines.push_back(line);
		}

		sAppName = "Advent of Code 2023 - Day "+std::to_string(DAY);
	}

public:
	bool OnUserCreate() override
	{

		return true;
	}

	bool OnUserUpdate(float fElapsedTime) override
	{
		static std::thread aocSolver(&AoC2023::doStuff,this);

		if(waitForRender){
			draw();
			waitForRender=false;
		}
		return true;
	}
};

int main()
{
	AoC2023 game;
	if (game.Construct(640, 480, 2, 2))
		game.Start();
	return 0;
}
#pragma endregion