Selector クラス

ブロック選択クラス [詳解]

#include <Selector.h>

Selector 連携図

公開型
enum	NextOperationOfSearchingRouteIs { Evacuating, Moving, Carrying }
enum	BlockColor {   Blue, Red, Yellow, Green,   Undefined }

公開メンバ関数
	Selector ()
std::vector< int >	exploreNextOperation (std::int8_t currentPosition, BlockColor color)
std::int8_t	searchBlockPosition (std::int8_t currentPosition)
std::int8_t	searchMostPoorCostShelter (std::int8_t currentPosition)
bool	isAlreadyMovedNode (std::int8_t position)
bool	isAlreadyAllBlockMoved ()
void	changeBlockPosition (std::int8_t beforePosition, std::int8_t afterPosition)
void	setBlockPositionList (std::vector< std::int8_t > list)
std::vector< std::int8_t >	getBlockPositionList ()
void	addMovedBlockPosition (std::int8_t position)
void	pushEvacuatedBlockPosition (std::int8_t position)
std::int8_t	popEvacuatedBlockPosition ()
bool	canFindBlockInEvacuatedList (std::int8_t position)
void	prepareSearching (std::vector< std::int8_t > list)
std::vector< int >	searchRoute (std::int8_t start, std::int8_t end)
void	setNext (NextOperationOfSearchingRouteIs next)
bool	isEvacuatingWithNext ()
bool	isMovingWithNext ()
bool	isCarryingWithNext ()
bool	isBacksteppingBeforeNextOperation ()
bool	isBackstepping ()
std::int8_t	getPositionOfCenterQuadirilateral (BlockColor color)
void	updateRoute (std::vector< int > route)
std::vector< int >	extractRoute ()

詳解

ブロック選択クラス

ETロボコン2018における、ブロック並べエリアにおけるルート探索、および次の動作の確認を行います。 Explorer クラス同様、斜め移動は考慮していません。

このクラスのインスタンス保持者 (以下ユーザ) は、最初に setBlockPositionList(std::vector<std::int8_t>) を実行して、このクラスにブロックの位置を設定してください。

ユーザは、次の7つのメンバ関数を随時呼出す必要があります。 1つのルート取得関数でルートを取得し、残りの6つの真偽値判定関数で移動前後の振舞いを判定してください。

• exploreNextOperation()
  ユーザは、現在地から目的地へのルートを取得できます。 目的地については、このクラスが責任を持ちます。
• isBacksteppingBeforeNextOperation()
  目的地に移動する前に、バックステップを行う場合は真を返す真偽値を取得できます。 この戻り値が真の場合、ユーザは移動前にバックステップを行う必要があります。
• isBackstepping()
  目的地に到着した後に、バックステップを行う場合は真を返す真偽値を取得できます。 この戻り値が真の場合、ユーザは移動後にバックステップを行う必要があります。
• isEvacuatingWithNext()
  次の状態が「ブロックの一時避難」の場合は真を返す真偽値を取得できます。 この戻り値が真の場合、ユーザは一時避難状態として動作する必要があります。
• isMovingWithNext()
  次の状態が「次に運搬したいブロック置き場への移動」の場合は真を返す真偽値を取得できます。 この戻り値が真の場合、ユーザは移動状態として動作する必要があります。
• isCarryingWithNext() 次の状態が「ブロックの運搬」の場合は真を返す真偽値を取得できます。 この戻り値が真の場合、ユーザは運搬状態として動作する必要があります。
• isAlreadyAllBlockMoved()
  全てブロックを運搬し終えた場合は真を返す真偽値を取得できます。 この戻り値が真の場合、位置コード11へのルートを探索するため、ユーザは次の動作に備える必要があります。

Example1: when you get some values

Selector selector;
std::vector<std::int8_t> initializedBlockPositionList = {0, 2, 10, 14};

selector.setBlockPositionList(initializedBlockPositionList);

std::int8_t currentPosition = 8;
Selector::BlockColor color = Selector::Undefined;

