MazeLib::Maze クラス

迷路の壁情報を管理するクラス [詳解]

#include <Maze.h>

MazeLib::Maze 連携図

公開メンバ関数
	Maze (const Positions &goals=Positions(), const Position start=Position(0, 0))
	デフォルトコンストラクタ [詳解]
void	reset (const bool set_start_wall=true, const bool set_range_full=false)
	迷路の初期化。壁を削除し、スタート区画を既知に [詳解]
bool	isWall (const WallIndex i) const
	壁の有無を返す [詳解]
bool	isWall (const Position p, const Direction d) const
bool	isWall (const int8_t x, const int8_t y, const Direction d) const
void	setWall (const WallIndex i, const bool b)
	壁を更新をする [詳解]
void	setWall (const Position p, const Direction d, const bool b)
void	setWall (const int8_t x, const int8_t y, const Direction d, const bool b)
bool	isKnown (const WallIndex i) const
	壁が探索済みかを返す [詳解]
bool	isKnown (const Position p, const Direction d) const
bool	isKnown (const int8_t x, const int8_t y, const Direction d) const
void	setKnown (const WallIndex i, const bool b)
	壁の既知を更新する [詳解]
void	setKnown (const Position p, const Direction d, const bool b)
void	setKnown (const int8_t x, const int8_t y, const Direction d, const bool b)
bool	canGo (const WallIndex i) const
	通過可能かどうかを返す [詳解]
bool	canGo (const Position p, const Direction d) const
bool	canGo (const WallIndex &i, bool knownOnly) const
bool	updateWall (const Position p, const Direction d, const bool b, const bool pushRecords=true)
	既知の壁情報と照らしあわせながら、壁を更新する関数 [詳解]
void	resetLastWalls (const int num, const bool set_start_wall=true)
	直前に更新した壁を見探索状態にリセットする [詳解]
int8_t	wallCount (const Position p) const
	引数区画の壁の数を返す [詳解]
int8_t	unknownCount (const Position p) const
	引数区画に隣接する未知壁の数を返す [詳解]
void	print (std::ostream &os=std::cout, const int mazeSize=MAZE_SIZE) const
	迷路の表示 [詳解]
void	print (const Directions &dirs, const Position start=Position(0, 0), std::ostream &os=std::cout, const int mazeSize=MAZE_SIZE) const
	パス付きの迷路の表示 [詳解]
void	print (const Positions &positions, std::ostream &os=std::cout, const int mazeSize=MAZE_SIZE) const
	位置のハイライト付きの迷路の表示 [詳解]
bool	parse (std::istream &is)
	特定の迷路の文字列(*.maze ファイル)から壁をパースする [詳解]
bool	parse (const std::string &filepath)
bool	parse (const std::vector< std::string > &data, const int mazeSize)
	配列から迷路を読み込むパーサ [詳解]
void	setGoals (const Positions &goals)
	ゴール区画の集合を更新 [詳解]
void	setStart (const Position start)
	スタート区画を更新 [詳解]
const Positions &	getGoals () const
	ゴール区画の集合を取得 [詳解]
const Position &	getStart () const
	スタート区画を取得 [詳解]
const WallRecords &	getWallRecords () const
	壁ログを取得 [詳解]
int8_t	getMinX () const
	既知部分の迷路サイズを返す。計算量を減らすために使用。 [詳解]
int8_t	getMinY () const
int8_t	getMaxX () const
int8_t	getMaxY () const
bool	backupWallRecordsToFile (const std::string &filepath, const bool clear=false)
	壁ログをファイルに追記保存する関数 [詳解]
bool	restoreWallRecordsFromFile (const std::string &filepath)
	壁ログファイルから壁情報を復元する関数 [詳解]

限定公開メンバ関数
bool	isWallBase (const std::bitset< WallIndex::SIZE > &wall, const WallIndex i) const
	壁の確認のベース関数。迷路外を参照すると壁ありと返す。 [詳解]
void	setWallBase (std::bitset< WallIndex::SIZE > &wall, const WallIndex i, const bool b) const
	壁の更新のベース関数。迷路外を参照すると無視される。 [詳解]

限定公開変数類
std::bitset< WallIndex::SIZE >	wall
	壁情報 [詳解]
