int answerWithMe(board *b) { searchData d; initSearchData(b, &d); d.fr = manhattanDistance(b); int nowSearching = endCheck(b); while(d.fr > 15){ mvRoot(&d, nowSearching); nowSearching++; d.fr = manhattanDistance(&d.b); } return 0; }
bool PacMan::findPacman(int *ghostX, int *ghostY, int *sniff) { //Ghosts pursue pacman for 5 timesteps or less. if (*sniff > 0) { return true; } else if (manhattanDistance(pacmanX, pacmanY, *ghostX, *ghostY) <= 5) { *sniff = 5; return true; } else { return false; } }
/** Function to find the heuristic value */ int heuristicUnweightedValue(int state[SIZE]) { /** Position and heuristic value */ int position; int heuristicValue = 0; /** Loop through the array */ for(position = 0; position < SIZE; position++) { heuristicValue += manhattanDistance(state[position], position); } return heuristicValue; }
int TMXPathFinding::getDistance(TileNode *start, TileNode *end) { //return euclideanDistance(start, end); return manhattanDistance(start, end); }
//Update the observation we return to the agent. //Make binary array that represents a 16-bit value. void PacMan::updateObservation() { //bool binary[16]; binaryObservation[0] = false; binaryObservation[1] = false; binaryObservation[2] = false; binaryObservation[3] = false; binaryObservation[4] = false; binaryObservation[5] = false; binaryObservation[6] = false; binaryObservation[7] = false; binaryObservation[8] = false; binaryObservation[9] = false; binaryObservation[10] = false; binaryObservation[11] = false; binaryObservation[12] = false; binaryObservation[13] = false; binaryObservation[14] = false; binaryObservation[15] = false; //Get the surrounding spaces around pacman if (pacmanY - 1 < 0 || map[pacmanY - 1][pacmanX] == '*') { binaryObservation[0] = true; } if (pacmanX + 1 > 16 || map[pacmanY][pacmanX + 1] == '*') { binaryObservation[1] = true; } if (pacmanY + 1 > 18 || map[pacmanY + 1][pacmanX] == '*') { binaryObservation[2] = true; } if (pacmanX - 1 < 0 || map[pacmanY][pacmanX] == '*') { binaryObservation[3] = true; } //See if pacman can find a ghost or a pellet north int upY = pacmanY - 1; while (upY > 0 && map[upY][pacmanX] != '*') { if (map[upY][pacmanX] == 'A' || map[upY][pacmanX] == 'B' || map[upY][pacmanX] == 'C' || map[upY][pacmanX] == 'D') { binaryObservation[4] = true; } if (map[upY][pacmanX] == '.') { binaryObservation[11] = true; } upY--; } //See if pacman can find a ghost or a pellet east. int rightX = pacmanX + 1; while (rightX < 17 && map[pacmanY][rightX] != '*') { if (map[pacmanY][rightX] == 'A' || map[pacmanY][rightX] == 'B' || map[pacmanY][rightX] == 'C' || map[pacmanY][rightX] == 'D') { binaryObservation[5] = true; } if (map[pacmanY][rightX] == '.') { binaryObservation[12] = true; } rightX++; } //See if pacman can find a ghost or a pellet south. int downY = pacmanY + 1; while (downY < 19 && map[downY][pacmanX] != '*') { if (map[downY][pacmanX] == 'A' || map[downY][pacmanX] == 'B' || map[downY][pacmanX] == 'C' || map[downY][pacmanX] == 'D') { binaryObservation[6] = true; } if (map[downY][pacmanX] == '.') { binaryObservation[13] = true; } downY++; } //See if pacman can find a ghost or a pellet east. int leftX = pacmanX - 1; while (leftX > 0 && map[pacmanY][leftX] != '*') { if (map[pacmanY][leftX] == 'A' || map[pacmanY][leftX] == 'B' || map[pacmanY][leftX] == 'C' || map[pacmanY][leftX] == 'D') { binaryObservation[7] = true; } if (map[pacmanY][leftX] == '.') { binaryObservation[14] = true; } leftX--; } //Check if there's a pellet nearby for (int y = 0; y < 19; y++) { for (int x = 0; x < 17; x++) { int distance = manhattanDistance(pacmanX, pacmanY, x, y); if (!binaryObservation[8] && distance <= 2 && map[y][x] == '.') { binaryObservation[8] = true; } if (!binaryObservation[9] && distance <= 3 && map[y][x] == '.') { binaryObservation[9] = true; } if (!binaryObservation[10] && distance <= 4 && map[y][x] == '.') { binaryObservation[10] = true; } } } //See if pacman is under the effects of a power pellet binaryObservation[15] = poweredUp; m_observation = binaryToDecimal(binaryObservation); }
void PacMan::ghostPursuitMove(int *ghostX, int *ghostY, int *covers, char ghost) { int newX, newY; int currentDistance = manhattanDistance(pacmanX, pacmanY, *ghostX, *ghostY); bool pursuing = false; //Go up int upX = *ghostX; int upY = (*ghostY) - 1; if (isValidGhostMove(upX, upY) && manhattanDistance(pacmanX, pacmanY, upX, upY) < currentDistance) { pursuing = true; newX = upX; newY = upY; } //Go right int rightX = (*ghostX) + 1; int rightY = *ghostY; if (isValidGhostMove(rightX, rightY) && manhattanDistance(pacmanX, pacmanY, rightX, rightY) < currentDistance) { pursuing = true; newX = rightX; newY = rightY; } //Go down int downX = *ghostX; int downY = (*ghostY) + 1; if (isValidGhostMove(downX, downY) && manhattanDistance(pacmanX, pacmanY, downX, downY) < currentDistance) { pursuing = true; newX = downX; newY = downY; } // Go Left int leftX = (*ghostX) - 1; int leftY = *ghostY; if (isValidGhostMove(leftX, leftY) && manhattanDistance(pacmanX, pacmanY, leftX, leftY) < currentDistance) { pursuing = true; newX = leftX; newY = leftY; } //Pursuit move not valid (wall?) Get a random move instead. if (!pursuing) { ghostRandomMove(ghostX, ghostY, covers, ghost); return; } //Ghost got pacman. But it shouldn't move if (newX == pacmanX && newY == pacmanY) { if (poweredUp) { //m_reward += 50; resetGhost(ghost); } else { m_reward -= 50; reset = true; } return; } //If ghost covered something, put it back in. if (*covers == 0) { map[*ghostY][*ghostX] = ' '; } else if (*covers == 1) { map[*ghostY][*ghostX] = '.'; } else if (*covers == 2) { map[*ghostY][*ghostX] = 'O'; } else if (*covers == 3) { map[*ghostY][*ghostX] = 'x'; } else { //Should not get here unless P=NP. Uh, right. std::cout << "WTF?\n"; } //If ghost is gonna cover something, save it somewhere first if (map[newY][newX] == ' ') { *covers = 0; } else if (map[newY][newX] == '.') { *covers = 1; } else if (map[newY][newX] == 'O') { *covers = 2; } else if (map[newY][newX] == 'x') { *covers = 3; } else { //Should not get here unles 2+2=5. //For extremely large values of 2. std::cout << "Pakshit\n"; } *ghostX = newX; *ghostY = newY; map[newY][newX] = ghost; }
bool Pathfinder::search(const Vector2i &start, Vector2i end, NodePath &path, Map *map, const GameObject *forObj) { if (!map || start.x < 0 || start.x >= map->getMapWidth() || start.y < 0 || start.y >= map->getMapHeight() || end.x < 0 || end.x >= map->getMapWidth() || end.y < 0 || end.y >= map->getMapHeight() || (start.x == end.x && start.y == end.y)) { return false; } mMap = map; int startGroup = map->mMapData[start.x][start.y].group; int endGroup = map->mMapData[end.x][end.y].group; if(startGroup != endGroup) { mMap = NULL; return false; } if (!map->isValidGridLocation(end.x, end.y, forObj)) { // Move back towards the start position until we do find a passable location. Engine *engine = Engine::getEngine(); Vector2f fstart(start); Vector2f fend(end); Vector2f toStart(fend.sub(fstart)); int numSteps = static_cast<int>(toStart.length() * 2.0f); toStart.normalise(); toStart.scale(0.5f); for (int step = 0; step < numSteps; step++) { fend = fend.sub(toStart); Vector2i grid(fend); if (map->isValidGridLocation(grid.x, grid.y, forObj)) { break; } } end.x = round(fend.x); end.y = round(fend.y); endGroup = map->mMapData[end.x][end.y].group; if(startGroup != endGroup) { mMap = NULL; return false; } } mOpenList.clear(); mClosedList.clear(); mNodeUseCounter++; mOpenList.push_back(&map->mMapData[start.x][start.y]); AStarNode *endNode = &map->mMapData[end.x][end.y]; endNode->parent = NULL; while(!mOpenList.empty()) { AStarNode *node = mOpenList.front(); if(node->useCounter < mNodeUseCounter) { node->g = 0; node->useCounter = mNodeUseCounter; node->parent = NULL; } if (node == endNode) { // Complete getPath(node, path); mMap = NULL; return true; } else { mOpenList.erase(mOpenList.begin()); mClosedList.push_back(node); mNeighbors.clear(); getNeighbors(node->gridPosition, forObj); for(auto iter = mNeighbors.begin(); iter != mNeighbors.end(); ++iter) { AStarNode *n = *iter; if (!Utils::listContains(mOpenList, n) && !Utils::listContains(mClosedList, n)) { if (n->useCounter < mNodeUseCounter) { n->g = 0; n->useCounter = mNodeUseCounter; } n->g += node->g; n->f = n->g + manhattanDistance(n->position, endNode->position); n->parent = node; mOpenList.push_back(n); } } mNeighbors.clear(); sortAStarList(mOpenList); } } // NO PATH! D: mMap = NULL; return false; }