Programmiererforum

bool TileMap::tilesBetween(Tile& p_start, Tile& p_end)
{
std::vector openList;
std::vector closedList;

openList.push_back(p_start);

do
{
std::sort(openList.begin(), openList.end(), sortF());
Tile& current = openList[0];
closedList.push_back(current);
openList.erase(std::find(openList.begin(), openList.end(), current));
if(std::find(closedList.begin(), closedList.end(), p_end) != closedList.end())
{
return true;
}

std::vector adjacentTiles;
if (current.m_coordinates.x > 0)
{
adjacentTiles.push_back(m_tiles[current.m_coordinates.y * m_width + (current.m_coordinates.x - 1)]);
}
if (current.m_coordinates.x < m_width)
{
adjacentTiles.push_back(m_tiles[current.m_coordinates.y * m_width + (current.m_coordinates.x + 1)]);
}
if (current.m_coordinates.y > 0)
{
adjacentTiles.push_back(m_tiles[(current.m_coordinates.y - 1) * m_width + current.m_coordinates.x]);
}
if (current.m_coordinates.y < m_height)
{
adjacentTiles.push_back(m_tiles[(current.m_coordinates.y + 1) * m_width + current.m_coordinates.x]);
}

for(auto t : adjacentTiles)
{
if(std::find(closedList.begin(), closedList.end(), t) != closedList.end())
{
continue;
}

if(std::find(openList.begin(), openList.end(), t) == closedList.end())
{
openList.push_back(t);
}
}
}
while(!openList.empty());

return false;
}
< /code>

Bearbeiten: veröffentlicht Sortf < /code> < /p>

struct sortF
{
bool operator()(const Tile* p_a, const Tile* p_b) const
{
return p_a->f < p_b->f;
}
};
< /code>

Update: Gemäß dem Vorschlag habe ich die Funktion geändert, um Zeiger anstelle von Referenzen zu verwenden. Es scheint zu funktionieren, aber ich habe mehr zu implementieren, bevor es fertig ist.  < /P>

bool TileMap::tilesBetween(Tile* p_start, Tile* p_end)
{
std::vector openList;
std::vector closedList;

std::cout  0)
{
adjacentTiles.push_back(&m_tiles[current->m_coordinates.y * m_width + (current->m_coordinates.x - 1)]);
}
if (current->m_coordinates.x < m_width)
{
std::cout m_coordinates.y * m_width + (current->m_coordinates.x + 1)] m_coordinates.y * m_width + (current->m_coordinates.x + 1)]);
}
if (current->m_coordinates.y > 0)
{
adjacentTiles.push_back(&m_tiles[(current->m_coordinates.y - 1) * m_width + current->m_coordinates.x]);
}
if (current->m_coordinates.y < m_height)
{
adjacentTiles.push_back(&m_tiles[(current->m_coordinates.y + 1) * m_width + current->m_coordinates.x]);
}

for(auto t : adjacentTiles)
{
if(std::find(closedList.begin(), closedList.end(), t) != closedList.end())
{
continue;
}

if(std::find(openList.begin(), openList.end(), t) == openList.end())
{
openList.push_back(t);
}
}
}
while(!openList.empty());

return false;
}

Ich versuche, einen Teil eines Pfadfindungsalgorithmus neu zu verarbeiten. Ich hatte verwendet Zeiger, um keine Zeiger zu verwenden. Leider bin ich nicht so gut über Referenzen informiert. Ich erhalte den Fehler: Ungültige Operanden zum binären Ausdruck ('std :: __ 1 :: reference_wrapper ' und 'const std :: __ 1 :: reference_wrapper ')

Ich habe auch keine Ahnung, was das bedeutet. Mein Code ist unten und ich kann erfassen, dass er aus der Zeile stammt: openlist.erase (std :: find (openlist.begin (), openlist.end (), aktuell); Aber ich bin nicht Sicher, wie Sie dies beheben. < /p>

[code]bool TileMap::tilesBetween(Tile& p_start, Tile& p_end)
{
std::vector openList;
std::vector closedList;

openList.push_back(p_start);

do
{
std::sort(openList.begin(), openList.end(), sortF());
Tile& current = openList[0];
closedList.push_back(current);
openList.erase(std::find(openList.begin(), openList.end(), current));
if(std::find(closedList.begin(), closedList.end(), p_end) != closedList.end())
{
return true;
}

std::vector adjacentTiles;
if (current.m_coordinates.x > 0)
{
adjacentTiles.push_back(m_tiles[current.m_coordinates.y * m_width + (current.m_coordinates.x - 1)]);
}
if (current.m_coordinates.x < m_width)
{
adjacentTiles.push_back(m_tiles[current.m_coordinates.y * m_width + (current.m_coordinates.x + 1)]);
}
if (current.m_coordinates.y > 0)
{
adjacentTiles.push_back(m_tiles[(current.m_coordinates.y - 1) * m_width + current.m_coordinates.x]);
}
if (current.m_coordinates.y < m_height)
{
adjacentTiles.push_back(m_tiles[(current.m_coordinates.y + 1) * m_width + current.m_coordinates.x]);
}

for(auto t : adjacentTiles)
{
if(std::find(closedList.begin(), closedList.end(), t) != closedList.end())
{
continue;
}

if(std::find(openList.begin(), openList.end(), t) == closedList.end())
{
openList.push_back(t);
}
}
}
while(!openList.empty());

return false;
}
< /code>

Bearbeiten: veröffentlicht Sortf < /code> < /p>

struct sortF
{
bool operator()(const Tile* p_a, const Tile* p_b) const
{
return p_a->f < p_b->f;
}
};
< /code>

Update: Gemäß dem Vorschlag habe ich die Funktion geändert, um Zeiger anstelle von Referenzen zu verwenden. Es scheint zu funktionieren, aber ich habe mehr zu implementieren, bevor es fertig ist. < /P>

bool TileMap::tilesBetween(Tile* p_start, Tile* p_end)
{
std::vector openList;
std::vector closedList;

std::cout 0)
{
adjacentTiles.push_back(&m_tiles[current->m_coordinates.y * m_width + (current->m_coordinates.x - 1)]);
}
if (current->m_coordinates.x < m_width)
{
std::cout m_coordinates.y * m_width + (current->m_coordinates.x + 1)] m_coordinates.y * m_width + (current->m_coordinates.x + 1)]);
}
if (current->m_coordinates.y > 0)
{
adjacentTiles.push_back(&m_tiles[(current->m_coordinates.y - 1) * m_width + current->m_coordinates.x]);
}
if (current->m_coordinates.y < m_height)
{
adjacentTiles.push_back(&m_tiles[(current->m_coordinates.y + 1) * m_width + current->m_coordinates.x]);
}

for(auto t : adjacentTiles)
{
if(std::find(closedList.begin(), closedList.end(), t) != closedList.end())
{
continue;
}

if(std::find(openList.begin(), openList.end(), t) == openList.end())
{
openList.push_back(t);
}
}
}
while(!openList.empty());

return false;
}
[/code]