int eSuficiente (float d, node pontos) { /* Descobre se a distância d é suficiente para tornar o grafo 'pontos' conexo */
float d2 = d*d; /* Evita ter que multiplicar a cada iteração */
node desconectados = pontos; /* Lista de pontos que ainda não conectamos */
node conectados = initEmptyNode(); /* Lista de pontos que já foram conectados */
node noduloCon; /* Percorrer a conectados */
node noduloDes; /* Percorrer a desconectados */
conectados->prox = removeProximoNodulo(desconectados); /* Escolhe-se um ponto arbitrário para começar */
noduloCon = conectados;
noduloDes = desconectados;
while (noduloCon->prox != NULL) { /* Percorre a conectados */
while (noduloDes->prox != NULL) { /* Percorre a desconectados */
if (quickDistance(noduloDes->prox, noduloCon->prox) <= d2) { /* Se a distância for menor, precisa conectar */
insereNodulo(removeProximoNodulo(noduloDes), noduloCon->prox); /* Tira da desconectados, põe na conectados.
Colocamos o ponto logo depois de noduloCon,
garantindo que ele ainda será analisado.*/
}
else {
noduloDes = noduloDes->prox; /* Se removemos um ponto da desconectados, não precisa andar. Caso contrário, anda. */
}
}
noduloDes = desconectados; /* Reinicia do começo da desconectados */
noduloCon = noduloCon->prox; /* Anda na conectados */
}
if (desconectados->prox == NULL) {/* Se a desconectados está vazia, é porque conseguimos conectar todos os pontos com a distância d */
pontos = juntaLista(desconectados, conectados); /* Reconstruimos a lista 'pontos' que foi separada em duas no processo */
return YES;
}
pontos = juntaLista(desconectados, conectados);
return NO;
}
int Actor::fillPathArray(const Point &fromPoint, const Point &toPoint, Point &bestPoint) {
int bestRating;
int currentRating;
Point bestPath;
int pointCounter;
const PathDirectionData *samplePathDirection;
Point nextPoint;
int directionCount;
int16 compressX = (_vm->getGameId() == GID_ITE) ? 2 : 1;
Common::List<PathDirectionData> pathDirectionQueue;
pointCounter = 0;
bestRating = quickDistance(fromPoint, toPoint, compressX);
bestPath = fromPoint;
for (int8 startDirection = 0; startDirection < 4; startDirection++) {
PathDirectionData tmp = { startDirection, fromPoint.x, fromPoint.y };
pathDirectionQueue.push_back(tmp);
}
if (validPathCellPoint(fromPoint)) {
setPathCell(fromPoint, kDirUp);
#ifdef ACTOR_DEBUG
addDebugPoint(fromPoint, 24+36);
#endif
}
while (!pathDirectionQueue.empty()) {
PathDirectionData curPathDirection = pathDirectionQueue.front();
pathDirectionQueue.pop_front();
for (directionCount = 0; directionCount < 3; directionCount++) {
samplePathDirection = &pathDirectionLUT[curPathDirection.direction][directionCount];
nextPoint = Point(curPathDirection.x, curPathDirection.y);
nextPoint.x += samplePathDirection->x;
nextPoint.y += samplePathDirection->y;
if (!validPathCellPoint(nextPoint)) {
continue;
}
if (getPathCell(nextPoint) != kPathCellEmpty) {
continue;
}
setPathCell(nextPoint, samplePathDirection->direction);
#ifdef ACTOR_DEBUG
addDebugPoint(nextPoint, samplePathDirection->direction + 96);
#endif
PathDirectionData tmp = {
samplePathDirection->direction,
nextPoint.x, nextPoint.y };
pathDirectionQueue.push_back(tmp);
++pointCounter;
if (nextPoint == toPoint) {
bestPoint = toPoint;
return pointCounter;
}
currentRating = quickDistance(nextPoint, toPoint, compressX);
if (currentRating < bestRating) {
bestRating = currentRating;
bestPath = nextPoint;
}
}
}
bestPoint = bestPath;
return pointCounter;
}