std::bitset< WallIndex::SIZE >	known
	壁の既知未知情報 [詳解]
Positions	goals
	ゴール区画の集合 [詳解]
Position	start
	スタート区画 [詳解]
WallRecords	wallRecords
	更新した壁のログ [詳解]
int8_t	min_x
	既知壁の最小区画 [詳解]
int8_t	min_y
	既知壁の最小区画 [詳解]
int8_t	max_x
	既知壁の最大区画 [詳解]
int8_t	max_y
	既知壁の最大区画 [詳解]
int	wallRecordsBackupCounter
	壁ログバックアップのカウンタ [詳解]

フレンド
std::istream &	operator>> (std::istream &is, Maze &maze)
	入力ストリームの迷路データをパースする [詳解]

詳解

迷路の壁情報を管理するクラス

• 壁情報とスタート位置とゴール位置の集合などを保持する
• 壁の有無の確認は、isWall()
• 壁の既知未知の確認は、isKnown()
• 壁の更新は、updateWall() によって行う
• 壁のバックアップ用に WallRecords 情報も管理する

構築子と解体子

Maze()

MazeLib::Maze::Maze ( const Positions &  goals = Positions(), const Position  start = Position(0, 0)  )

inline

デフォルトコンストラクタ

引数

goals	ゴール区画の集合
start	スタート区画

      : goals(goals), start(start) {
    reset();
  }

呼び出し関係図:

関数詳解

backupWallRecordsToFile()

bool MazeLib::Maze::backupWallRecordsToFile	(	const std::string &	filepath,
		const bool	clear = false
	)

壁ログをファイルに追記保存する関数

                                                     {
  /* 変更なし */
  if (!clear &&
      wallRecordsBackupCounter == static_cast<int>(wallRecords.size()))
    return true;
  /* 前のデータが残っていたら削除 */
  std::ifstream ifs(filepath, std::ios::ate);
  const int num_items = ifs.tellg() / sizeof(WallRecord);
  ifs.close();
  if (clear || num_items > wallRecordsBackupCounter) {
    std::remove(filepath.c_str());
    wallRecordsBackupCounter = 0;
  }
  /* WallRecords を追記 */
  std::ofstream ofs(filepath, std::ios::binary | std::ios::app);
  if (ofs.fail()) {
    MAZE_LOGW << "failed to open file! " << filepath << std::endl;
    return false;
  }
  while (wallRecordsBackupCounter < static_cast<int>(wallRecords.size())) {
    const auto& wr = wallRecords[wallRecordsBackupCounter];
    ofs.write(reinterpret_cast<const char*>(&wr), sizeof(wr));
    wallRecordsBackupCounter++;
  }
  return true;
}

canGo() [1/3]

bool MazeLib::Maze::canGo ( const Position  p, const Direction  d  ) const

inline

                                                        {
    return canGo(WallIndex(p, d));
  }

呼び出し関係図:

canGo() [2/3]

bool MazeLib::Maze::canGo ( const WallIndex &  i, bool  knownOnly  ) const

inline

                                                       {
    return !isWall(i) && (isKnown(i) || !knownOnly);
  }

呼び出し関係図:

canGo() [3/3]

bool MazeLib::Maze::canGo ( const WallIndex  i ) const

inline

通過可能かどうかを返す

戻り値

true: 既知かつ壁なし

false: それ以外

{ return !isWall(i) && isKnown(i); }

呼び出し関係図:

getGoals()

const Positions& MazeLib::Maze::getGoals ( ) const

inline

ゴール区画の集合を取得

{ return goals; }

getMaxX()

int8_t MazeLib::Maze::getMaxX ( ) const

inline

{ return max_x; }

getMaxY()

int8_t MazeLib::Maze::getMaxY ( ) const

inline

{ return max_y; }

getMinX()

int8_t MazeLib::Maze::getMinX ( ) const

inline

既知部分の迷路サイズを返す。計算量を減らすために使用。

{ return min_x; }

getMinY()

int8_t MazeLib::Maze::getMinY ( ) const

inline

{ return min_y; }

getStart()

const Position& MazeLib::Maze::getStart ( ) const

inline

