bool operator == (const Block &First, const Block &Second)
{
	return First.GetX() == Second.GetX() && First.GetY() == Second.GetY();
}

void HGame::StartAlgorithmus()
{
	std::cout<<"-------------------------"<<std::endl;
	std::cout<<"A* Algorithmus gestartet!"<<std::endl;
	std::cout<<"Weg wird berechnet, bitte warten..."<<std::endl<<std::endl;

	//Listen löschen und Felder freigeben
	Clear();

	//Clock starten!
	ClockTime.restart();

	ClosedList.push_back(Myqueue.front());
	//Solange ausführen, bis man entweder einen Weg hat oder nicht
	Block &GoalBlock	= Myqueue.back();
	while(!OpenList.empty() && ClosedList.back() != GoalBlock)
	{
		Block CurrentBlock	= OpenList.front();
		OpenList.pop();
		ClosedList.push_back(CurrentBlock);
		CurrentBlock.SetBlockID(4);		//ClosedList -> Farbe ändern

		int int_x = static_cast<int>(CurrentBlock.GetX() / 20.f +0.5f);//hier sollte kein float sein=> Block sollte keine floats speichern sondern ints
		int int_y = static_cast<int>(CurrentBlock.GetY() / 20.f +0.5f);//taucht später auch noch als Problem auf!
		Field[int_x][int_y].Available == true;//als closed markieren

		{
			int neighbors[][] = { {1,0}, {1,1}, {1,-1}, {-1,0}, {-1,1}, {-1,-1}, {0,1}, {0,-1} };
			for(int counter = 0; counter < 8; counter++)
			{
				int new_x = int_x + neighbors[counter][0];
				int new_y = int_y + neighbors[counter][1];

				if(Field[new_x][new_y].Available == true)//eine art closed check; ginge auch per ClosedList und wäre wahrscheinlich sicherer
				{
					//der knoten muss gelöscht werden um doppelte Einträge zu vermeiden!
					for(auto it = OpenList.begin(); it != OpenList.end();)
						if(fabs(it->GetX() - new_x*20.f) < 0.001f && fabs(it->GetY() - new_y*20.f) < 0.001f)
							it = OpenList.erase(it);
						else
							++it;

					OpenList.push_back(Block(Game, new_x*20.f, new_y*20.f, 3));		//3 = OpenList
					Block &m = OpenList.back();
				
					float h_dist_x = m.GetX() - GoalBlock.GetX();
					float h_dist_y = m.GetY() - GoalBlock.GetY();

					float dist_x = m.GetX() - CurrentBlock.GetX();
					float dist_y = m.GetY() - CurrentBlock.GetY();

					m.SetG(CurrentBlock.GetG() + sqrt(dist_x*dist_x+dist_y*dist_y));
					m.SetH(sqrt(h_dist_x*h_dist_x+h_dist_y*h_dist_y));
					m.SetF(m.GetG() + m.GetH());
					m.SetComeFrom(sf::Vector2i(CurrentBlock.GetX(), CurrentBlock.GetY()));
				}
			}
			OpenList.sort();
		}
	}
	Finish		= ClosedList.back() == GoalBlock;
	Impossible	= !Finish;

	if(ClosedList.empty() == false && Impossible == false)
	{
		bool Start = false;

		ComeFromX = ClosedList.back().GetX();
		ComeFromY = ClosedList.back().GetY();

		while(Start == false)
		{
			if(PathList.empty() == false)
			{
				if((PathList.back().GetX()+1 == Myqueue.front().GetX() && PathList.back().GetY() == Myqueue.front().GetY()) ||
					(PathList.back().GetX()+1 == Myqueue.front().GetX() && PathList.back().GetY()+1 == Myqueue.front().GetY()) ||
					(PathList.back().GetX()+1 == Myqueue.front().GetX() && PathList.back().GetY()-1 == Myqueue.front().GetY()) ||
					(PathList.back().GetX()-1 == Myqueue.front().GetX() && PathList.back().GetY() == Myqueue.front().GetY()) ||
					(PathList.back().GetX()-1 == Myqueue.front().GetX() && PathList.back().GetY()+1 == Myqueue.front().GetY()) ||
					(PathList.back().GetX()-1 == Myqueue.front().GetX() && PathList.back().GetY()-1 == Myqueue.front().GetY()) ||
					(PathList.back().GetX() == Myqueue.front().GetX() && PathList.back().GetY()+1 == Myqueue.front().GetY()) ||
					(PathList.back().GetX() == Myqueue.front().GetX() && PathList.back().GetY()-1 == Myqueue.front().GetY()))
					Start = true;
			}
			MoveBack();
		}
	}

	std::cout<<"OpenList: "<<OpenList.size()<<std::endl;
	std::cout<<"ClosedList: "<<ClosedList.size()<<std::endl;
	std::cout<<"PathList: "<<PathList.size()<<std::endl;

	//Wenn man das Ziel erreicht hat man einen Weg gefunden
	if(Finish == true)
		std::cout<<"Weg gefunden! ("<<ClockTime.getElapsedTime().asMilliseconds()<<"ms)"<<std::endl<<std::endl;

	//Wenn OpenList leer ist, aber einen Weg gefunden hat, hat man ihn ja trotzdem gefunden
	if(Impossible == true && Finish == false)
		std::cout<<"Das Ziel kann nicht erreicht werden! ("<<ClockTime.getElapsedTime().asMilliseconds()<<"ms)"<<std::endl<<std::endl;
}