auto route = obj.exploreNextOperation(currentPosition, color);
bool isBacksteppingBeforeNextOperation = selector.isBacksteppingBeforeNextOperation();
bool isBackstepping = selector.isBackstepping();
bool isEvacuating = selector.isEvacuatingWithNext();
bool isMoving = selector.isMovingWithNext();
bool isCarrying = selector.isCarryingWithNext();
bool isClearGame = selector.isAlreadyAllBlockMoved();
 

Example2: when you use it while you solve puzzle

Selector selector;
std::vector<std::int8_t> initializedBlockPositionList = {0, 2, 10, 14};

selector.setBlockPositionList(initializedBlockPositionList);

std::int8_t currentPosition;
Selector::BlockColor color;

while (!selector.isAlreadyAllBlockMoved())
{
  currentPosition = this->getCurrent();
  color = this->getColor();

  if (selector.isBacksteppingBeforeNextOperation()) this->backstep();

  this->run(obj.exploreNextOperation(currentPosition, color));

  if (selector.isEvacuatingWithNext()) this->evacuate();
  else if (selector.isMovingWithNext()) this->move();
  else if (selector.isCarryingWithNext()) this->carry();

  if (selector.isBackstepping()) this->backstep();
}

this->lookPerpendicularParkingArea();
 

Selector.h の 113 行目に定義があります。

列挙型メンバ詳解

enum Selector::BlockColor

列挙値
Blue
Red
Yellow
Green
Undefined

Selector.h の 140 行目に定義があります。

{ Blue, Red, Yellow, Green, Undefined };

enum Selector::NextOperationOfSearchingRouteIs

列挙値
Evacuating
Moving
Carrying

Selector.h の 138 行目に定義があります。

{ Evacuating, Moving, Carrying };

構築子と解体子

Selector::Selector ( )

inline

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

各ブロック置き場における位置コストのリストを作成し、そのサイズを元にノードリストを初期化しています。

Selector.h の 122 行目に定義があります。

    : blockPositionList(MAX_BLOCK_COUNT),
      movedBlockPositionList(MAX_BLOCK_COUNT, EMPTY_ID),
      evacuatedBlockPositionList(MAX_BLOCK_COUNT, EMPTY_ID),
      nodePositionCostList(TOTAL_NODE_COUNT),
      routeBeforeOne_(TOTAL_NODE_COUNT, EMPTY_ID)
  {
    // 各ノードにおける位置コストのリスト
    std::vector<int> nodePositionCostList_{ { 4, 3, 3, 4, 3, 2, 2, 3, 1, 2, 2, 3, 4, 3, 3, 4 } };

    for(unsigned int i = 0; i < nodePositionCostList_.size(); i++)
      nodePositionCostList[i] = nodePositionCostList_[i];

    explorer.createBlockArea();
  }

呼び出し関係図:

関数詳解

void Selector::addMovedBlockPosition

(

std::int8_t

position

)

Selector.cpp の 208 行目に定義があります。

{
  movedBlockPositionList[movedCount] = position;
  movedCount++;
}

被呼び出し関係図:

bool Selector::canFindBlockInEvacuatedList

(

std::int8_t

position

)

Selector.cpp の 226 行目に定義があります。

{
  auto itr
      = std::find(evacuatedBlockPositionList.begin(), evacuatedBlockPositionList.end(), position);
  return itr != evacuatedBlockPositionList.end();
}

被呼び出し関係図:

void Selector::changeBlockPosition	(	std::int8_t	beforePosition,
		std::int8_t	afterPosition
	)

Selector.cpp の 188 行目に定義があります。

{
  auto itr = std::find(blockPositionList.begin(), blockPositionList.end(), beforePosition);
  auto index = std::distance(blockPositionList.begin(), itr);

  blockPositionList[index] = afterPosition;
}

被呼び出し関係図:

std::vector< int > Selector::exploreNextOperation	(	std::int8_t	currentPosition,
		BlockColor	color
	)