スタート区画を取得

{ return start; }

getWallRecords()

const WallRecords& MazeLib::Maze::getWallRecords ( ) const

inline

壁ログを取得

{ return wallRecords; }

isKnown() [1/3]

bool MazeLib::Maze::isKnown ( const int8_t  x, const int8_t  y, const Direction  d  ) const

inline

                                                                        {
    return isWallBase(known, WallIndex(Position(x, y), d));
  }

呼び出し関係図:

isKnown() [2/3]

bool MazeLib::Maze::isKnown ( const Position  p, const Direction  d  ) const

inline

                                                          {
    return isWallBase(known, WallIndex(p, d));
  }

呼び出し関係図:

isKnown() [3/3]

bool MazeLib::Maze::isKnown ( const WallIndex  i ) const

inline

壁が探索済みかを返す

戻り値

true: 探索済み、false: 未探索

{ return isWallBase(known, i); }

呼び出し関係図:

isWall() [1/3]

bool MazeLib::Maze::isWall ( const int8_t  x, const int8_t  y, const Direction  d  ) const

inline

                                                                       {
    return isWallBase(wall, WallIndex(Position(x, y), d));
  }

呼び出し関係図:

isWall() [2/3]

bool MazeLib::Maze::isWall ( const Position  p, const Direction  d  ) const

inline

                                                         {
    return isWallBase(wall, WallIndex(p, d));
  }

呼び出し関係図:

isWall() [3/3]

bool MazeLib::Maze::isWall ( const WallIndex  i ) const

inline

壁の有無を返す

戻り値

true: 壁あり、false: 壁なし

{ return isWallBase(wall, i); }

呼び出し関係図:

isWallBase()

bool MazeLib::Maze::isWallBase ( const std::bitset< WallIndex::SIZE > &  wall, const WallIndex  i  ) const

inlineprotected

壁の確認のベース関数。迷路外を参照すると壁ありと返す。

                                           {
    return !i.isInsideOfField() || wall[i.getIndex()];  //< 範囲外は壁ありに
  }

呼び出し関係図:

parse() [1/3]

bool MazeLib::Maze::parse ( const std::string &  filepath )

inline

                                        {
    std::ifstream ifs(filepath);
    return ifs ? parse(ifs) : false;
  }

呼び出し関係図:

parse() [2/3]

bool MazeLib::Maze::parse	(	const std::vector< std::string > &	data,
		const int	mazeSize
	)

配列から迷路を読み込むパーサ

引数

data	各区画16進表記の文字列配列 例：{"abaf", "1234", "abab", "aaff"}
mazeSize	迷路の1辺の区画数（正方形のみ対応）

                                                                     {
  for (const auto xr : {true, false}) {
    for (const auto yr : {false, true}) {
      for (const auto xy : {false, true}) {
        for (const auto b0 : Direction::Along4()) {
          for (const auto b1 : Direction::Along4()) {
            for (const auto b2 : Direction::Along4()) {
              for (const auto b3 : Direction::Along4()) {
                const std::array<Direction, 4> bit_to_dir_map{{b0, b1, b2, b3}};
                reset(false);
                int diffs = 0;
                for (int8_t y = 0; y < mazeSize; ++y) {
                  for (int8_t x = 0; x < mazeSize; ++x) {
                    const int8_t xd = xr ? x : (mazeSize - x - 1);
                    const int8_t yd = yr ? y : (mazeSize - y - 1);
                    const signed char c = xy ? data[xd][yd] : data[yd][xd];
                    uint8_t h = 0;
                    if ('0' <= c && c <= '9')
                      h = c - '0';
                    else if ('a' <= c && c <= 'f')
                      h = c - 'a' + 10;
                    else if ('A' <= c && c <= 'F')
                      h = c - 'A' + 10;
                    else if (0 <= c && c <= 15)
                      h = c;
                    if (!updateWall(Position(x, y), bit_to_dir_map[0], h & 0x01,
                                    false))
                      ++diffs;
                    if (!updateWall(Position(x, y), bit_to_dir_map[1], h & 0x02,
                                    false))
                      ++diffs;
                    if (!updateWall(Position(x, y), bit_to_dir_map[2], h & 0x04,
                                    false))
                      ++diffs;
                    if (!updateWall(Position(x, y), bit_to_dir_map[3], h & 0x08,
                                    false))
                      ++diffs;
                  }
                }
                if (diffs < MAZE_SIZE && isWall(0, 0, Direction::East) &&
                    !isWall(0, 0, Direction::North))
                  return true;
              }
            }
          }
        }
      }
    }
  }
  return false;
}

