C++ Maze::getRows方法代码示例

int Arena::getNumberOfVisitedCells(Maze& m) {
    int count = 0;
    //for each cell in the maze
    for (int i = 0; i < m.getRows(); i++) {
        for (int j = 0; j < m.getCols(); j++) {
            //if cell has been visited, increase count
            if (m.getCell(i,j)->isVisited()) count++;
        }
    }
    return count;
}

double Arena::runSimulation(Maze& maze, Robot& r) {
	//reset maze
	maze.clearVisited();
	maze.clearValues();

	//set needed values after reset
	Cell* curCell = maze.getStartCell();
	robotOrientation = direction::SOUTH;
	unsigned int move;
	double score;

	//while the robot is not in the same cell facing the same direction
	while (!repeat(robotOrientation, curCell->getValue()) && !(curCell == maze.getEndCell())) {
		//set current cell to visited and update it's value
		curCell->setVisited();
		curCell->setValue(curCell->getValue() + robotOrientation);

		//send the robot the environment and get it's next move
		move = r.getMove(getEnv(robotOrientation, curCell));

		//perform next move

		//find rotation
		if (move == 3 || move == 7) {
			robotOrientation = Direction::left(robotOrientation);
		}
		else if (move == 2 || move == 6) {
			robotOrientation = Direction::opposite(robotOrientation);
		}
		else if (move == 1 || move == 5) {
			robotOrientation = Direction::right(robotOrientation);
		}
		else {
			//no rotation
		}

		//move forwards
		if (!curCell->hasWall(robotOrientation) && !curCell->hasEdge(robotOrientation)) {
			curCell = maze.getCell(curCell->getRow() + Direction::row(robotOrientation), curCell->getCol() + Direction::col(robotOrientation));
		}
	}

	//calculate score    
	//score is a 1 if the end has been reached, else it is 1 - (distance from end * 0.01)
	if (curCell == maze.getEndCell()) {
		score = 1.0;
	}
	else {
		score = (double)getNumberOfVisitedCells(maze) / (double)((double)maze.getRows() * (double)maze.getCols());
	}
	//return score
	return score;
}

void FindPathsFromXtoY::findAllThePaths(Maze& mazeT, Cell* startC, Cell* finalC)
{
	currentPath.pathVec.push_back(startC);
	currentPath.sizeOfPath++;
	startC->isCovered = true;

    if(startC->row == finalC->row &&
       startC->col == finalC->col)
    {
        allThePaths.push_back(currentPath);

        /*std::cout << "Current situation: " << std::endl;
        printAllThePaths();*/

        // currentPath.clear();
        // currentPath.pathVec.push_back(startCell);

        return;
    }



    for(int i = 0; i < 4; i++)
    {
        if(startC->row + xMoves[i] >= 0 &&
           startC->row + xMoves[i] < mazeT.getRows() &&
           startC->col + yMoves[i] >=0 &&
           startC->col + yMoves[i] < mazeT.getCols())
        {
            Cell* stepCell = mazeT.getCell(startC->row + xMoves[i], startC->col + yMoves[i]);
            if(stepCell &&
			   stepCell->isCovered == false &&
               stepCell->isOkayToPass())
            {
                // currentPath.push_back(stepCell);
                findAllThePaths(mazeT,stepCell,finalC);

				currentPath.pathVec.pop_back();
				currentPath.sizeOfPath--;
				stepCell->isCovered = false;
            }
        }
    }

    // startC->isCovered = false;
}