目的地までのルート探索および動作判定を行います。

現在地とブロックの色を選択すると、次に移動すべきブロック置き場 (目的地) までのルートを取得します。 また、内部変数の真偽値に、次の動作を設定します。

この関数を利用する場合は、内部変数の真偽値も参照してください。 詳細は Selector クラスの説明を参照してください。

引数

currentPosition	現在地
color	取得したブロックの色 取得していない場合は Selector::Undefined を設定する必要があります。

戻り値

現在地から目的地までの位置コードのリスト
最小で要素数1です。

Selector.cpp の 3 行目に定義があります。

{
  const std::int8_t shelterWhenPathBlocked = 12;
  const std::int8_t shelterWhenAllNodeInitialPositionsIsFromCenter = 12;
  const std::int8_t goal = 11;
  auto nextBlock = searchBlockPosition(currentPosition);
  auto nextMovedPosition = getPositionOfCenterQuadirilateral(color);
  auto routeBeforeOne = extractRoute();
  auto next = nextBlock;
  auto start = currentPosition;
  backsteppingFlag = false;
  backsteppingBeforeNextOeperationFlag = false;
  isClearGame = !isAlreadyMovedNode(EMPTY_ID);

  if(currentPosition == 8 && nextBlock == 8) {
    if(color == Undefined) {
      setNext(Moving);
    } else {
      if(explorer.hasBlock(4) && explorer.hasBlock(9) && explorer.hasBlock(13)) {
        setNext(Evacuating);
        next = shelterWhenPathBlocked;
        pushEvacuatedBlockPosition(shelterWhenPathBlocked);
      } else if(explorer.hasBlock(nextMovedPosition)) {
        setNext(Evacuating);
        next = searchMostPoorCostShelter(currentPosition);
        pushEvacuatedBlockPosition(next);
      }
      // else if (explorer.hasBlock(4) && explorer.hasBlock(9) && explorer.hasBlock(12))
      // {
      //   // もし最初の位置コード8のブロックを囲むように周りにブロックが存在した場合
      //   // 現在は未実装
      // }
      else {
        setNext(Carrying);
        next = nextMovedPosition;
      }
    }
  } else if(lastBlock != EMPTY_ID
            && std::distance(movedBlockPositionList.begin(),
                             std::find(movedBlockPositionList.begin(), movedBlockPositionList.end(),
                                       EMPTY_ID))
                   == 3) {
    setNext(Moving);
    next = lastBlock;
    lastBlock = EMPTY_ID;
  } else if(!isClearGame) {
    if(color == Undefined) {
      if(evacuatedSize > 0 && carryingFlag) {
        setNext(Moving);
        next = popEvacuatedBlockPosition();
      } else if(evacuatedSize > 0 && isCarriedToShelter) {
        setNext(Moving);
        next = popEvacuatedBlockPosition();
        isCarriedToShelter = false;
      } else {
        setNext(Moving);
      }
    } else {
      if(explorer.hasBlock(5) && explorer.hasBlock(6) && explorer.hasBlock(9)
         && explorer.hasBlock(10)) {
        setNext(Evacuating);
        next = shelterWhenAllNodeInitialPositionsIsFromCenter;
        lastBlock = shelterWhenAllNodeInitialPositionsIsFromCenter;
      } else if(explorer.hasBlock(nextMovedPosition)) {
        if(canFindBlockInEvacuatedList(nextMovedPosition)) {
          next = searchMostPoorCostShelter(currentPosition);
          setNext(Evacuating);
          isCarriedToShelter = true;
        } else {
          pushEvacuatedBlockPosition(currentPosition);
          start = routeBeforeOne[routeBeforeOne.size() - 2];
          next = nextMovedPosition;
          setNext(Moving);
          backsteppingBeforeNextOeperationFlag = true;
        }
      } else {
        setNext(Carrying);
        next = nextMovedPosition;
      }
    }
  } else  // if (isClearGame)
  {
    setNext(Moving);
    next = goal;
  }

  if(evacuatingFlag || carryingFlag) backsteppingFlag = true;

  if((evacuatingFlag || carryingFlag) && !backsteppingBeforeNextOeperationFlag)
    changeBlockPosition(currentPosition, next);

  explorer.resetBlockArea();
  for(auto position : blockPositionList) explorer.setHasBlockIn(position);
  std::vector<int> route = searchRoute(start, next);

  // updateRoute(route);
  {
    // updateRoute(std::vector<int>)を利用するとメモリ肥大化をしてしまう
    // おそらく仮引数routeへの代入が問題
    // 関数内の文字列をまるまるコピペし、中括弧でくくる突貫工事で対応した
    for(auto itr = routeBeforeOne_.begin(); itr != routeBeforeOne_.end(); itr++) (*itr) = EMPTY_ID;

    int count = 0;

    for(auto node : route) {
      routeBeforeOne_[count] = node;
      count++;
    }
  }

  if(carryingFlag) addMovedBlockPosition(next);

  return route;
}