呼び出し関係図:

parse() [3/3]

bool MazeLib::Maze::parse

(

std::istream &

is

)

特定の迷路の文字列(*.maze ファイル)から壁をパースする

テキスト形式。S: スタート区画(単数)、G: ゴール区画(複数可)

+---+---+
|     G |
+   +   +
| S | G |
+---+---+

引数

is	*.maze 形式のファイルの input-stream

                               {
  /* determine the maze size */
  /* get file size */
  is.seekg(0, std::ios::end);  //< move the position to end
  const int file_size = 1 + is.tellg();
  is.seekg(0, std::ios::beg);  //< restore the position to begin
  /* estimated (minimum) file size [byte] : F = (4*M + 1 + 1) * (2*M + 1) */
  /* using quadratic formula, we have: M = (sqrt(2*F) - 2) / 4 */
  const int mazeSize = (std::sqrt(2 * file_size) - 2) / 4;
  if (mazeSize < 1) return false;  //< file size error
  /* reset existing maze */
  reset(), goals.clear();
  char c;  //< temporal variable to use next
  for (int8_t y = mazeSize; y >= 0; --y) {
    /* vertical walls and cells */
    if (y != mazeSize) {
      is.ignore(10, '|');  //< skip until next '|'
      for (int8_t x = 0; x < mazeSize; ++x) {
        is.ignore(1);  //< skip a space
        c = is.get();
        if (c == 'S')
          start = Position(x, y);
        else if (c == 'G')
          goals.push_back(Position(x, y));
        is.ignore(1);  //< skip a space
        c = is.get();
        if (c == '|')
          Maze::updateWall(Position(x, y), Direction::East, true, false);
        else if (c == ' ')
          Maze::updateWall(Position(x, y), Direction::East, false, false);
      }
    }
    /* horizontal walls and pillars */
    for (uint8_t x = 0; x < mazeSize; ++x) {
      is >> c;  //< skip until next '+' or 'o'
      std::string s;
      for (int i = 0; i < 3; ++i) s += static_cast<char>(is.get());
      if (s == "---")
        Maze::updateWall(Position(x, y), Direction::South, true, false);
      else if (s == "   ")
        Maze::updateWall(Position(x, y), Direction::South, false, false);
    }
  }
  return true;
}

呼び出し関係図:

print() [1/3]

void MazeLib::Maze::print	(	const Directions &	dirs,
		const Position	start = Position(0, 0),
		std::ostream &	os = std::cout,
		const int	mazeSize = MAZE_SIZE
	)		const

パス付きの迷路の表示

引数

start	パスのスタート座標
dirs	移動方向の配列
os	output-stream
mazeSize	迷路の1辺の区画数（正方形のみ対応）

                                           {
  /* preparation */
  std::vector<Pose> path;
  path.reserve(dirs.size());
  {
    Position p = start;
    for (const auto d : dirs) path.push_back({p, d}), p = p.next(d);
  }
  const auto& maze = *this;
  /* start to draw maze */
  for (int8_t y = mazeSize; y >= 0; --y) {
    if (y != mazeSize) {
      for (uint8_t x = 0; x <= mazeSize; ++x) {
        /* Vertical Wall */
        const auto it =
            std::find_if(path.cbegin(), path.cend(), [&](const Pose& pose) {
              return WallIndex(pose.p, pose.d) ==
                     WallIndex(Position(x, y), Direction::West);
            });
        const auto w = maze.isWall(x, y, Direction::West);
        const auto k = maze.isKnown(x, y, Direction::West);
        if (it != path.cend())
          os << C_YE << it->d << C_NO;
        else
          os << (k ? (w ? "|" : " ") : (C_RE "." C_NO));
        /* Breaking Condition */
        if (x == mazeSize) break;
        /* Cell */
        const auto p = Position(x, y);
        if (p == start)
          os << C_BL << " S " << C_NO;
        else if (std::find(goals.cbegin(), goals.cend(), p) != goals.cend())
          os << C_BL << " G " << C_NO;
        else
          os << "   ";
      }
      os << std::endl;
    }
    for (uint8_t x = 0; x < mazeSize; ++x) {
      /* Pillar */
      os << '+';
      /* Horizontal Wall */
      const auto it =
          std::find_if(path.cbegin(), path.cend(), [&](const Pose pose) {
            return WallIndex(pose.p, pose.d) ==
                   WallIndex(Position(x, y), Direction::South);
          });
      const auto w = maze.isWall(x, y, Direction::South);
      const auto k = maze.isKnown(x, y, Direction::South);
      if (it != path.cend())
        os << C_YE << ' ' << it->d << ' ' << C_NO;
      else
        os << (k ? (w ? "---" : "   ") : (C_RE " . " C_NO));
    }
    /* Last Pillar */
    os << '+' << std::endl;
  }
}

