StepMap.h

[詳解]

 
#pragma once
 
#include <limits>  //< for std::numeric_limits
 
#include "MazeLib/Maze.h"
 
namespace MazeLib {
 
class StepMap {
 public:
  using step_t = uint16_t; 
  static constexpr step_t STEP_MAX =
      std::numeric_limits<step_t>::max(); 
 public:
  StepMap();
  void reset(const step_t step = STEP_MAX) { stepMap.fill(step); }
  step_t getStep(const int8_t x, const int8_t y) const {
    return getStep(Position(x, y));
  }
  step_t getStep(const Position p) const {
    return p.isInsideOfField() ? stepMap[p.getIndex()] : STEP_MAX;
  }
  void setStep(const int8_t x, const int8_t y, const step_t step) {
    return setStep(Position(x, y), step);
  }
  void setStep(const Position p, const step_t step) {
    if (p.isInsideOfField()) stepMap[p.getIndex()] = step;
  }
  const auto& getMapArray() const { return stepMap; }
  const auto getScalingFactor() const { return scalingFactor; }
  void print(const Maze& maze, const Position p = Position(-1, -1),
             const Direction d = Direction::Max,
             std::ostream& os = std::cout) const;
  void print(const Maze& maze, const Directions& dirs,
             const Position start = Position(0, 0),
             std::ostream& os = std::cout) const;
  void printFull(const Maze& maze, const Position p = Position(-1, -1),
                 const Direction d = Direction::Max,
                 std::ostream& os = std::cout) const;
  void printFull(const Maze& maze, const Directions& dirs,
                 const Position start = Position(0, 0),
                 std::ostream& os = std::cout) const;
  void update(const Maze& maze, const Positions& dest, const bool knownOnly,
              const bool simple);
  Directions calcShortestDirections(const Maze& maze, const Position start,
                                    const Positions& dest, const bool knownOnly,
                                    const bool simple);
  Directions calcShortestDirections(const Maze& maze, const bool knownOnly,
                                    const bool simple) {
    return calcShortestDirections(maze, maze.getStart(), maze.getGoals(),
                                  knownOnly, simple);
  }
  Pose calcNextDirections(const Maze& maze, const Pose& start,
                          Directions& nextDirectionsKnown,
                          Directions& nextDirectionCandidates) const;
  Directions getStepDownDirections(const Maze& maze, const Pose& start,
                                   Pose& end, const bool knownOnly,
                                   const bool simple,
                                   const bool breakUnknown) const;
  Directions getNextDirectionCandidates(const Maze& maze,
                                        const Pose& focus) const;
  static void appendStraightDirections(const Maze& maze,
                                       Directions& shortestDirections,
                                       const bool knownOnly,
                                       const bool diagEnabled);
 
#if MAZE_DEBUG_PROFILING
  int queueSizeMax = 0;
#endif
 
 protected:
  std::array<step_t, Position::SIZE> stepMap;
  static constexpr int stepTableSize = MAZE_SIZE;
  static constexpr float scalingFactor = 2;
  std::array<step_t, MAZE_SIZE> stepTable;
 
  void calcStraightCostTable();
};
 
}  // namespace MazeLib