呼び出し関係図:

被呼び出し関係図:

std::vector< int > Selector::extractRoute

(

)

Selector.cpp の 347 行目に定義があります。

{
  std::vector<int> route(TOTAL_NODE_COUNT, EMPTY_ID);

  for(int i = 0; i < TOTAL_NODE_COUNT; i++) {
    if(routeBeforeOne_[i] == EMPTY_ID)
      route.pop_back();
    else
      route[i] = routeBeforeOne_[i];
  }

  return route;
}

被呼び出し関係図:

std::vector< std::int8_t > Selector::getBlockPositionList

(

)

Selector.cpp の 203 行目に定義があります。

{
  return blockPositionList;
}

被呼び出し関係図:

std::int8_t Selector::getPositionOfCenterQuadirilateral

(

BlockColor

color

)

Selector.cpp の 304 行目に定義があります。

{
  std::int8_t node;

  switch(color) {
    case Blue:
      node = 10;
      break;

    case Red:
      node = 6;
      break;

    case Yellow:
      node = 9;
      break;

    case Green:
      node = 5;
      break;

    case Undefined:
    default:
      node = EMPTY_ID;
      break;
  }

  return node;
}

被呼び出し関係図:

bool Selector::isAlreadyAllBlockMoved

(

)

Selector.cpp の 183 行目に定義があります。

{
  return isClearGame;
}

被呼び出し関係図:

bool Selector::isAlreadyMovedNode

(

std::int8_t

position

)

Selector.cpp の 177 行目に定義があります。

{
  auto itr = std::find(movedBlockPositionList.begin(), movedBlockPositionList.end(), position);
  return itr != movedBlockPositionList.end();
}

被呼び出し関係図:

bool Selector::isBackstepping

(

)

Selector.cpp の 294 行目に定義があります。

{
  return backsteppingFlag;
}

被呼び出し関係図:

bool Selector::isBacksteppingBeforeNextOperation

(

)

Selector.cpp の 299 行目に定義があります。

{
  return backsteppingBeforeNextOeperationFlag;
}

被呼び出し関係図:

bool Selector::isCarryingWithNext

(

)

Selector.cpp の 289 行目に定義があります。

{
  return carryingFlag;
}

被呼び出し関係図:

bool Selector::isEvacuatingWithNext

(

)

Selector.cpp の 279 行目に定義があります。

{
  return evacuatingFlag;
}

被呼び出し関係図:

bool Selector::isMovingWithNext

(

)

Selector.cpp の 284 行目に定義があります。

{
  return movingFlag;
}

被呼び出し関係図:

std::int8_t Selector::popEvacuatedBlockPosition

(

)

Selector.cpp の 220 行目に定義があります。

{
  evacuatedSize--;
  return evacuatedBlockPositionList[evacuatedSize];
}

被呼び出し関係図:

void Selector::prepareSearching

(

std::vector< std::int8_t >

list

)

Selector.cpp の 233 行目に定義があります。