呼び出し関係図:

print() [2/3]

void MazeLib::Maze::print	(	const Positions &	positions,
		std::ostream &	os = std::cout,
		const int	mazeSize = MAZE_SIZE
	)		const

位置のハイライト付きの迷路の表示

引数

positions	ハイライトする位置の集合
os	output-stream
mazeSize	迷路の1辺の区画数（正方形のみ対応）

                                           {
  /* preparation */
  const auto exists = [&](const Position p) {
    return std::find(positions.cbegin(), positions.cend(), p) !=
           positions.cend();
  };
  const auto& maze = *this;
  /* start to draw maze */
  for (int8_t y = mazeSize; y >= 0; --y) {
    if (y != mazeSize) {
      for (uint8_t x = 0; x <= mazeSize; ++x) {
        /* Vertical Wall */
        const auto w = maze.isWall(x, y, Direction::West);
        const auto k = maze.isKnown(x, y, Direction::West);
        os << (k ? (w ? "|" : " ") : (C_RE "." C_NO));
        /* Breaking Condition */
        if (x == mazeSize) break;
        /* Cell */
        const auto p = Position(x, y);
        if (p == start)
          os << C_BL << " S " << C_NO;
        else if (std::find(goals.cbegin(), goals.cend(), p) != goals.cend())
          os << C_BL << " G " << C_NO;
        else if (exists(p))
          os << C_YE << " X " << C_NO;
        else
          os << "   ";
      }
      os << std::endl;
    }
    for (uint8_t x = 0; x < mazeSize; ++x) {
      /* Pillar */
      os << '+';
      /* Horizontal Wall */
      const auto w = maze.isWall(x, y, Direction::South);
      const auto k = maze.isKnown(x, y, Direction::South);
      os << (k ? (w ? "---" : "   ") : (C_RE " . " C_NO));
    }
    /* Last Pillar */
    os << '+' << std::endl;
  }
}

print() [3/3]

void MazeLib::Maze::print	(	std::ostream &	os = std::cout,
		const int	mazeSize = MAZE_SIZE
	)		const

迷路の表示

                                                         {
  for (int8_t y = mazeSize; y >= 0; --y) {
    if (y != mazeSize) {
      os << '|';
      for (int8_t x = 0; x < mazeSize; ++x) {
        const auto p = Position(x, y);
        if (p == start)
          os << " S ";
        else if (std::find(goals.cbegin(), goals.cend(), p) != goals.cend())
          os << " G ";
        else
          os << "   ";
        const auto k = isKnown(x, y, Direction::East);
        const auto w = isWall(x, y, Direction::East);
        os << (k ? (w ? '|' : ' ') : '.');
      }
      os << std::endl;
    }
    for (int8_t x = 0; x < mazeSize; ++x) {
      const auto k = isKnown(x, y, Direction::South);
      const auto w = isWall(x, y, Direction::South);
      os << '+' << (k ? (w ? "---" : "   ") : " . ");
    }
    os << '+' << std::endl;
  }
}

呼び出し関係図:

reset()

void MazeLib::Maze::reset	(	const bool	set_start_wall = true,
		const bool	set_range_full = false
	)

