Powershell（オセロ013）のロジック6までを入れたバージョンから少し修正したものです。
下のコードをメモ帳にコピー後、文字コードUTF8(BOM付き)、拡張子ps1で保存、実行で動くと思います。
・オセロのゲームで、白と黒で交互に自動的に石を置く。
置く場所は、ロジック0～６により決定（0: ランダム, 1: 四隅優先, 2: 1つの区画優先, 3: 裏返す石が最大, 4: 裏返す石が最小 (途中から), 5: 3手目で勝ち筋となる手が多いものを選択, 6: 0, 3, 5のミックス）。
・置くことができない場合、passして相手側の手順になる。
・白と黒どちらも置けない場合は終了。
・コンソール表示は、ゲーム毎の結果のみ。盤上のデータはテキストファイルに保存。
■ 実行例
■ サンプルコード
# =========================================================================
# [Board]クラス: オセロの盤（10×10マス (黒（"●"）、白（"〇"）、空欄（"＿"）のどれか。）、表示の機能、結果集計機能
# [Player]クラス: プレイヤー（白か黒、ロジックを持つ）、石を置く機能、裏返す機能
# [Logic]クラス:0,ランダム 1,四隅優先 2,1つの区画優先（左上、右上、右下、左下） 3,最大数（最大数となるものでランダム） 4,最小数（途中から変更） 5,3手目で勝ち筋となる手が多いものを選択 6,ミックス
# [Utility]クラス: よく使う機能をメソッドに取り出したクラス
# $turn: 順番（player AかB）
# $endflag: ゲーム終了を判断するフラグ（passが両プレイヤーから連続した場合に終了）
# $trialnum: 現在、何手目かのカウント（無効となる場所に石を置いたときはカウントされない）
# =========================================================================
# $TEXTFILE= (結果を保存するファイル名)
# $GAME_NUM = (オセロを行う回数）
# $PLAYER_A_LOGIC=（プレイヤーAのロジック: 0~6）
# $PLAYER_B_LOGIC=（プレイヤーBのロジック: 0~6）
# =========================================================================
$TEXTFILE="result.txt"
$GAME_NUM = 1000
$PLAYER_A_LOGIC=0
$PLAYER_B_LOGIC=1
# =========================================================================
$result = @(0,0,0)
# GAME_NUMの数だけゲームを行う
for ($i=1; $i -le $GAME_NUM ; $i++) {
$othboard = [Board]::new()
$playerA = [Player]::new("〇", $PLAYER_A_LOGIC)
$playerB = [Player]::new("●", $PLAYER_B_LOGIC)
$turn = $playerA
$endflag = 0
$trialnum = 0
echo ("Game:"+$i+"| Start Othello") | Out-file $TEXTFILE -Append
$othboard.showBoard($othboard.boardData) | Out-file $TEXTFILE -Append
# 1ゲームの中、石を置く処理を繰り返す。
while($true) {
if ($turn -eq $playerA) {
$position = $playerA.placeStone($othboard.boardData,$playerA.logic)
if ($position -eq "pass") {
$endflag += $endflag + 1
$turn = $playerB
} else {
$othboard.boardData = $playerA.reverseStones($position, $othboard.boardData)
$trialnum++
$turn = $playerB
}
} elseif ($turn -eq $playerB) {
$position = $playerB.placeStone($othboard.boardData,$playerB.logic)
if ($position -eq "pass") {
$endflag += $endflag + 1
$turn = $playerA
} else {
$othboard.boardData = $playerB.reverseStones($position, $othboard.boardData)
$trialnum++
$turn = $playerA
}
}
echo ("=====Trial:"+$trialnum+"=====") | Out-file $TEXTFILE -Append
[String]$str = $othboard.showBoard($othboard.boardData)
echo ($str) | Out-file $TEXTFILE -Append
if ($endflag -ge 2) {
break
} elseif ($trialnum -ge 60) {
break
}
}
[String]$str = $othboard.sumResult($othboard.boardData, $result)
echo ($str + " Game:"+$i+" | End Othello")
echo ($str + " Game:"+$i+" | End Othello") | Out-file $TEXTFILE -Append
}
echo ("●"+$result[0]+"vs〇"+$result[1]+"vsE"+$result[2])
##############################################################
## [Board]クラス:
# コンストラクタ
# 表示の機能：[String]showBoard($boardData)
# 結果集計機能：[String]sumResult($boardData, $result)
##############################################################
class Board {
$boardData
#コンストラクタ、盤上のデータを初期化
Board() {
$this.boardData=@(
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','〇','●','＿','＿','＿','＿'),
@('＿','＿','＿','＿','●','〇','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿')
)
}
#盤上のデータ表示（引数：盤上のデータ、戻し値：現在の盤上を示した文字列）
[String]showBoard($boardData) {
[String]$boardStr=""
for ($n=1; $n -lt 8; $n++) {
$boardStr+=$boardData[$n][1]+$boardData[$n][2]+$boardData[$n][3]+$boardData[$n][4]+$boardData[$n][5]+$boardData[$n][6]+$boardData[$n][7]+$boardData[$n][8]+"`r`n"
}
$boardStr+=$boardData[$n][1]+$boardData[$n][2]+$boardData[$n][3]+$boardData[$n][4]+$boardData[$n][5]+$boardData[$n][6]+$boardData[$n][7]+$boardData[$n][8]
return $boardStr
}
#結果集計、白の石と黒の石のカウントとresultの勝敗を1つ増やす（引数：盤上のデータ、複数のゲームの勝率、戻し値：結果として表示する文字列）
[String]sumResult($boardData, $result) {
$whitecnt = 0
$blackcnt = 0
for ($n=1; $n -le 8; $n++) {
for ($m=1; $m -le 8; $m++) {
if ($boardData[$n][$m] -eq "●") {
$blackcnt++
} elseif ($boardData[$n][$m] -eq "〇") {
$whitecnt++
}
}
}
if ($blackcnt -gt $whitecnt) {
$result[0]++
} elseif ($blackcnt -lt $whitecnt) {
$result[1]++
} elseif ($blackcnt -eq $whitecnt) {
$result[2]++
}
return ("●"+$blackcnt+"vs〇"+$whitecnt)
}
}
##############################################################
## [Player]クラス:
# コンストラクタ
# 石を置く機能：[String]placeStone($boardData, $logic_num)（手動入力の場合、[String]placeStone($boardData)）
# 裏返す機能：[String[][]]reverseStones($position, $boardData)
##############################################################
class Player {
$playerColor
$logic
#コンストラクタ、プレイヤーデータを初期化
Player($color, $logicNum) {
$this.playerColor = $color
$this.logic = $logicNum
}
#石を置く処理（引数：盤上のデータ、ロジックの番号、戻し値：石を置く場所の文字列（11~88））
[String]placeStone($boardData, $logic_num) {
$logic_num = $this.logic
$position ="00"
$blankArray=@()
$inputArray=@()
for ($n=1; $n -le 8; $n++) {
for ($m=1; $m -le 8; $m++) {
if ($boardData[$n][$m] -eq '＿') {
$blankArray+= [string]$n + [string]$m
}else{
}
}
}
if ($blankArray.count -eq 0) {
$position = "pass"
} else{
if ($blankArray.count -eq 1) {
$inputArray = $blankArray
} else {
if ($logic_num -eq 0) {
$inputArray = [Logic]::logic_random($blankArray)
}elseif ($logic_num -eq 1){
$inputArray = [Logic]::logic_corner($blankArray, $boardData)
}elseif ($logic_num -eq 2){
$inputArray = [Logic]::logic_zone($blankArray, $boardData)
}elseif ($logic_num -eq 3){
$inputArray = [Logic]::logic_max($blankArray, $boardData, $this)
}elseif ($logic_num -eq 4){
$inputArray = [Logic]::logic_min($blankArray, $boardData, $this)
}elseif ($logic_num -eq 5){
$inputArray = [Logic]::logic_winroute($blankArray, $boardData, $this)
}elseif ($logic_num -eq 6){
$inputArray = [Logic]::logic_mix($blankArray, $boardData, $this)
}
}
#石を置いた場合に裏返すものがあるかのチェック（裏返すものがなければ、pass）
foreach ($position in $inputArray) {
$tempBoard = [Utility]::copyBoard($boardData)
$tempClass = [Player]::new($this.playercolor, $this.logic)
$tempClass.reverseStones($position, $tempBoard)
$canBeReversed = [Utility]::compareBoard($tempBoard, $boardData)
if($canBeReversed) {
$position = "pass"
} else {
break
}
}
}
return $position
}
#石を置く処理（引数：盤上のデータ、戻し値：石を置く場所の文字列（11~88））
[String]placeStone($boardData) {
$position='00'
while ($true) {
$position = Read-Host ("Player ("+$this.playerColor+")")
if($position -eq "pass") {
break
} elseif($position.length -le 1) {
} else {
$line=$position.substring(0,1)
$row=$position.substring(1,1)
if (($line -ge 1) -And ($line -le 8) -And ($row -ge 1) -And ($row -le 8)) {
if ($boardData[$line][$row] -eq "＿") {
$tempBoard = [Utility]::copyBoard($boardData)
$tempClass = [Player]::new($this.playercolor, $this.logic)
$tempClass.reverseStones($position, $tempBoard)
$canBeReversed = [Utility]::compareBoard($tempBoard, $boardData)
if($canBeReversed) {
} else { break
}
}
}
}
}
return $position
}
#石を裏返す処理（引数：石を置く場所、盤上のデータ、戻し値：裏返した後の盤上のデータ）
[String[][]]reverseStones($position, $boardData) {
if ($position -eq "pass") {
return $boardData
}
for ($checkcnt=0; $checkcnt -lt 8; $checkcnt++) {
$line=$position.substring(0,1)
$row=$position.substring(1,1)
[Int]$startline=$line
[Int]$startrow=$row
[Int]$opponentstonenum=0
for ($extension=0; $extension -lt 8; $extension++) {
if ($checkcnt -eq 0) {
$startline=$startline-1
} elseif ($checkcnt -eq 1) {
$startline=$startline-1
$startrow=$startrow+1
} elseif ($checkcnt -eq 2) {
$startrow=$startrow+1
} elseif ($checkcnt -eq 3) {
$startline=$startline+1
$startrow=$startrow+1
} elseif ($checkcnt -eq 4) {
$startline=$startline+1
} elseif ($checkcnt -eq 5) {
$startline=$startline+1
$startrow=$startrow-1
} elseif ($checkcnt -eq 6) {
$startrow=$startrow-1
} elseif ($checkcnt -eq 7) {
$startline=$startline-1
$startrow=$startrow-1
} else {
}
if ($boardData[$startline][$startrow] -eq "＿") {
break
} elseif ($boardData[$startline][$startrow] -ne $this.playerColor) {
$opponentstonenum=$opponentstonenum+1
} elseif ($boardData[$startline][$startrow] -eq $this.playerColor) {
if ($opponentstonenum -ge 1) {
if ($checkcnt -eq 0) {
for ($startline;$startline -le $line;$startline++) {
$boardData[$startline][$startrow]=$this.playerColor
}
break
} elseif ($checkcnt -eq 1) {
for ($startline;$startline -le $line;$startline++) {
$boardData[$startline][$startrow]=$this.playerColor
$startrow=$startrow-1
}
break
} elseif ($checkcnt -eq 2) {
for ($startrow;$startrow -ge $row;$startrow--) {
$boardData[$startline][$startrow]=$this.playerColor
}
break
} elseif ($checkcnt -eq 3) {
for ($startrow;$startrow -ge $row;$startrow--) {
$boardData[$startline][$startrow]=$this.playerColor
$startline=$startline-1
}
break
} elseif ($checkcnt -eq 4) {
for ($startline;$startline -ge $line;$startline--) {
$boardData[$startline][$startrow]=$this.playerColor
}
break
} elseif ($checkcnt -eq 5) {
for ($startline;$startline -ge $line;$startline--) {
$boardData[$startline][$startrow]=$this.playerColor
$startrow=$startrow+1
}
break
} elseif ($checkcnt -eq 6) {
for ($startrow;$startrow -le $row;$startrow++) {
$boardData[$startline][$startrow]=$this.playerColor
}
break
} elseif ($checkcnt -eq 7) {
for ($startrow;$startrow -le $row;$startrow++) {
$boardData[$startline][$startrow]=$this.playerColor
$startline=$startline+1
}
break
}
} else {
break
}
}
}
}
return $boardData
}
}
##############################################################
## [Logic]クラス:
##############################################################
Class Logic{
static [String[]]logic_random($blankArray) {
$inputArray=@()
$inputArray = get-random -input $blankArray -count ([int]::MaxValue)
return $inputArray
}
static [String[]]logic_corner($blankArray, $boardData) {
$inputArray=@()
$inputArray = get-random -input $blankArray -count ([int]::MaxValue)
$cornerArray = @()
if ($boardData[1][1] -eq '＿') {
$cornerArray += "11"
}
if ($boardData[8][1] -eq '＿') {
$cornerArray += "81"
}
if ($boardData[1][8] -eq '＿') {
$cornerArray += "18"
}
if ($boardData[8][8] -eq '＿') {
$cornerArray += "88"
}
$inputArray = $cornerArray + $inputArray
return $inputArray
}
static [String[]]logic_zone($blankArray, $boardData) {
$inputArray=@()
$zoneArray = @()
for ($n=1; $n -le 4; $n++) {
for ($m=1; $m -le 4; $m++) {
if ($boardData[$n][$m] -eq '＿') {
$zoneArray+= [string]$n + [string]$m
}else{
}
}
}
if($zoneArray.count -eq 0) {
} elseif($zoneArray.count -eq 1) {
$inputArray = $zoneArray
} else {
$inputArray = get-random -input $zoneArray -count ([int]::MaxValue)
}
$zoneArray = @()
for ($n=1; $n -le 4; $n++) {
for ($m=5; $m -le 8; $m++) {
if ($boardData[$n][$m] -eq '＿') {
$zoneArray+= [string]$n + [string]$m
}else{
}
}
}
if($zoneArray.count -eq 0) {
} elseif($zoneArray.count -eq 1) {
$inputArray = $zoneArray
} else {
$inputArray = $inputArray + (get-random -input $zoneArray -count ([int]::MaxValue))
}
$zoneArray = @()
for ($n=5; $n -le 8; $n++) {
for ($m=5; $m -le 8; $m++) {
if ($boardData[$n][$m] -eq '＿') {
$zoneArray+= [string]$n + [string]$m
}else{
}
}
}
if($zoneArray.count -eq 0) {
} elseif($zoneArray.count -eq 1) {
$inputArray = $zoneArray
} else {
$inputArray = $inputArray + (get-random -input $zoneArray -count ([int]::MaxValue))
}
$zoneArray = @()
for ($n=5; $n -le 8; $n++) {
for ($m=1; $m -le 4; $m++) {
if ($boardData[$n][$m] -eq '＿') {
$zoneArray+= [string]$n + [string]$m
}else{
}
}
}
if($zoneArray.count -eq 0) {
} elseif($zoneArray.count -eq 1) {
$inputArray = $zoneArray
} else {
$inputArray = $inputArray + (get-random -input $zoneArray -count ([int]::MaxValue))
}
return $inputArray
}
static [String[]]logic_max($blankArray, $boardData, $Player) {
$max_diff_num = 0
$tempposition ="00"
$inputArray = get-random -input $blankArray -count ([int]::MaxValue)
foreach ($position in $inputArray) {
$tempBoard = [Utility]::copyBoard($boardData)
$tempClass = [Player]::new($Player.playercolor, $Player.logic)
$tempClass.reverseStones($position, $tempBoard)
$diff_num = [Utility]::compareBoardDiffNum($tempBoard, $boardData)
if ($diff_num -gt $max_diff_num) {
$max_diff_num = $diff_num
$tempposition = $position
}
}
$inputArray[0] = $tempposition
return $inputArray
}
static [String[]]logic_min($blankArray, $boardData, $Player) {
$min_diff_num = 32
$tempposition ="00"
$inputArray = get-random -input $blankArray -count ([int]::MaxValue)
if($blankArray.count -le 55) {
} else{
foreach ($position in $inputArray) {
$tempBoard = [Utility]::copyBoard($boardData)
$tempClass = [Player]::new($Player.playercolor, $Player.logic)
$tempClass.reverseStones($position, $tempBoard)
$diff_num = [Utility]::compareBoardDiffNum($tempBoard, $boardData)
if ($diff_num -ne 0) {
if ($diff_num -lt $min_diff_num) {
$min_diff_num = $diff_num
$tempposition = $position
}
}
}
$inputArray[0] = $tempposition
}
return $inputArray
}
static [String[]]logic_winroute($blankArray, $boardData, $Player) {
$max_win_route_rate = 0
$tempposition ="00"
$inputArray = get-random -input $blankArray -count ([int]::MaxValue)
$boardList = [System.Collections.ArrayList]::new()
foreach ($position in $inputArray) {
$win_route = 0
$boardList.clear()
$tempBoard = [Utility]::copyBoard($boardData)
$tempClass = [Player]::new($Player.playerColor, $Player.logic)
$tempClass.reverseStones($position, $tempBoard)
$canBeReversed = [Utility]::compareBoard($tempBoard, $boardData)
if($canBeReversed) {
} else {
if($Player.playerColor -eq "●") {
$tempboardList = [System.Collections.ArrayList]::new()
$tempboardList = [Utility]::reversedBoardList($tempBoard, "〇")
foreach ($nextBlackTurnBoard in $tempboardList) {
$boardList.AddRange([Utility]::reversedBoardList($nextBlackTurnBoard, "●"))
}
} elseif ($Player.playerColor -eq "〇") {
$tempboardList = [System.Collections.ArrayList]::new()
$tempboardList = [Utility]::reversedBoardList($tempBoard, "●")
foreach ($nextWhiteTurnBoard in $tempboardList) {
$boardList.AddRange([Utility]::reversedBoardList($nextWhiteTurnBoard, "〇"))
}
}
foreach ($field in $boardList) {
$fieldLeth = ""
foreach($item in $field) {
$fieldLeth = $fieldLeth + ($item -join "")
}
$blackcnt = $fieldLeth.Length - ($fieldLeth -replace "●","").Length
$whitecnt = $fieldLeth.Length - ($fieldLeth -replace "〇","").Length
if($Player.playerColor -eq "●") {
if($blackcnt -gt $whitecnt) {
$win_route++
}
} elseif ($Player.playerColor -eq "〇") {
if($whitecnt -gt $blackcnt) {
$win_route++
}
}
}
if ($boardList.count -eq 0) {
} else {
if (($win_route/$boardList.count) -ge $max_win_route_rate) {
$max_win_route_rate = $win_route/$boardList.count
$tempposition = $position
}
}
}
}
$inputArray[0] = $tempposition
return $inputArray
}
static [String[]]logic_mix($blankArray, $boardData, $Player) {
######
#最も多くの石を裏返すところをリスト化する。
$max_diff_num = 0
$tempposition ="00"
$maxboardList = [System.Collections.ArrayList]::new()
$inputArray = get-random -input $blankArray -count ([int]::MaxValue)
foreach ($position in $inputArray) {
$tempBoard = [Utility]::copyBoard($boardData)
$tempClass = [Player]::new($Player.playercolor, $Player.logic)
$tempClass.reverseStones($position, $tempBoard)
$diff_num = [Utility]::compareBoardDiffNum($tempBoard, $boardData)
if ($diff_num -gt $max_diff_num) {
$max_diff_num = $diff_num
$maxboardList.Add($position)
}
}
######
######
#上で作ったリストから３手目先で勝っている状態となるルートとなる確率が高い一手を選択する。
$max_win_route_rate = 0
$tempposition ="00"
$boardList = [System.Collections.ArrayList]::new()
foreach ($position in $maxboardList) {
$win_route = 0
$boardList.clear()
$tempBoard = [Utility]::copyBoard($boardData)
$tempClass = [Player]::new($Player.playerColor, $Player.logic)
$tempClass.reverseStones($position, $tempBoard)
$canBeReversed = [Utility]::compareBoard($tempBoard, $boardData)
if($canBeReversed) {
} else {
if($Player.playerColor -eq "●") {
$tempboardList = [System.Collections.ArrayList]::new()
$tempboardList = [Utility]::reversedBoardList($tempBoard, "〇")
foreach ($nextBlackTurnBoard in $tempboardList) {
$boardList.AddRange([Utility]::reversedBoardList($nextBlackTurnBoard, "●"))
}
} elseif ($Player.playerColor -eq "〇") {
$tempboardList = [System.Collections.ArrayList]::new()
$tempboardList = [Utility]::reversedBoardList($tempBoard, "●")
foreach ($nextWhiteTurnBoard in $tempboardList) {
$boardList.AddRange([Utility]::reversedBoardList($nextWhiteTurnBoard, "〇"))
}
}
foreach ($field in $boardList) {
$fieldLeth = ""
foreach($item in $field) {
$fieldLeth = $fieldLeth + ($item -join "")
}
$blackcnt = $fieldLeth.Length - ($fieldLeth -replace "●","").Length
$whitecnt = $fieldLeth.Length - ($fieldLeth -replace "〇","").Length
if($Player.playerColor -eq "●") {
if($blackcnt -gt $whitecnt) {
$win_route++
}
} elseif ($Player.playerColor -eq "〇") {
if($whitecnt -gt $blackcnt) {
$win_route++
}
}
}
if ($boardList.count -eq 0) {
} else {
if (($win_route/$boardList.count) -ge $max_win_route_rate) {
$max_win_route_rate = $win_route/$boardList.count
$tempposition = $position
}
}
}
}
$inputArray[0] = $tempposition
######
######
#上で選択した一手より四隅を優先する。
$cornerArray = @()
if ($boardData[1][1] -eq '＿') {
$cornerArray += "11"
}
if ($boardData[8][1] -eq '＿') {
$cornerArray += "81"
}
if ($boardData[1][8] -eq '＿') {
$cornerArray += "18"
}
if ($boardData[8][8] -eq '＿') {
$cornerArray += "88"
}
$inputArray = $cornerArray + $inputArray
######
return $inputArray
}
}
##############################################################
## [Utility]クラス:
# 盤上のデータを比較する機能：[Boolean]compareBoard($tempBoard, $boardData)
# 盤上のデータを比較する機能(差の取得）：[Int]compareBoardDiffNum($tempBoard, $boardData)
# 盤上のデータをコピーする機能：[String[][]]copyBoard($boardData)
# 盤上のデータから石をおくことができる場所に石を置いた際の盤上のデータのリストを返す
##############################################################
Class Utility {
#盤上のデータを比較する機能（引数：盤上データ、盤上のデータ、戻し値：一致するかどうか（$true, $false））
static [Boolean]compareBoard($tempBoard, $boardData) {
for ($n=1; $n -le 8; $n++) {
for ($m=1; $m -le 8; $m++) {
if ($boardData[$n][$m] -eq $tempBoard[$n][$m]) {
}else{
return $false
}
}
}
return $true
}
#盤上のデータを比較する機能（引数：盤上データ、盤上のデータ、戻し値：差の数））
static [Int]compareBoardDiffNum($tempBoard, $boardData) {
[Int]$diff_num = 0
for ($n=1; $n -le 8; $n++) {
for ($m=1; $m -le 8; $m++) {
if ($boardData[$n][$m] -eq $tempBoard[$n][$m]) {
}else{
$diff_num++
}
}
}
return $diff_num
}
#盤上のデータをコピーする機能（引数：盤上のデータ、戻し値：コピーした盤上のデータ（配列は参照型なので、別の2次元配列を準備して戻す））
static [String[][]]copyBoard($boardData) {
$tempBoard=@(
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿'),
@('＿','＿','＿','＿','＿','＿','＿','＿','＿','＿')
)
for ($n=1; $n -le 8; $n++) {
for ($m=1; $m -le 8; $m++) {
$tempBoard[$n][$m] = $boardData[$n][$m]
}
}
return $tempBoard
}
#盤上のデータから石をおくことができる場所に石を置いた際の盤上のデータのリストを返す（引数：盤上のデータ、戻し値：裏返された盤上のデータのリスト）
static [System.Collections.ArrayList]reversedBoardList($boardData, $color) {
$boardList = [System.Collections.ArrayList]::new()
$tempClass = [Player]::new($color, 0)
for ($n=1; $n -le 8; $n++) {
for ($m=1; $m -le 8; $m++) {
if ($boardData[$n][$m] -ne '＿') {
} else {
$position = [String]$n + [String]$m
$tempBoard = [Utility]::copyBoard($boardData)
$tempClass.reverseStones($position, $tempBoard)
$canBeReversed = [Utility]::compareBoard($tempBoard, $boardData)
if($canBeReversed) {
} else {
$boardList.Add($tempBoard)
}
}
}
}
return $boardList
}
}