{
  explorer.resetBlockArea();

  for(auto id : list) {
    explorer.setHasBlockIn(id);
  }
}

呼び出し関係図:

被呼び出し関係図:

void Selector::pushEvacuatedBlockPosition

(

std::int8_t

position

)

Selector.cpp の 214 行目に定義があります。

{
  evacuatedBlockPositionList[evacuatedSize] = position;
  evacuatedSize++;
}

被呼び出し関係図:

std::int8_t Selector::searchBlockPosition

(

std::int8_t

currentPosition

)

Selector.cpp の 118 行目に定義があります。

{
  std::int8_t blockPosition = -1;
  int minCost = 9999;

  for(auto checkedBlock : blockPositionList) {
    if(isAlreadyMovedNode(checkedBlock)) continue;

    explorer.resetBlockArea();
    for(auto position : blockPositionList) explorer.setHasBlockIn(position);

    if(checkedBlock == currentPosition) {
      minCost = 0;
      blockPosition = checkedBlock;
      break;
    }

    auto route = explorer.searchRoute(currentPosition, checkedBlock);
    int cost = route.size() - 1 + nodePositionCostList[checkedBlock];

    if(minCost > cost) {
      minCost = cost;
      blockPosition = checkedBlock;
    }
  }

  return blockPosition;
}

呼び出し関係図:

被呼び出し関係図:

std::int8_t Selector::searchMostPoorCostShelter

(

std::int8_t

currentPosition

)

Selector.cpp の 147 行目に定義があります。

{
  std::int8_t blockPosition = -1;
  int minCost = 9999;
  std::vector<std::int8_t> shelters = { 0, 3, 12, 15 };

  for(auto shelter : shelters) {
    explorer.resetBlockArea();
    for(auto position : blockPositionList) explorer.setHasBlockIn(position);

    if(explorer.hasBlock(shelter)) continue;

    if(shelter == currentPosition) {
      minCost = 0;
      blockPosition = shelter;
      break;
    }

    auto route = explorer.searchRoute(currentPosition, shelter);
    int cost = route.size() - 1;

    if(minCost > cost) {
      minCost = cost;
      blockPosition = shelter;
    }
  }

  return blockPosition;
}

呼び出し関係図:

被呼び出し関係図:

std::vector< int > Selector::searchRoute	(	std::int8_t	start,
		std::int8_t	end
	)

Selector.cpp の 242 行目に定義があります。

{
  if(start == end) {
    std::vector<int> only{ 1 };
    only[0] = start;
    return only;
  } else {
    return explorer.searchRoute(start, end);
  }
}

呼び出し関係図:

被呼び出し関係図:

void Selector::setBlockPositionList

(

std::vector< std::int8_t >

list

)

Selector.cpp の 196 行目に定義があります。

{
  for(unsigned int i = 0; i < blockPositionList.size(); i++) {
    blockPositionList[i] = list[i];
  }
}

被呼び出し関係図:

void Selector::setNext

(

NextOperationOfSearchingRouteIs

next

)

Selector.cpp の 253 行目に定義があります。

{
  switch(next) {
    case Evacuating:
      evacuatingFlag = true;
      movingFlag = false;
      carryingFlag = false;
      break;

    case Moving:
      evacuatingFlag = false;
      movingFlag = true;
      carryingFlag = false;
      break;

    case Carrying:
      evacuatingFlag = false;
      movingFlag = false;
      carryingFlag = true;
      break;

    default:
      break;
  }
}

被呼び出し関係図:

void Selector::updateRoute

(

std::vector< int >

route

)

Selector.cpp の 334 行目に定義があります。

{
  for(auto itr = routeBeforeOne_.begin(); itr != routeBeforeOne_.end(); itr++) (*itr) = EMPTY_ID;

  int count = 0;

  for(auto node : route) {
    routeBeforeOne_[count] = node;
    count++;
  }
}

被呼び出し関係図:

---

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

• str/apps/include/Selector.h
• str/apps/src/Selector.cpp