迷路の初期化。壁を削除し、スタート区画を既知に

引数

set_start_wall	スタート区画の East と North の壁を設定するかどうか
set_range_full	高速化用の min_x などを予め最大に設定するかどうか

                                                                     {
  wall.reset();
  known.reset();
  min_x = min_y = set_range_full ? 0 : (MAZE_SIZE - 1);
  max_x = max_y = set_range_full ? (MAZE_SIZE - 1) : 0;
  wallRecordsBackupCounter = 0;
  if (set_start_wall) {
    updateWall(Position(0, 0), Direction::East, true);    //< start cell
    updateWall(Position(0, 0), Direction::North, false);  //< start cell
  }
  wallRecords.clear();
}

呼び出し関係図:

resetLastWalls()

void MazeLib::Maze::resetLastWalls	(	const int	num,
		const bool	set_start_wall = true
	)

直前に更新した壁を見探索状態にリセットする

引数

num	消去する直近の壁の数
set_start_wall	スタート区画の East と North の壁を設定するかどうか

                                                                  {
  /* 直近の壁情報を削除 */
  for (int i = 0; i < num && !wallRecords.empty(); ++i) wallRecords.pop_back();
  /* 削除後の壁情報を取得 */
  const auto new_wallRecords = wallRecords;
  /* スタート壁を考慮して迷路を再構築 */
  reset(set_start_wall);
  for (const auto wr : new_wallRecords)
    updateWall(wr.getPosition(), wr.getDirection(), wr.b);
  return;
}

呼び出し関係図:

restoreWallRecordsFromFile()

bool MazeLib::Maze::restoreWallRecordsFromFile

(

const std::string &

filepath

)

壁ログファイルから壁情報を復元する関数

                                                               {
  std::ifstream f(filepath, std::ios::binary);
  if (f.fail()) {
    MAZE_LOGW << "failed to open file! " << filepath << std::endl;
    return false;
  }
  reset();
  while (!f.eof()) {
    WallRecord wr;
    f.read(reinterpret_cast<char*>(&wr), sizeof(WallRecord));
    Position p = Position(wr.x, wr.y);
    Direction d = Direction(wr.d);
    bool b = wr.b;
    updateWall(p, d, b);
    wallRecordsBackupCounter++;
  }
  return true;
}

呼び出し関係図:

setGoals()

void MazeLib::Maze::setGoals ( const Positions &  goals )

inline

ゴール区画の集合を更新

{ this->goals = goals; }

setKnown() [1/3]

void MazeLib::Maze::setKnown ( const int8_t  x, const int8_t  y, const Direction  d, const bool  b  )

inline

                              {
    return setWallBase(known, WallIndex(Position(x, y), d), b);
  }

呼び出し関係図:

setKnown() [2/3]

void MazeLib::Maze::setKnown ( const Position  p, const Direction  d, const bool  b  )

inline

                                                                   {
    return setWallBase(known, WallIndex(p, d), b);
  }

呼び出し関係図:

setKnown() [3/3]

void MazeLib::Maze::setKnown ( const WallIndex  i, const bool  b  )

inline

壁の既知を更新する

引数

i	壁の位置
b	壁の未知既知 true:既知、false:未知

                                                 {
    return setWallBase(known, i, b);
  }

呼び出し関係図:

setStart()

void MazeLib::Maze::setStart ( const Position  start )

inline

スタート区画を更新

{ this->start = start; }

setWall() [1/3]

void MazeLib::Maze::setWall ( const int8_t  x, const int8_t  y, const Direction  d, const bool  b  )

inline

                             {
    return setWallBase(wall, WallIndex(Position(x, y), d), b);
  }

呼び出し関係図:

setWall() [2/3]

void MazeLib::Maze::setWall ( const Position  p, const Direction  d, const bool  b  )

inline

                                                                  {
    return setWallBase(wall, WallIndex(p, d), b);
  }

呼び出し関係図:

setWall() [3/3]

void MazeLib::Maze::setWall ( const WallIndex  i, const bool  b  )

inline

壁を更新をする

引数

i	壁の位置
b	壁の有無 true:壁あり、false:壁なし

                                                {
    return setWallBase(wall, i, b);
  }

呼び出し関係図:

setWallBase()

void MazeLib::Maze::setWallBase ( std::bitset< WallIndex::SIZE > &  wall, const WallIndex  i, const bool  b  ) const

inlineprotected

壁の更新のベース関数。迷路外を参照すると無視される。

                                       {
    if (i.isInsideOfField())  //< 範囲外アクセスの防止
      wall[i.getIndex()] = b;
  }

呼び出し関係図:

unknownCount()

int8_t MazeLib::Maze::unknownCount

(

const Position

p

)

const

引数区画に隣接する未知壁の数を返す

引数

p

区画の座標

戻り値

既知壁の数 0~4

                                                {
  const auto dirs = Direction::Along4();
  return std::count_if(dirs.cbegin(), dirs.cend(),
                       [&](const Direction d) { return !isKnown(p, d); });
}

呼び出し関係図:

updateWall()

bool MazeLib::Maze::updateWall	(	const Position	p,
		const Direction	d,
		const bool	b,
		const bool	pushRecords = true
	)

既知の壁情報と照らしあわせながら、壁を更新する関数

既知の壁と非一致した場合、未知壁にして return する

引数

p	区画の座標
d	壁の方向
b	壁の有無
pushRecords	壁更新の記録に追加する

戻り値

true: 正常に更新された

false: 既知の情報と不一致だった

                                              {
  /* 既知の壁と食い違いがあったら未知壁としてreturn */
  if (isKnown(p, d) && isWall(p, d) != b) {
    setWall(p, d, false);
    setKnown(p, d, false);
    /* ログに追加 */
    if (pushRecords) wallRecords.push_back(WallRecord(p, d, b));
    return false;
  }
  /* 未知壁なら壁情報を更新 */
  if (!isKnown(p, d)) {
    setWall(p, d, b);
    setKnown(p, d, true);
    /* ログに追加 */
    if (pushRecords) wallRecords.push_back(WallRecord(p, d, b));
    /* 最大最小区画を更新 */
    min_x = std::min(p.x, min_x);
    min_y = std::min(p.y, min_y);
    max_x = std::max(p.x, max_x);
    max_y = std::max(p.y, max_y);
  }
  return true;
}

呼び出し関係図:

wallCount()

int8_t MazeLib::Maze::wallCount

(

const Position

p

)

const

引数区画の壁の数を返す

引数

p

区画の座標

戻り値

壁の数 0~4

                                             {
  const auto dirs = Direction::Along4();
  return std::count_if(dirs.cbegin(), dirs.cend(),
                       [&](const Direction d) { return isWall(p, d); });
}

呼び出し関係図:

フレンドと関連関数の詳解

operator>>

std::istream& operator>> ( std::istream &  is, Maze &  maze  )

friend

入力ストリームの迷路データをパースする

使用例: Maze maze; maze << std::cin;

引数

is	テキスト形式の迷路データを含む入力ストリーム
maze	パース結果を書き出す迷路の参照

戻り値

std::istream& 引数の is をそのまま返す

                                                            {
    maze.parse(is);
    return is;
  }

メンバ詳解

goals

Positions MazeLib::Maze::goals

protected

ゴール区画の集合

known

std::bitset<WallIndex::SIZE> MazeLib::Maze::known

protected

壁の既知未知情報

max_x

int8_t MazeLib::Maze::max_x

protected

既知壁の最大区画

max_y

int8_t MazeLib::Maze::max_y

protected

既知壁の最大区画

min_x

int8_t MazeLib::Maze::min_x

protected

既知壁の最小区画

min_y

int8_t MazeLib::Maze::min_y

protected

既知壁の最小区画

start

Position MazeLib::Maze::start

protected

スタート区画

wall

std::bitset<WallIndex::SIZE> MazeLib::Maze::wall

protected

壁情報

wallRecords

WallRecords MazeLib::Maze::wallRecords

protected

更新した壁のログ

wallRecordsBackupCounter

int MazeLib::Maze::wallRecordsBackupCounter

protected

壁ログバックアップのカウンタ

---

このクラス詳解は次のファイルから抽出されました:

• include/MazeLib/Maze.h
• src/Maze.cpp