【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(12) GNUの碁1.2 をC#化して9路盤を追加したのでソースを配布するぜ☆www

2015-11-30 12:17

201511301218

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「GNUの碁1.2 をC#化して、9路盤を追加したんで、

ソースを公開するぜ☆」

 

↓囲碁とか書いてあるところに置いたぜ☆

ぐれーすけーる 『きふわらべ』

http://grayscale.iza-yoi.net/shogi/index.html

 


2015-11-30 12:24

KIFUWARABE_80x100x8

「次は GNUの碁2.8 の endgame.c を読もうぜ☆!」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「それが、ソースコードの構成が全然変わっちゃっているんだぜ☆

endgame.c は無いぜ☆」

KIFUWARABE_80x100x8

「それは困ったななんだぜ……☆」

UEUESHIMA_Komado_80x80x8_07_piririUmauma

「どうするんだぜ☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「GNUの碁2.8の全てのソースを読むしかないだろう☆」

KIFUWARABE_80x100x8

「まじか……☆」


 

 

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(12) GNUの碁1.2 をC#化して9路盤を追加したのでソースを配布するぜ☆www
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket

【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(11) GNUの碁1.2 でのハンディーキャップを一覧しようぜ☆ww

2015-11-30

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「9路盤の ハンディーキャップの石の置き方を調べたかっただけなんだが、

ググっても見つからなかったので

GNUの碁1.2の19路盤でのハンディーキャップの石の置き方を調べて、

その類推で勝手に 9路盤のハンディーキャップの石を置くことにするぜ☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「どうせ勝手な類推なのだったら、もう適当に置いちゃったらどうだぜ☆?

パパーっと☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「お前は神か☆! そこは もうちょっと それっぽさを出したいんだぜ☆」


07:36

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが1つの場合だぜ☆」

201511300735

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが2つの場合だぜ☆」

201511300738

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが3つの場合だぜ☆」

201511300739

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが4つの場合だぜ☆」

201511300758

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが5つの場合だぜ☆」

201511300800

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが6つの場合だぜ☆」

201511300801

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが7つの場合だぜ☆」

201511300802

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが8つの場合だぜ☆」

201511300803

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが9つの場合だぜ☆」

201511300804

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが10個の場合だぜ☆」

201511300805

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが11個の場合だぜ☆」

201511300806

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが12個の場合だぜ☆」

201511300807

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが13個の場合だぜ☆」

201511300808

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが14個の場合だぜ☆」

201511300809

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが15個の場合だぜ☆」

201511300810

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが16個の場合だぜ☆」

201511300811

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが17個の場合だぜ☆」

201511300812

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これで全部だぜ☆」

UEUESHIMA_Komado_80x80x8_03_jitoo

「左上、右下、右上、左上、

5は真ん中で 6はサイコロ、 7はH☆

8が四角で、9が碁盤、

10~13 が 外周をくり返し、

14~17 が 内周をくり返し、かだぜ☆ 覚えたぜ☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「5~9のあたりで フェイントがあるだけで、

あとは 追加、追加 みたいだな☆

9路盤でも なるべく真似して作ってみるぜ☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「おっおっ☆! 盤面が埋まってしまうんじゃないかだぜ~☆!www」


09:01

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「それでは、わたしの考えた最強の 9路盤のハンディーキャップを紹介するぜ☆」

\ 88888888888888888888888888888888888☆ /

UEUESHIMA_Komado_80x80x8_02_nitaari

「わー☆!」

\ 888888888888888888888888888888888888888888☆ /

KIFUWARABE_80x100x8

「わーわー☆!」

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが1個の場合だぜ☆」

201511300900

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが2個の場合だぜ☆」

201511300903

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが3個の場合だぜ☆」

201511300904

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが4個の場合だぜ☆」

201511300906

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが5個の場合だぜ☆」

201511300907

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが6個の場合だぜ☆」

201511300908

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが7個の場合だぜ☆」

201511300909

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが8個の場合だぜ☆」

201511300910

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが9個の場合だぜ☆」

201511300911

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが10個の場合だぜ☆」

201511300912

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが11個の場合だぜ☆」

201511300913

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが12個の場合だぜ☆」

201511300914

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが13個の場合だぜ☆」

201511300915

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが14個の場合だぜ☆」

201511300916

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが15個の場合だぜ☆」

201511300918

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが16個の場合だぜ☆」

201511300919

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハンディーキャップが17個の場合だぜ☆」

201511300920

 

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これで全部だぜ☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「wwwwwwwwwwwwwwwwwwwwwwwwww☆

9路盤の ハンディーキャップ17 は、もう勝負が付いているんじゃないのかなんだぜ☆wwwwwwwwwwwwwwwwww☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ん……☆? そうなのかなんだぜ☆?」

KIFUWARABE_80x100x8

「続きを作って、コンピューターに整地させようぜ☆!」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「そこらへんの囲碁のルールも よく分からないところだぜ☆

ソースコードを真似て 作るぐらいは できるけど☆」


09:29

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「序盤の定石の 四隅の場所とか、19路盤のままだぜ☆

ここらへんを 9路盤でもいけるように 縮めるぜ☆ なんとかできるかどうかだぜ☆」


09:39

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「おっ☆ 定石をオフにしたり、四隅のあたりを直したら

コンピューターくんが 9路盤でも 動くようになったぜ☆?」

201511300939

UEUESHIMA_Komado_80x80x8_02_nitaari

「おっ☆!」

KIFUWARABE_80x100x8

「やったな☆!」


09:55

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ちなみに、9路盤のセーブデータは こんな感じの内容になるぜ☆」

0000000000200000201220202002002020000020202001002020100120202002211000200222100001 0 0 0 0 0 0 0 0 0 0 0

UEUESHIMA_Komado_80x80x8_02_nitaari

「おっ☆ 短くなったな☆!」


10:01

201511301001

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「おっ☆! コンピューターがパスをしてきたぜ☆!」

UEUESHIMA_Komado_80x80x8_02_nitaari

「9路盤のハンディーキャップ17とはいえ、勝てそうだな☆!」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「よーし、勝っちゃうぜ☆!?」


10:04

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「この囲碁の最後らへんのやり取りが わからないんだぜ☆?」

201511301003

UEUESHIMA_Komado_80x80x8_07_piririUmauma

「GNUの碁3.8 では エンドゲーム は、どうなってるんだぜ☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「結果発表まで オートでやってほしいんだぜ☆」


10:07

201511301007

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「こんな結果になったんだが、合っているのかなんだぜ☆?」

UEUESHIMA_Komado_80x80x8_02_nitaari

「わからないぜ☆www」

KIFUWARABE_80x100x8

「もう1回遊んでみて、無事に動きそうなら ソースを公開しようぜ☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「その前に 朝食にしようぜ☆?」

UEUESHIMA_Komado_80x80x8_02_nitaari

「おう☆!ww」

KIFUWARABE_80x100x8

「よっしゃ☆!」


9路盤のハンディーキャップは ばっちり 追加したぜ☆!

第9回UEC杯コンピュータ囲碁大会と直接関係のない改造だが、微速微進、遅々前進なんだぜ☆!

 

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(11) GNUの碁1.2 でのハンディーキャップを一覧しようぜ☆ww
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket

【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(10) まず、9路盤を作ろうぜ☆www

2015-11-29 23:38

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「大会は 19路盤 なんだが、その前に 9路盤 を作ろうぜ☆」

KIFUWARABE_80x100x8

「おう☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「GNUの碁 2.6 や、 3.8 のソースも見てみたんだが、

環境周りが まったく別物というぐらい 進化してるので

今回は GNUの碁 1.2 ベースの囲碁ソフトを開発していくぜ☆」

KIFUWARABE_80x100x8

「まあ、Cカテゴリーだしな☆」

 

Cカテゴリーは、予選のみ参加。

第9回UEC杯コンピュータ囲碁大会 『参加要件』

http://jsb.cs.uec.ac.jp/~igo/sankayouken.html

 


23:44

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「GNUの碁 1.2 のソースを読んだ感想としては、

定石が 19路盤 を想定したものになっていることと、

指し手の評価値を出すときに 端っこ、真ん中、の距離感の

報酬とペナルティーを付けるのに、 19路盤の広さで 付けているという

ところがあったと 記憶しているぜ☆」

KIFUWARABE_80x100x8

「あとは 画面表示と、指し手入力が 19路盤を前提としたものになっているぜ☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「ちゃちゃーっと 9路盤にしようぜ☆wwww」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「オブジェクト・シコー・パワー を使って

19ジバン・モード と、9ジバン・モード の2つに大きく分けて選択できるように

した方がいいのか、

それとも 19路盤と 9路盤は別ゲームとして、

別個に作った方がいいのか☆」

KIFUWARABE_80x100x8

「盤のでかさが変わるだけで 別アプリケーションにするぐらい違うのか☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「うーむ☆ 同じアプリで盤のでかさが変えられる方が フツー だよな☆

ジバン・モードチェンジを作っていくかなんだぜ☆」


23:54

201511292353

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「古いほうは残しつつ、9路盤、19路盤併用モードの開発を続けるぜ☆」

KIFUWARABE_80x100x8

「おう☆」


2015-11-30 00:57

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「まずは、 9 か 19 を選べるように、入力を作っておいたぜ☆」

201511300057

UEUESHIMA_Komado_80x80x8_09_Nikoniko

「次は 盤表示 なのかだぜ☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「うむ、まずは 目に見えるところから 手を付けて 気分をアゲアゲ↑↑しようぜ☆」


01:31

201511300131

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「とりあえず クラスをコピーして2つにしたんで、

9路盤の方を ちょくちょく変えていくことにしようぜ☆」

KIFUWARABE_80x100x8

「おう☆!」



 

2015-11-30 03:44

201511300344

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「おっおっ☆! かわいらしい 9路盤 がでけたんだぜ☆!」

UEUESHIMA_Komado_80x80x8_09_Nikoniko

「おっ☆! 十分なできだぜ☆」

KIFUWARABE_80x100x8

「やったな☆!」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「あとは 人間と、コンピューターが、9路盤の中に石を置いてくれれば完成だぜ☆

今は 19路盤のプログラムだし、

ハンディキャップも 19路盤のままだぜ☆」

UEUESHIMA_Komado_80x80x8_09_Nikoniko

「こつこつ変えていこうぜ☆!ww」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「よしよし☆ 続きはまた今度だぜ☆」

KIFUWARABE_80x100x8

「おう☆!」

UEUESHIMA_Komado_80x80x8_02_nitaari

「おーう☆!」


 

9路盤の見た目を 用意 したぜ☆! 順調 だな☆!

ひとまず 9路盤の方へ寄り道しながら、

第9回UEC杯コンピュータ囲碁大会へ向けて、微速微進、遅々前進なんだぜ☆!


 


 

05:49

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「セーブデータなんだが、19路盤か、9路盤か、先にわかってないと読み込めないぜ☆?」

00000000000000000000000000000000000000000000000000010000000020000010000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000020000000000002000000000000000000000000000000000000000000000001 0 0 0 0 0 0 0 0 0 0 0

KIFUWARABE_80x100x8

「セーブファイルの仕様を独自拡張するというより、

19路盤と、9路盤で、セーブファイル名を分けて

9路盤用のセーブファイルを新しく作ってしまおうぜ☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「天才か☆!」

UEUESHIMA_Komado_80x80x8_02_nitaari

「gnugo.dat ファイルがあれば 19路盤のゲームを再開して、

gnugo_9ziban.dat ファイルがあれば 9路盤のゲームを再開すればどうだぜ☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ありだな☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「すると、セーブ機能と、ロード機能も

9ジバン・モード、19ジバン・モードに分けたいところだぜ……☆」


05:56

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「はっ☆! 今日は月曜日☆! 生ゴミの日では!?」

KIFUWARABE_80x100x8

「現在住んでいるこの場所では、今日は 100% の確率で 生ゴミの日だぜ☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「100%か……☆!」


06:46

201511300646

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「やっぱり セーブと ロードのアルゴリズムは同じにして、

数字だけ変えることにしたぜ☆

19路盤と 9路盤で、保存する 定石とか変わってくると思うんだが、困ったらそのとき

また対応するぜ☆」

KIFUWARABE_80x100x8

「おう☆」

UEUESHIMA_Komado_80x80x8_09_Nikoniko

「拡張しなくて済むものは ギリギリまで拡張しないのも手だよな☆」


07:14

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「9路盤のハンディーキャップどうしよ☆

19路盤だと 0~17 で選べるんだが、すぐ盤外だぜ☆」

KIFUWARABE_80x100x8

「ググろうぜ☆?」


07:23

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ググっても、これといった特集が見つからないぜ☆

19路盤で どうなっていたか、調べるか…☆

じゃあ、次の記事へ移るぜ☆」

KIFUWARABE_80x100x8

「おう☆!」


 

 

 

 

 

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(10) まず、9路盤を作ろうぜ☆www
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket

【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(9) GNUの碁 1.2 をC#化したんで配るぜ☆wwww

2015-11-29 10:54

201511291048

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「GNUの碁 1.2 を C#化したんで配るぜ☆ GPLライセンスだからいいだろ☆

↓ 囲碁 と書いてあるところに .zip を置いておいたぜ☆」

 

ぐれーすけーる 『きふわらべのページ』

http://grayscale.iza-yoi.net/shogi/index.html

 

UEUESHIMA_Komado_80x80x8_07_piririUmauma

「ごちゃごちゃしたページなんだぜ……☆」


10:58

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「んじゃ、お父んは バイトの方やるんで☆ 今日はここまでだぜ☆」

KIFUWARABE_80x100x8

「おう☆」


 

GNUの碁 1.2 のC#化は 大成功 なんだぜ☆!

第9回UEC杯コンピュータ囲碁大会に向けて、微速微進、遅々前進なんだぜ☆!

 

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(9) GNUの碁 1.2 をC#化したんで配るぜ☆wwww
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket

【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(8) 行列演算 in 碁☆wwwwwww

2015-11-29 03:03

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「すごい掛け算のことを、行列演算という☆」

KIFUWARABE_80x100x8

「深い理解だぜ☆」

UEUESHIMA_Komado_80x80x8_09_Nikoniko

「wwwwwwwwwwwwwwwwwwww☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「囲碁の定石を調べるときに、盤面を 左右反転したり、90度回転したり、

左右反転と90度回転を組み合わせたりするんだが、

これをするときに 行列演算を使う☆ マスターしておくぜ☆」


03:07

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「こんなところで わたしの画力が 試されることになるとは……☆」

┏          ┓

┃  1    0  ┃

┃  0    1  ┃

┗          ┛

201511290308

http://gakusyu.jp/visualization/visualization.php?mapping=linear

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「左の絵が、右の絵に 変換(トランスフォーム) されたんだぜ☆

これを、そのまんま という☆」


03:15

┏          ┓

┃  1    0  ┃

┃  0   -1  ┃

┗          ┛

 

201511290315

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これを上下反転(invert)という☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「変形を確認するテストで、

シンメトリー(左右対称)な絵を描くのはやめてくれないか☆!wwww」


03:20

┏          ┓

┃  0   -1  ┃

┃  1    0  ┃

┗          ┛

201511290320

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これを反時計回り90度回転(rotate 90)という☆」

KIFUWARABE_80x100x8

「象さんだぜー☆!」


03:25

┏          ┓

┃  0   -1  ┃

┃ -1    0  ┃

┗          ┛

201511290325

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これを反時計回りに90度回転して上下反転(rotate 90 and invert)という☆

2ステップを1つ1つやれば この結果になるな☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「なんだぜ☆? このパーマンバッジみたいなものは☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「鳩だぜ☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「近所の公園に こんな動物がいるのかだぜ☆wwww

そりゃあ見物だぜ☆! 見にいってくるぜ☆wwww」


03:34

┏          ┓

┃ -1    0  ┃

┃  0   -1  ┃

┗          ┛

201511290332

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これを左右反転(flip left)という☆」

KIFUWARABE_80x100x8

「お猿さんだぜー☆!」


 

┏          ┓

┃ -1    0  ┃

┃  0   -1  ┃

┗          ┛

201511290337

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これを、左右反転して上下反転(flip left and invert)という☆」

KIFUWARABE_80x100x8

「なんだ、亀かだぜ☆」


03:42

┏          ┓

┃  0    1  ┃

┃  1    0  ┃

┗          ┛

201511290341

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これを反時計回りに90度回転して左右反転(rotate 90 and flip left)という☆」

KIFUWARABE_80x100x8

「うさぎだぜー☆!」


03:46

UEUESHIMA_Komado_80x80x8_07_piririUmauma

「まさか あんな鳩がいるとは……、おっ☆

面白動物大会は まだやってたのかだぜ☆!」

┏          ┓

┃  0    1  ┃

┃ -1    0  ┃

┗          ┛

201511290345

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これを反時計回りに90度回転して左右反転して上下反転(rotate 90, flip left and invert)という☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「時計回りに90度回転でいいんじゃないのか☆wwwww

なんだぜ、その長い名前☆wwwwww!」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「全パターン組み合わせたことが分かるようにしたわけだぜ☆」

KIFUWARABE_80x100x8

「反時計回りで90度回転、上下反転、左右反転があれば

囲碁の盤上の定石チェックもできそうだな☆!」


04:04

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「変換を8つ紹介したんだが、

上4つだけで十分、という定石もあるみたいだぜ☆

もともと左右反転な定石なので、それを左右反転しても意味ないだろ、

ということみたいだな☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「しっちゃか めっちゃか に見えた紹介順序に意味があったのか☆wwww

なるほど、後ろ4つは、前半4つを 左右反転したパターンかだぜ☆wwww」


04:28

201511290427

X … わたし(きふわらべのお父ん)

O … GNUの碁1.2

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「 O を囲ってやろうと、 X を横付けしたんだが、

3つの囲いのところに首を突っ込めば すぐ4つ が完成して

取られてしまうし、

逆に ごっさんの方が有利になってしまったぜ☆」

KIFUWARABE_80x100x8

「相手の石が1つあるところに、

自分の石を隣に付けると、次は相手の手番だろ☆

置いてあった石に、もう1枚 石がプラスされるんだぜ☆

常に相手の方が 1枚 多くなってしまわないか☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「むむむ☆!」


04:59

201511290459

KITASHIRAKAWA_Chiyuri_80x100x8_02_Hidosu

「インデントがわからないぜ……☆!」

UEUESHIMA_Komado_80x80x8_02_nitaari

「if と else の対応もわからないぜ☆www」


05:03

201511290503

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「多分、こうなってるんだぜ☆」

KIFUWARABE_80x100x8

「tab が 8 だと思うというツイートが届いているぜ☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「tab は消し飛ばして ハンカクスペース  にするぜ☆

tab のない世界は平和だぜ☆」

 


05:23

201511290522

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「これから ダンジョンに入っていく勇者って、こんな感じだよな☆」

KIFUWARABE_80x100x8

「多勢に無勢だぜ☆」


行列演算も ばっちり だな☆!

第9回UEC杯コンピュータ囲碁大会に向けて、微速微進、遅々前進なんだぜ☆!

 

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(8) 行列演算 in 碁☆wwwwwww
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket

【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(7) 上端が北で i=0、下端が南で i=18、でも画面表示は上端が19、下端が1☆

2015-11-28 21:56

KIFUWARABE_80x100x8

「上端が北で i=0、下端が南で i=18、でも画面表示は上端が19、下端が1☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「そんなん、わかるか☆!」

201511282152

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「石の4方向を囲むと、囲まれた石は消えることを 発見 した☆!」

KIFUWARABE_80x100x8

「お父んが発見する前から そうだったと思われ☆」

emptyemptyempty

emptywhiteempty

emptyemptyempty

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「↑こういうのがあるとき☆」

emptyplace1empty

place4whiteplace2

emptyplace3empty

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「4方向に石を置いていくぜ☆? まずは1つ☆」

emptyblackempty

place4whiteplace2

emptyplace3empty

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「次は2つ目だぜ☆」

emptyblackempty

place4whiteblack

emptyplace3empty

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「次は3つ目だぜ☆」

emptyblackempty

place4whiteblack

emptyblackempty

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「次は4つ目だぜ☆」

emptyblackempty

blackemptyblack

emptyblackempty

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ほら消えた☆」

KIFUWARABE_80x100x8

「囲碁マスターか☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「囲碁マスターだぜ☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「でも、おかしくね☆?」

UEUESHIMA_Komado_80x80x8_02_nitaari

「何もおかしくないぜ☆wwwwwwwww」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「石1個 消し飛ばすのに 4つもかかってたら、

4倍の労力だろ☆」

KIFUWARABE_80x100x8

「GNUの碁1.2の ごっさんは、 ぱらぱらと

何にも無いところに石を置いていっているみたいだぜ☆?

それも、盤の角とか 辺の端っことか、真ん中ではなく、

ドーナツの輪のように☆

お父んみたいに 石の周りを囲みに行くことはしないぜ☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「べっさんも そう置け☆」

KIFUWARABE_80x100x8

「ソース解析は、まだだぜ☆」


22:47

KITASHIRAKAWA_Chiyuri_80x100x8_03_Ahee

「ほうあっ☆! コンピューターめ☆! 1つ置きに石を置いているじゃないか☆!」

201511282246

X … わたし(きふわらべのお父ん)

O … GNUの碁1.2

KIFUWARABE_80x100x8

「どういう戦術なのか……☆」

UEUESHIMA_Komado_80x80x8_02_nitaari

「1つ飛ばしで 小さな輪っかを作ってるんじゃないか☆ww?」



 

2015-11-29 02:06

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「確かに、小さな輪っかを作っているみたいなんだぜー☆?」

201511290206

KIFUWARABE_80x100x8

「それに比べて お父んは 大腸 みたいだぜ☆」

KITASHIRAKAWA_Chiyuri_80x100x8_03_Ahee

「大腸……☆!」

UEUESHIMA_Komado_80x80x8_02_nitaari

「大腸と ポンデリングの戦いかなんだぜ☆?ww」


02:59

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ソースを読んでいたら、行列計算が出てきたので、ブログの次記事に移るぜ☆」

KIFUWARABE_80x100x8

「おう☆!」

UEUESHIMA_Komado_80x80x8_09_Nikoniko

「おーう☆!」


 

GNUの碁1.2 のソースの理解は 順調 だぜ☆!

コウ ぐらいは分かってきたぜ☆ww

第9回UEC杯コンピュータ囲碁大会に向けて、微速微進、遅々前進だぜ☆!

 

 

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(7) 上端が北で i=0、下端が南で i=18、でも画面表示は上端が19、下端が1☆
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket

【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(6) わからないことがいっぱいだぜ☆ww

2015-11-28 06:14

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「おっはー☆ Gnugo1.2 のソースコード読むぜ☆」

\ ズーーーピーーー☆ /

UEUESHIMA_Komado_80x80x8_07_piririUmauma

「Zzz……☆」


06:52

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「わたしは 囲碁ゲームのボキャブラリーがないので

いろいろ プログラムの説明文章が書きにくいぜ☆」


07:15

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「Console.ReadLine() を1個挟むだけで、

一瞬で消えていた 整地が 見えるようになったぜ☆」

201511280714

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「まあ、全駒されたわけだが……☆」


09:57

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「GNUの碁1.2 の、bfslist関数の第4引数の list配列、

使ってない気がするんだぜ☆」

int  bfslist(int i,
             int j,
             int movelist[][5],
             int list[])
/* Using the adjacency list, movelist, for pieces of one color
   find all connected points.  
   Starting point is defined by i and j.  Output is
   the number of points found and an array of their 
   locations.
*/
{ 
  int k,u,v;
  int w=0;

  for (k=0;k<(BSIZE*BSIZE);k++) color[k]=WHITE; /* initialization */
  color[node(i,j)] = GREY;
  u=node(i,j);
  enqueue(&u);
#ifdef DEBUG 
printf("Survived first enqueue in bfslist.\n");
#endif
  while (size != 0) {
    k = 0;
    u=*pstart;
    while ((v = movelist[u][k]) != ENDLIST) {    
      if (color[v] == WHITE) {
        color[v] = GREY;
        enqueue(&v);
      }
      k++;
    }
#ifdef DEBUG 
printf("Just prior to first dequeue!.\n");
#endif
    dequeue();
    color[u]=BLACK;
    *(listpt + w) = u;
    w++;
  }
return w;
}

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「うーむ……☆?」


10:33

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「英語の Adjacency と Neighbor の違いがわからないぜ☆

隣じゃないのかなんだぜ☆??」


 

 

 

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(6) わからないことがいっぱいだぜ☆ww
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket

【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(5) デッド・ピースって何だぜ☆ww

2015-11-27 08:17

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「朝っぱらから 移植ミスを修正して いじっていたんだが、だいぶ動くようになったぜ☆

デッド・ピースを選べ☆? と促されたので、

分からないので 適当に相手の駒を 指したら……、」

201511270819

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「なんか 石いっぱい取ったことになったのかなんだぜ☆?」

UEUESHIMA_Komado_80x80x8_07_piririUmauma

「囲碁の結果発表はオートでやってくれよう☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「今日は 飯くったらバイトだぜ☆」



 

11:43

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「2時間ばかり バイトが順調だったので こっちに戻ってきたぜ☆」

UEUESHIMA_Komado_80x80x8_03_jitoo

「順調のまま バイト してればいいのに……☆」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ソースコードを読むぜ☆」


14:31

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「休憩☆!」


 

 

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(5) デッド・ピースって何だぜ☆ww
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket

【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(4) どんどん、ソースコードを読んでいくんだぜ☆!

2015-11-26 02:35

UEUESHIMA_Komado_80x80x8_03_jitoo

「バイトは☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「バイトは明け方だぜ☆!」


02:52

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「GNUの碁1.2 の、メイン・プログラムだぜ☆

やっぱりCUIだな☆」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// GNUの碁のメイン・プログラム
//

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "gnugo.h"

unsigned char p[19][19];    // 碁盤
unsigned char l[19][19];    // カレント色のリバーティー
unsigned char ma[19][19];   // マーキング用の作業用行列
unsigned char ml[19][19];   // マーキング用の作業用行列
int mymove, umove;          // コンピューターの色、相手の色
int lib;                    // カレント石のリバーティー
int play;                   // ゲームの状態
int pass;                   // パスを示します
int mik, mjk;               // コンピューターが取った石の位置
int uik, ujk;               // 相手が取った石の位置
int mk, uk;                 // コンピューターか相手によって取った石たちの番号
int opn[9];                 // 序盤定跡のフラグ

int main    (
                int argc,
                char *argv[]
            )
{
    FILE *fp;
    int i,  // 行
        j   // 列
        ;
    char
        move[10],
        ans[5]
        ;
    int cont = 0;
    time_t tm;

    // 説明を表示します。
    showinst();

    if
    (
        (fp = fopen("gnugo.dat", "r")) != NULL  // 古いゲームを続けます。
    )
    {
        cont = 1;

        // 盤設定を読み込みます。
        for (i = 0; i < 19; i++)
        {
            for (j = 0; j < 19; j++)
            {
                fscanf(fp, "%c", &p[i][j]);
            }
        }

        // コンピューターの色、取ったピースズを読み込みます。
        fscanf(fp, "%d %d %d ", &mymove, &mk, &uk);

        // 序盤定跡フラグを読み込みます。
        for (i = 0; i < 9; i++)
        {
            fscanf(fp, "%d ", &opn[i]);
        }

        fclose(fp);
        umove = 3 - mymove;

        // ファイルを削除します。
        remove("gnugo.dat");
    }
    else
    {
        // 序盤定跡のサーチ番号たちを初期化します。
        for (i = 0; i < 9; i++)
        {
            opn[i] = 1;
        }
        opn[4] = 0;

        // 盤の初期化
        for (i = 0; i < 19; i++)
        {
            for (j = 0; j < 19; j++)
            {
                p[i][j] = EMPTY;
            }
        }

        // グローバル変数の初期化
        mk = 0;
        uk = 0;
    }

    // グローバル変数の初期化
    play = 1;
    pass = 0;
    mik = -1; mjk = -1;
    uik = -1; ujk = -1;
    srand((unsigned)time(&tm)); // ランダム値の種を設定

    if (!cont)  // 新ゲーム
    {
        // ハンディーキャップを尋ねます。
        printf("Number of handicap for black (0 to 17)? ");
        scanf("%d", &i);
        getchar();
        sethand(i);

        // ゲーム盤を表示します。
        showboard();

        // 色を選びます。
        printf("\nChoose side(b or w)? ");
        scanf("%c",ans);
        if (ans[0] == 'b')
        {
            mymove = 1; // コンピューターが白
            umove = 2;  // 人間が黒
            if (i)
            {
                genmove(&i, &j);    // コンピューターが指します。
                p[i][j] = mymove;
            }
        }
        else
        {
            mymove = 2; // コンピューターが黒
            umove = 1;  // コンピューターが白
            if (i == 0)
            {
                genmove(&i, &j);    // コンピューターの指し手
                p[i][j] = mymove;
            }
        }
    }

    showboard();

    // メインループ
    while (play > 0)
    {
        printf("your move? ");
        scanf("%s", move);
        getmove(move, &i, &j);  // 人間の指し手を読込
        if (play > 0)
        {
            if (i >= 0) // パスでないなら
            {
                p[i][j] = umove;
                examboard(mymove);  // コンピューターの死ピースズを削除します。
            }
            
            if (pass != 2)
            {
                genmove(&i, &j);    // コンピューターの指し手
                if (i >= 0) // パスでなければ
                {
                    p[i][j] = mymove;
                    examboard(umove);   // あなたの死ピースズを削除します。
                }
            }
            showboard();
        }
        
        if (pass == 2)
        {
            play = 0;   // お互いがパスをしたら、ゲーム終了です。
        }
    }

    if (play == 0)
    {
        // ゲームを終了し、ピースズを数えます。
        getchar();
        printf("Do you want to count score (y or n)? ");
        scanf("%c",ans);
        if (ans[0] == 'y')
        {
            endgame();
        }
    }

    return 0;
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「ほうほう☆!」


03:22

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「matchpat.c は、盤面をくるくる回したり、反転させたりして

同じ形かどうかを 判定しているんじゃないかなんだぜ☆?」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// matchpat.c -- マッチパターンの動き。
//
/*-----------------------------------
  
-----------------------------------*/

#include "gnugo.h"
#include "patterns.h"

#define abs(x) ((x) < 0 ? -(x) : (x))
#define line(x) (abs(x - 9))

extern unsigned char p[19][19]; // 碁盤
extern int mymove, umove;       // コンピューターの色、相手の色
extern int lib;                 // カレント石のリバーティー

// マッチ・パターンと、次の手の取得
int matchpat(
                int m,      // 原点の   行
                int n,      // 〃       列
                int *i,     // 次の手の 行番号
                int *j,     // 〃       列番号
                int *val    // 〃       評価値
            )
{
    // 行列操作のための行列たち
    static int trf [8][2][2] =
    {
        {{ 1,  0}, { 0,  1}},   // 線型変換                     (linear transfomation matrix)
        {{ 1,  0}, { 0, -1}},   // 反転                         (invert)
        {{ 0,  1}, {-1,  0}},   // 90度回転                     (rotate 90)
        {{ 0, -1}, {-1,  0}},   // 90度回転して反転             (rotate 90 and invert)
        {{-1,  0}, { 0,  1}},   // 左へ返す                     (flip left)
        {{-1,  0}, { 0, -1}},   // 左へ返して反転               (flip left and invert)
        {{ 0,  1}, { 1,  0}},   // 90度回転して左へ返す         (rotate 90 and flip left)
        {{ 0, -1}, { 1,  0}}    // 90度回転して左へ返して反転   (rotate 90, flip left and invert)
    };
    int k, my, nx, ll, r, cont;
    int ti, tj, tval;

    *i = -1;
    *j = -1;
    *val = -1;

    for (r = 0; r < PATNO; r++) // それぞれのパターンを試します。
    {
        for (ll = 0; ll < pat[r].trfno; ll++)/* try each orientation transformation */
        {
            k = 0;  cont = 1;
            while ((k != pat[r].patlen) && cont)/* match each point */
            {
                /* transform pattern real coordinate */
                nx = n + trf[ll][0][0] * pat[r].patn[k].x
                        + trf[ll][0][1] * pat[r].patn[k].y;
                my = m + trf[ll][1][0] * pat[r].patn[k].x
                        + trf[ll][1][1] * pat[r].patn[k].y;

                /* outside the board */
                if ((my < 0) || ( my > 18) || (nx < 0) || (nx > 18))
                {
                    cont = 0;
                    break;
                }
                
                switch (pat[r].patn[k].att)
                {
                    case 0 :
                        if (p[my][nx] == EMPTY)    /* open */
                            break;
                        else
                        {
                            cont = 0;
                            break;
                        }
                    case 1 :
                        if (p[my][nx] == umove)  /* your piece */
                            break;
                        else
                        {
                            cont = 0;
                            break;
                        }
                    case 2 :
                        if (p[my][nx] == mymove)  /* my piece */
                            break;
                        else
                        {
                            cont = 0;
                            break;
                        }
                    case 3 :
                        if (p[my][nx] == EMPTY)    /* open for new move */
                        {
                            lib = 0;
                            countlib(my, nx, mymove);    /* check liberty */
                            if (lib > 1)  /* move o.k. */
                            {
                                ti = my;
                                tj = nx;
                                break;
                            }
                            else
                            {
                                cont = 0;
                                break;
                            }
                        }
                        else
                        {
                            cont = 0;
                            break;
                        }
                    case 4 :
                        if (
                                (p[my][nx] == EMPTY)  /* open on edge */
                            && (
                                (my == 0) || (my == 18) || (nx == 0) || (nx == 18)
                               )
                           )
                            break;
                        else
                        {
                            cont = 0;
                            break;
                        }
                    case 5 :
                        if (
                            (p[my][nx] == umove)  /* your piece on edge */
                            && (
                                (my == 0) || (my == 18) || (nx == 0) || (nx == 18)
                               )
                           )
                            break;
                        else
                        {
                            cont = 0;
                            break;
                        }
                    case 6 :
                        if (
                                (p[my][nx] == mymove)  /* my piece on edge */
                            &&  (
                                (my == 0) || (my == 18) || (nx == 0) || (nx == 18)
                                )
                           )
                            break;
                        else
                        {
                            cont = 0;
                            break;
                        }
                }
                ++k;
            }
            
            if (cont)   /* match pattern */
            {
                tval = pat[r].patwt;
                if (
                    (r >= 8) && (r <= 13)    /* patterns for expand region */
                   )
                {
                    if (line(ti) > 7)  /* penalty on line 1, 2 */
                        tval--;
                    else
                        if ((line(ti) == 6) || (line(ti) == 7))
                            tval++;    /* reward on line 3, 4 */

                        if (line(tj) > 7)  /* penalty on line 1, 2 */
                            tval--;
                        else
                            if ((line(tj) == 6) || (line(tj) == 7))
                                tval++;    /* reward on line 3, 4 */
                }
                
                if (tval > *val)
                {
                    *val = tval;
                    *i = ti;
                    *j = tj;
                }
            }
        }//for
    }

    if (*val > 0)   // パターンにマッチしました。
    {
        return 1;
    }
    else    // マッチに失敗しました。
    {
        return 0;
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「なるほど☆!」


03:33

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「opening.c は、序盤の定跡じゃないかなんだぜ☆?」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// opening.c -- 序盤定跡を選択します。
//

#include <stdlib.h>
#include "gnugo.h"

///
/// ゲームツリーから序盤のための動きを取得します。
///
int opening(
            int *i,
            int *j,
            int *cnd,
            int type
           )
{
    struct tnode
    {
        int i, j, ndct, next[8];
    };

    static struct tnode tree[] =
    {
        {-1,-1, 8, { 1, 2, 3, 4, 5, 6, 7, 20}},  /* 0 */
        { 2, 3, 2, { 8, 9}                   },
        { 2, 4, 1, {10}                      },
        { 3, 2, 2, {11, 12}                  },
        { 3, 3, 6, {14, 15, 16, 17, 18, 19}  },
        { 3, 4, 1, {10}                      },  /* 5 */
        { 4, 2, 1, {13}                      },
        { 4, 3, 1, {13}                      },
        { 4, 2, 0                            },
        { 4, 3, 0                            },
        { 3, 2, 0                            },  /* 10 */
        { 2, 4, 0                            },
        { 3, 4, 0                            },
        { 2, 3, 0                            },
        { 2, 5, 1, {10}                      },
        { 2, 6, 1, {10}                      },  /* 15 */
        { 3, 5, 1, {10}                      },
        { 5, 2, 1, {13}                      },
        { 5, 3, 1, {13}                      },
        { 6, 2, 1, {13}                      },
        { 2, 2, 0                            }  /* 20 */
    };

    int m;

    /* get i, j */
    if ((type == 1) || (type == 3))
    {
        *i = 18 - tree[*cnd].i;   /* inverted */
    }
    else
    {
        *i = tree[*cnd].i;
    }

    if ((type == 2) || (type == 3))
    {
        *j = 18 - tree[*cnd].j;   /* reflected */
    }
    else
    {
        *j = tree[*cnd].j;
    }

    if (tree[*cnd].ndct)  /* more move */
    {
        m = rand() % tree[*cnd].ndct;   /* select move */
        *cnd = tree[*cnd].next[m];      /* new current node */
        return 1;
    }
    else
    {
        return 0;
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「ほうほう☆!」


03:43

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「openregn.c は、四角形の領域が開いているかどうかを調べているのかだぜ☆?? よくわからないぜ☆」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// openregn.c -- もし四角形の領域がオープンなら調べます。
//

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤

///
/// もし四角形 (i1,j1)~(i2,j2)がオープンなら、調べます。
///
int openregion(
                int i1,
                int j1,
                int i2,
                int j2
              )
{
    int minx, maxx, miny, maxy, x, y;

    // 上下の限界を差替えます。
    if (i1 < i2)
    {
        miny = i1;
        maxy = i2;
    }
    else
    {
        miny = i2;
        maxy = i1;
    }

    if (j1 < j2)
    {
        minx = j1;
        maxx = j2;
    }
    else
    {
        minx = j2;
        maxx = j1;
    }

    // 空っぽ領域を調べます。
    for (y = miny; y <= maxy; y++)
    {
        for (x = minx; x <= maxx; x++)
        {
            if (p[y][x] != EMPTY)
            {
                return 0;
            }
        }
    }

    return 1;
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「ほうほうほう☆!」


4:09

KITASHIRAKAWA_Chiyuri_80x100x8_02_Hidosu

「patterns.h、打鍵する指が痛いぜ☆!定石ファイルなのかだぜ☆?」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// patterns.h -- 動きのパターンたち
//

#define PATNO 24
#define MAXPC 16

// パターンの x,y 座標と、属性。
struct patval
{
    int x,
        y,
        att;
        // att = 0 - empty,
        //       1 - your piece,
        //       2 - my piece,
        //       3 - my next move
        //       4 - empty on edge,
        //       5 - your piece on edge,
        //       6 - my piece on edge
};
struct pattern
{
    struct patval patn[MAXPC];  // パターン
    int patlen;                 // パターンの中のピースズの数
    int trfno;                  // 行列変換の番号
    int patwt;                  // パターンの評価値
};

static struct pattern pat[PATNO] =
{
    //   pattern 0: 232   connect if invaded
    //      010
    {
        {
            {0, 0,     2},
            {0, 1, EMPTY},
            {1, 0,     3},
            {1, 1,     1},
            {2, 0,     2},
            {2, 1, EMPTY}
        },
        6,
        4,
        82
    },
    // pattern 1: 230   connect if invaded
    //    012
    {
        {
            {0, 0,     2},
            {0, 1, EMPTY},
            {1, 0,     3},
            {1, 1,     1},
            {2, 0, EMPTY},
            {2, 1,     2}
        },
        6,
        8,
        82
    },
    // pattern 2: 212   try to attack
    //    030
    {
        {
            {0, 0,     2},
            {0, 1, EMPTY},
            {1, 0,     1},
            {1, 1,     3},
            {2, 0,     2},
            {2, 1, EMPTY}
        },
        6,
        4,
        82
    },
    // pattern 3: 2302   connect if invaded
    //    0100
    {
        {
            {0, 0,     2},
            {0, 1, EMPTY},
            {1, 0,     3},
            {1, 1,     1},
            {2, 0, EMPTY},
            {2, 1, EMPTY},
            {3, 0,     2},
            {3, 1, EMPTY}
        },
        8,
        8,
        83
    },
    // pattern 4: 20302   connect if invaded
    // 00100
    {
        {
            {0, 0,     2},
            {0, 1, EMPTY},
            {1, 0, EMPTY},
            {1, 1, EMPTY},
            {2, 0,     3},
            {2, 1,     1},
            {3, 0, EMPTY},
            {3, 1, EMPTY},
            {4, 0,     2},
            {4, 1, EMPTY}
        },
        10,
        4,
        84
    },
    // pattern 5: 203   form eye to protect
    //    021
    {
        {
            {0, 0,     2},
            {0, 1, EMPTY},
            {1, 0, EMPTY},
            {1, 1,     2},
            {2, 0,     3},
            {2, 1,     1}
        },
        6,
        8,
        82
    },
    // pattern 6: 202    form eye to protect
    // 031
    {
        {
            {0, 0,     2},
            {0, 1, EMPTY},
            {1, 0, EMPTY},
            {1, 1,     3},
            {2, 0,     2},
            {2, 1,     1}
        },
        6,
        8,
        82
    },
    // pattern 7: 230   connect if invaded
    //    102
    {
        {
            {0, 0,     2},
            {0, 1,     1},
            {1, 0,     3},
            {1, 1, EMPTY},
            {2, 0, EMPTY},
            {2, 1,     2}
        },
        6,
        8,
        82
    },
    // pattern 8: 200000
    //  00030  extend
    //  00000
    {
        {
            {0, 0,     2},
            {1, 0, EMPTY},
            {2, 0, EMPTY},
            {3, 0, EMPTY},
            {4, 0, EMPTY},
            {5, 0, EMPTY},
            {1, 1, EMPTY},
            {2, 1, EMPTY},
            {3, 1, EMPTY},
            {4, 1,     3},
            {5, 1, EMPTY},
            {1, 2, EMPTY},
            {2, 2, EMPTY},
            {3, 2, EMPTY},
            {4, 2, EMPTY},
            {5, 2, EMPTY}
        },
        16,
        8,
        80
    },
    //pattern 9:  2
    //000
    //000  extend
    //000
    //030
    //000
    {
        {
            { 0, 0,     2},
            {-1, 1, EMPTY},
            { 0, 1, EMPTY},
            { 1, 1, EMPTY},
            {-1, 2, EMPTY},
            { 0, 2, EMPTY},
            { 1, 2, EMPTY},
            {-1, 3, EMPTY},
            { 0, 3, EMPTY},
            { 1, 3, EMPTY},
            {-1, 4, EMPTY},
            { 0, 4,     3},
            { 1, 4, EMPTY},
            {-1, 5, EMPTY},
            { 0, 5, EMPTY},
            { 1, 5, EMPTY}
        },
        16,
        4,
        80
    },
    //pattern 10: 20000
    //0030  extend
    //0000
    {
        {
            {0, 0,     2},
            {1, 0, EMPTY},
            {2, 0, EMPTY},
            {3, 0, EMPTY},
            {4, 0, EMPTY},
            {1, 1, EMPTY},
            {2, 1, EMPTY},
            {3, 1,     3},
            {4, 1, EMPTY},
            {1, 2, EMPTY},
            {2, 2, EMPTY},
            {3, 2, EMPTY},
            {4, 2, EMPTY}
        },
        13,
        8,
        79
    },
    //pattern 11:    2
    //        000
    //        000  extend
    //        030
    //        000
    {
        {
            { 0, 0,     2},
            {-1, 1, EMPTY},
            { 0, 1, EMPTY},
            { 1, 1, EMPTY},
            {-1, 2, EMPTY},
            { 0, 2, EMPTY},
            { 1, 2, EMPTY},
            {-1, 3, EMPTY},
            { 0, 3,     3},
            { 1, 3, EMPTY},
            {-1, 4, EMPTY},
            { 0, 4, EMPTY},
            { 1, 4, EMPTY}
        },
        13,
        4,
        79
    },
    //pattern 12: 2000
    //     030  extend
    //     000
    {
        {
            {0, 0,     2},
            {1, 0, EMPTY},
            {2, 0, EMPTY},
            {3, 0, EMPTY},
            {1, 1, EMPTY},
            {2, 1,     3},
            {3, 1, EMPTY},
            {1, 2, EMPTY},
            {2, 2, EMPTY},
            {3, 2, EMPTY}
        },
        10,
        8,
        76
    },
    //pattern 13:    2
    //        000  extend
    //        030
    //        000
    {
        {
            { 0, 0,     2},
            {-1, 1, EMPTY},
            { 0, 1, EMPTY},
            { 1, 1, EMPTY},
            {-1, 2, EMPTY},
            { 0, 2,     3},
            { 1, 2, EMPTY},
            {-1, 3, EMPTY},
            { 0, 3, EMPTY},
            { 1, 3, EMPTY}
        },
        10,
         4,
        76
    },
    //pattern 14: 643   form eye on the edge
    //     20
    {
        {
            {0, 0,     6},
            {1, 0,     4},
            {1, 1,     2},
            {2, 0,     3},
            {2, 1, EMPTY}
        },
         5,
         8,
        80
    },
    //pattern 15: 646    solidify eye on the edge
    //        231
    {
        {
            {0, 0, 6},
            {1, 0, 4},
            {1, 1, 2},
            {2, 0, 6},
            {2, 1, 3},
            {3, 1, 1}
        },
         6,
         8,
        75
    },
    //pattern 16: 646    solidify eye on the edge
    //     230
    //      1
    {
        {
            {0, 0,     6},
            {1, 0,     4},
            {1, 1,     2},
            {2, 0,     6},
            {2, 1,     3},
            {2, 2,     1},
            {3, 1, EMPTY}
        },
         7,
         8,
        75
    },
    //pattern 17: 646    solidify eye on the edge
    //     230
    //      0
    {
        {
            {0, 0,     6},
            {1, 0,     4},
            {1, 1,     2},
            {2, 0,     6},
            {2, 1,     3},
            {2, 2, EMPTY},
            {3, 1, EMPTY}
        },
         7,
         8,
        75
    },
    //pattern 18:    2       form eye on center
    //        202
    //     3
    {
        {
            { 0, 0,     2},
            {-1, 1,     2},
            { 0, 1, EMPTY},
            { 1, 1,     2},
            { 0, 2,     3}
        },
         5,
         4,
        80
    },
    //pattern 19:    2       solidify eye on center
    //        202
    //     231
    {
        {
            { 0, 0,     2},
            {-1, 1,     2},
            { 0, 1, EMPTY},
            { 1, 1,     2},
            { 0, 2,     2},
            { 1, 2,     3},
            { 2, 2,     1}
        },
         7,
         8,
        75
    },
    //pattern 20:    2       solidify eye on center
    //        202
    //     230
    //      0
    {
        {
            { 0, 0,     2},
            {-1, 1,     2},
            { 0, 1, EMPTY},
            { 1, 1,     2},
            { 0, 2,     2},
            { 1, 2,     3},
            { 2, 2, EMPTY},
            { 1, 3, EMPTY}
        },
         8,
         8,
        75
    },
    //pattern 21:    2      solidify eye on center
    //        202
    //     230
    //      1
    {
        {
            { 0, 0,     2},
            {-1, 1,     2},
            { 0, 1, EMPTY},
            { 1, 1,     2},
            { 0, 2,     2},
            { 1, 2,     3},
            { 2, 2, EMPTY},
            { 1, 3,     1}
        },
         8,
         8,
        75
    },
    //pattern 23: 20100     connect if invaded
    //        00302
    {
        {
            {0, 0,     2},
            {0, 1, EMPTY},
            {1, 0, EMPTY},
            {1, 1, EMPTY},
            {2, 0,     1},
            {2, 1,     3},
            {3, 0, EMPTY},
            {3, 1, EMPTY},
            {4, 0, EMPTY},
            {4, 1,     2}
        },
        10,
         8,
        84
    },
    //pattern 24: 2100    connect if invaded
    //        0302
    {
        {
            {0, 0,     2},
            {0, 1, EMPTY},
            {1, 0,     1},
            {1, 1,     3},
            {2, 0, EMPTY},
            {2, 1, EMPTY},
            {3, 0, EMPTY},
            {3, 1,     2}
        },
        10,
         8,
        83
    }
};

UEUESHIMA_Komado_80x80x8_02_nitaari

「おつだぜ☆wwww」


04:15

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「sethand.c は、ハンディーキャップの石を置く関数みたいだな☆」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// sethand.c -- 黒側のためのハンディーキャップ・ピースズをセットアップします。
//

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤

///
/// ハンディーキャップ・ピースズをセットアップします。
///
void sethand(int i)
{
    if (i > 0)
    {
        p[3][3] = BLACK;
        if (i > 1)
        {
            p[15][15] = BLACK;
            if (i > 2)
            {
                p[3][15] = BLACK;
                if (i > 3)
                {
                    p[15][3] = BLACK;
                    if (i == 5)
                    {
                        p[9][9] = BLACK;
                    }
                    else
                    {
                        if (i > 5)
                        {
                            p[9][15] = BLACK;
                            p[9][3] = BLACK;
                            if (i == 7)
                                p[9][9] = BLACK;
                            else
                            {
                                if (i > 7)
                                {
                                    p[15][9] = BLACK;
                                    p[3][9] = BLACK;
                                    if (i > 8)
                                    {
                                        p[9][9] = BLACK;
                                    }
                                        
                                    if (i > 9)
                                    {
                                        p[2][2] = 2;
                                        if (i > 10)
                                        {
                                            p[16][16] = 2;
                                            if (i > 11)
                                            {
                                                p[2][16] = 2;
                                                if (i > 12)
                                                {
                                                    p[16][2] = 2;
                                                    if (i > 13)
                                                    {
                                                        p[6][6] = 2;
                                                        if (i > 14)
                                                        {
                                                            p[12][12] = 2;
                                                            if (i > 15)
                                                            {
                                                                p[6][12] = 2;
                                                                if (i > 16)
                                                                {
                                                                    p[12][6] = 2;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「if文のネストが深いぜ☆wwww」


04:47

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「showbord.c は、コンソール画面に碁盤を表示しているようだな☆

列は A~T で19列を表示しているみたいなんだが、

I を使ってないというのが面白いな☆ww 1 と間違えやすいからかなんだぜ☆?wwww」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// showbord.c -- カレント碁盤とプレイヤー情報を表示します。
//

#include <stdio.h>
#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤
extern int mymove, umove;       // コンピューターの色、相手の色
extern int mk, uk;              // コンピューターと相手による取った石たちの番号

// 碁盤を見せます。
void showboard(void)
{
    int i, j, ii;

    // p = 0 for empty ,
    // p = 1 for white piece,
    // p = 2 for black piece
    printf("   A B C D E F G H J K L M N O P Q R S T\n");

    // 行 19~17
    for (i = 0; i < 3; i++)
    {
        ii = 19 - i;
        printf("%2d",ii);

        for (j = 0; j < 19; j++)
        {
            if (p[i][j] == EMPTY)
            {
                printf(" -");
            }
            else if (p[i][j] == WHITE)
            {
                printf(" O");
            }
            else
            {
                printf(" X");
            }

            printf("%2d",ii);
            printf("\n");
        }
    }
    
    // 行 16
    printf("16");

    for (j = 0; j < 3; j++)
    {
        if (p[3][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[3][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    if (p[3][3] == 0)
    {
        printf(" +");
    }
    else if (p[3][3] == WHITE)
    {
        printf(" O");
    }
    else
    {
        printf(" X");
    }

    for (j = 4; j < 9; j++)
    {
        if (p[3][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[3][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    if (p[3][9] == EMPTY)
    {
        printf(" +");
    }
    else if (p[3][9] == WHITE)
    {
        printf(" O");
    }
    else
    {
        printf(" X");
    }

    for (j = 10; j < 15; j++)
    {
        if (p[3][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[3][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    if (p[3][15] == EMPTY)
    {
        printf(" +");
    }
    else if (p[3][15] == WHITE)
    {
        printf(" O");
    }
    else
    {
        printf(" X");
    }

    for (j = 16; j < 19; j++)
    {
        if (p[3][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[3][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    printf("16");

    if (umove == 1)
    {
        printf("     Your color: White O\n");
    }
    else
    {
        if (umove == 2)
        {
            printf("     Your color: Black X\n");
        }
        else
        {
            printf("\n");
        }
    }

    // 行 15~11
    for (i = 4; i < 9; i++)
    {
        ii = 19 - i;
        printf("%2d",ii);

        for (j = 0; j < 19; j++)
        {
            if (p[i][j] == EMPTY)
            {
                printf(" -");
            }
            else if (p[i][j] == WHITE)
            {
                printf(" O");
            }
            else
            {
                printf(" X");
            }
        }

        printf("%2d",ii);
        if (i == 4)
        {
            if (mymove == 1)
            {
                printf("     My color:   White O\n");
            }
            else if (mymove == 2)
            {
                printf("     My color:   Black X\n");
            }
            else
            {
                printf("\n");
            }
        }
        else if (i != 8)
        {
            printf("\n");
        }
        else
        {
            printf("     You have captured %d pieces\n", mk);
        }
    }

    // 行 10
    printf("10");

    for (j = 0; j < 3; j++)
    {
        if (p[9][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[9][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    if (p[9][3] == EMPTY)
    {
        printf(" +");
    }
    else if (p[9][3] == WHITE)
    {
        printf(" O");
    }
    else
    {
        printf(" X");
    }

    for (j = 4; j < 9; j++)
    {
        if (p[9][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[9][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    if (p[9][9] == EMPTY)
    {
        printf(" +");
    }
    else if (p[9][9] == WHITE)
    {
        printf(" O");
    }
    else
    {
        printf(" X");
    }

    for (j = 10; j < 15; j++)
    {
        if (p[9][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[9][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    if (p[9][15] == EMPTY)
    {
        printf(" +");
    }
    else if (p[9][15] == WHITE)
    {
        printf(" O");
    }
    else
    {
        printf(" X");
    }

    for (j = 16; j < 19; j++)
    {
        if (p[9][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[9][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    printf("10");
    printf("     I have captured %d pieces\n", uk);

    // 行 9~5
    for (i = 10; i < 15; i++)
    {
        ii = 19 - i;
        printf("%2d",ii);

        for (j = 0; j < 19; j++)
        {
            if (p[i][j] == EMPTY)
            {
                printf(" -");
            }
            else if (p[i][j] == WHITE)
            {
                printf(" O");
            }
            else
            {
                printf(" X");
            }
        }

        printf("%2d",ii);
        printf("\n");
    }
    
    // 行 4
    printf(" 4");

    for (j = 0; j < 3; j++)
    {
        if (p[15][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[15][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    if (p[15][3] == EMPTY)
    {
        printf(" +");
    }
    else if (p[15][3] == WHITE)
    {
        printf(" O");
    }
    else
    {
        printf(" X");
    }

    for (j = 4; j < 9; j++)
    {
        if (p[15][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[15][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    if (p[15][9] == EMPTY)
    {
        printf(" +");
    }
    else if (p[15][9] == WHITE)
    {
        printf(" O");
    }
    else
    {
        printf(" X");
    }

    for (j = 10; j < 15; j++)
    {
        if (p[15][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[15][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    if (p[15][15] == EMPTY)
    {
        printf(" +");
    }
    else if (p[15][15] == WHITE)
    {
        printf(" O");
    }
    else
    {
        printf(" X");
    }

    for (j = 16; j < 19; j++)
    {
        if (p[15][j] == EMPTY)
        {
            printf(" -");
        }
        else if (p[15][j] == WHITE)
        {
            printf(" O");
        }
        else
        {
            printf(" X");
        }
    }

    printf(" 4");
    printf("\n");

    // 行 3~1
    for (i = 16; i < 19; i++)
    {
        ii = 19 - i;
        printf("%2d",ii);

        for (j = 0; j < 19; j++)
        {
            if (p[i][j] == EMPTY)
            {
                printf(" -");
            }
            else if (p[i][j] == WHITE)
            {
                printf(" O");
            }
            else
            {
                printf(" X");
            }
        }

        printf("%2d",ii);
        printf("\n");
    }
    printf("   A B C D E F G H J K L M N O P Q R S T\n\n");
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「ほうほう☆ww」


04:52

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「showinst.c は、ゲーム開始時に出てくる説明みたいなんだぜ☆」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// showinst.c -- ゲーム開始の説明を表示します。
//

#include <stdio.h>
#include "gnugo.h"

///
/// プログラムの説明の表示
///
void showinst(void)
{
    printf("XOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOX");
    printf("OXOXOXOXOXOX\n");
    printf("O                                                                  ");
    printf("           O\n");
    printf("X                           GNUGO (Previously Hugo)                ");
    printf("           X\n");
    printf("O                           the game of Go (Wei-Chi)               ");
    printf("           O\n");
    printf("X                                                                  ");
    printf("           X\n");
    printf("O                            version 1.2   10-31-95                ");
    printf("           O\n");
    printf("X           Copyright (C) 1989, 1995 Free Software Foundation, Inc.");
    printf("           X\n");
    printf("O                              Author: Man L. Li                   ");
    printf("           O\n");
    printf("X           GNUGO comes with ABSOLUTELY NO WARRANTY; see COPYING fo");
    printf("r          X\n");
    printf("O           detail.   This is free software, and you are welcome to");
    printf("           O\n");
    printf("X           redistribute it; see COPYING for copying conditions.   ");
    printf("           X\n");
    printf("O                                                                  ");
    printf("           O\n");
    printf("X              Please report all bugs, modifications, suggestions  ");
    printf("           X\n");
    printf("O                             to manli@cs.uh.edu                   ");
    printf("           O\n");
    printf("X                                                                  ");
    printf("           X\n");
    printf("OXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXO");
    printf("XOXOXOXOXOXO\n");
    printf("\n\n\n\n\n\n\n\nPress return to continue");
    getchar();
    printf("\n\nTo play this game first select number of handicap pieces (0 to");
    printf(" 17) for the\nblack side.  Next choose your color (black or white).");
    printf("  To place your piece,\nenter your move as coordinate on the board");
    printf(" in column and row.  The column\nis from 'A' to 'T'(excluding 'I').");
    printf("  The row is from 1 to 19.\n\nTo pass your move enter 'pass' for");
    printf(" your turn.  After both you and the computer\npassed the game will");
    printf(" end.  To save the board and exit enter 'save'.  The game\nwill");
    printf(" continue the next time you start the program.  To stop the game in");
    printf(" the\nmiddle of play enter 'stop' for your move.  You will be");
    printf(" asked whether you want\nto count the result of the game.  If you");
    printf(" answer 'y' then you need to remove the\nremaining dead pieces and");
    printf(" fill up neutral turf on the board as instructed.\nFinally, the");
    printf(" computer will count all pieces for both side and show the result.\n\n");
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「だいぶ、ソースコードを読み込んだな☆!」


05:22

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「suicide.c は、自殺手でないか調べているんだと思うぜ☆

なんだか分からないぜ☆」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// suicide.c -- 相手の非合法手を調べます。
//

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤
extern unsigned char l[19][19]; // カレント色のリバーティー
extern int mymove, umove;       // コンピューター色、相手色
extern int lib;                 // カレント石のリバーティー
extern int uik, ujk;            // 相手が取った石の位置i,j

///
/// 相手の盤上i,jの動きが自殺手でないか調べます。
///
int suicide(int i,
            int j)
{
    int m, n, k;

    // 新しい動きのリバーティーを調べます。
    lib = 0;
    countlib(i, j, umove);
    if (lib == 0)
    // 調べて、もしコンピューターのピースズを殺して、コの可能性があれば、
    // 新しい動きは自殺手です。
    {
        // assume alive
        p[i][j] = umove;

        // コンピューターのピースズの評価値を調べます。
        eval(mymove);
        k = 0;

        for (m = 0; m < 19; m++)
        {
            for (n = 0; n < 19; n++)
            {
                // 殺されるかもしれないピースズを数えます。
                if
                (
                    (p[m][n] == mymove)
                    &&
                    !l[m][n]
                )
                {
                    ++k;
                }

                if
                (
                    (k == 0)
                    ||
                    (
                        k == 1
                        &&
                        (
                            (i == uik)
                            &&
                            (j == ujk)
                        )
                    )
                )
                // either no effect on my pieces or an illegal Ko take back
                {
                    p[i][j] = EMPTY;   /* restore to open */
                    return 1;
                }
                else
                {
                    /* good move */
                    return 0;
                }
            }
        }
    }
    else
    {
        /* valid move */
        return 0;
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「これで全部のソースに目を通したな☆!」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「もう1週見直すぜ☆」


11:28

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「おっ☆」

201511261128

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「見た目はなんか崩れているんだが、GNUの碁を C#に移植したぜ☆」

\ ズーーーーーピーーーーーー☆ /

UEUESHIMA_Komado_80x80x8_07_piririUmauma

「Zzzzzz☆」


11:44

201511261144

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「19路盤って、でかすぎないかだぜ☆?」


12:29

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「配列の長さを超えてアクセスするエラーが出てくるんだが、

移植にミスったんだろうか☆ 調べるんだぜ☆」

201511261229

 


12:37

201511261237

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「C# では、配列の長さは 配列が持っているので、

わざわざ 配列の長さを覚えておく必要はないんだぜ☆」


12:57

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「コンピューターがパスばっかりやり始めたんだが、

こっちはどうやってパスするんだぜ☆?」

201511261257


13:10

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「new string(charArray) と、

charArray.ToString() は別物だったのか☆」


 

 

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(4) どんどん、ソースコードを読んでいくんだぜ☆!
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket

【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(3) ぽつぽつ、ソースコードを読んでいくんだぜ☆

2015-11-25 21:05

..

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ハハッ☆! 面白っ☆! きふわらべが出ているぜ☆!」

UEUESHIMA_Komado_80x80x8_03_jitoo

「バイトは☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「バイトは夜中だぜ☆!」


21:07

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「GNUの囲碁のソースを読もうぜ☆!」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/

/*------------------------------------------------------
  eval.c -- 同じ色の石たちを評価します。
------------------------------------------------------*/

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤
extern unsigned char l[19][19]; // カレント色のリバーティー
extern int lib;                 // カレント石のリバーティー

///
/// evaluate liberty of 色ピースズのリバーティーを評価します。
///
void eval(
            int color   // 黒 or 白
         )
{
    int i, j;

    // find liberty of それぞれのピースのリバーティーを探します。
    for (i = 0; i < 19; i++)// 19路盤
    {
        for (j = 0; j < 19; j++)
        {
            if (p[i][j] == color)// 指定の色のみ
            {
                lib = 0;
                countlib(i, j, color);
                l[i][j] = lib;
            }
        }
    }
}

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「あれっ☆!? 評価関数って この数行だけなのかだぜ☆wwwww

囲碁の評価関数とは……☆! とか思ったんだが、

短っ☆wwww」

UEUESHIMA_Komado_80x80x8_02_nitaari

「このプログラムは、何をやっているんだぜ☆?」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「指定した色の石のリバーティーを数えているんだが、

重複して数えていないのか、ちょっと分からないぜ☆」


22:10

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「exambord.c は、取った石の数を数えているのかなんだぜ……☆?

わかんないぜ☆」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/

///
///  exambord.c -- 調査用(Examine)碁盤を使った、1つの色と、結果の更新のためのリバーティー。
///

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤
extern unsigned char l[19][19]; // カレント色のリバーティー
extern int mymove;              // コンピューターの色

// mはme?自分(コンピューター)、uは相手?you?
extern int mik, mjk;            // コンピューターが取った石の位置
extern int uik, ujk;            // 相手が取った石の位置
extern int mk, uk;              // コンピューターと相手による、取った石たちの個数

//
// 調査用のピースズ
//
void examboard(
                int color   // 黒 or 白
              )
{
   int  i,
        j,
        n
        ;

    // それぞれのピースのリバーティーを探します。
    eval(color);

    // 取ったピースを初期化します。
    if (color == mymove)
    {
        mik = -1;
        mjk = -1;
    }
    else
    {
        uik = -1;
        ujk = -1;
    }
    n = 0; // コ・プロポーゼス(Ko purposes)のための、この動きで石を取ることの番号。

    // ゼロ・リバーティーの全ピースを削除します。
    for (i = 0; i < 19; i++) // 19路盤
    {
        for (j = 0; j < 19; j++)
        {
            // pは対局中の碁盤? l はリバーティーのカウント。
            if ((p[i][j] == color) && (l[i][j] == 0))
            {
                p[i][j] = EMPTY; // 0クリアー?
                // 取ったピースをカウントアップ
                if (color == mymove)// コンピューター側の色
                {
                    mik = i;    // 自分(コンピューター)が取った石の位置i,j。
                    mjk = j;
                    ++mk;
                }
                else
                {
                    uik = i;    // 相手が取った石の位置i,j。
                    ujk = j;
                    ++uk;
                }
                ++n;    // increment number of captures on this move
            }
            // reset to -1 if more than one stone captured since  no Ko possible
            if (color == mymove && n > 1)
            {
                mik = -1;   // 自分(コンピューター)が取った石の位置情報をクリアー。
                mjk = -1;
            }
            else if ( n > 1 )
            {
                uik = -1;   // 相手が取った石の位置情報をクリアー。
                ujk = -1;
            }
        }
    }
}

22:17

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「iは19路盤の行番号、jは列番号☆」


22:55

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「findcolr.c は、何やってるか分からないぜ☆」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/

//
// findcolr.c -- 空っぽな交点の色を探します。
//

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤

//
// 空っぽ交点のピースのための色を探します。
//
unsigned int findcolor
(
    int i,  // 行番号 0~18
    int j   // 列番号 0~18
)
{
    int k,          // 使いまわされる、汎用的なループ・カウンター。
        result,     // 色
        color[4]    // [0]北、[1]南、[2]西、[3]東
        ;

    //
    // 指定した盤上の位置に石があれば、その色を返します。
    //
    if (p[i][j] != EMPTY)
    {
        return p[i][j];
    }

    // 北ネイバーを、石に突き当たるまで調べます。
    if (i>0)
    {
        // (0より大きい、指定の行番号)~ 1 まで。
        k = i; 
        do
        {
            --k;
        }
        while ((p[k][j] == EMPTY) && (k > 0));
        color[0] = p[k][j];
    }
    else
    {
        // 指定した交点の色。(空っぽの交点?)
        color[0] = p[i][j];
    }

    // 南ネイバーを、石に突き当たるまで調べます。
    if (i<18)
    {
        // (18より小さい、指定の行番号)~ 17 まで。
        k = i;
        do
        {
            ++k;
        }
        while ((p[k][j] == EMPTY) && (k < 18));
        color[1] = p[k][j];
    }
    else
    {
        // 指定した交点の色。(空っぽの交点?)
        color[1] = p[i][j];
    }

    // 西ネイバーを、石に突き当たるまで調べます。
    if (j>0)
    {
        // (0より大きい、指定の列番号)~ 1 まで。
        k = j;
        do
        {
            --k;
        }
        while ((p[i][k] == EMPTY) && (k > 0));
        color[2] = p[i][k];
    }
    else
    {
        // 指定した交点の色。(空っぽの交点?)
        color[2] = p[i][j];
    }

    // 東ネイバーを、石に突き当たるまで調べます。
    if (j<18)
    {
        // (18より小さい、指定の列番号)~ 17 まで。
        k = j;
        do
        {
            ++k;
        }
        while ((p[i][k] == EMPTY) && (k < 18));
        color[3] = p[i][k];
    }
    else
    {
        // 指定した交点の色。(空っぽの交点?)
        color[3] = p[i][j];
    }

    // 4方向のうち、空っぽでない交点の色を1つだけ知りたい。
    for (k=0;k<4;k++)
    {
        if (color[k] == EMPTY)
        {
            continue;
        }
        else
        {
            result = color[k];
            break;
        }
    }

    // クロスチェックします。
    // もし  わたしたちがエラーを見つけたなら、全ての死ピースは盤から取らない。
    // わたしたちはこれを修正するようプレイヤーたちに促す。
    for (k=0;k<4;k++)
    {
        // 色が設定されているのに、返す結果の色が違っていたらエラーです。問題です。
        if ((color[k] != EMPTY) && (color[k] != result))
        {
            return 0;
        }
    }

    // もし、わたしたちが全てのチェックにOKすれば、結果をレポートします。
    return result;
}

UEUESHIMA_Komado_80x80x8_09_Nikoniko

「読んでいるうちに、後で分かってくるだろう☆」


23:45

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「findnext.c は、コンピューター将棋で言うところの

bestmove を探す関数なのかだぜ☆?

評価値を出しては、高い方の石を置く場所を探しているんじゃないかなんだぜ☆?」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/

//
// findnext.c -- 現在位置へと続く、次のコンピューターの一手を探します。
//

#include "gnugo.h"

extern unsigned char p[19][19];     // 碁盤
extern unsigned char ma[19][19];    // マーキングのための作業用行列
extern int mymove;                  // コンピューターの色
extern int lib;                     // 現在の石のリバーティー。

static int fval(int newlib, int minlib);

//
// 位置m,nを含むグループから、新しい指し手 i,j を探します。
//
int findnextmove(
                    int m,      // カレント・ストーンの 行番号
                    int n,      // 〃                   列番号
                    int *i,     // 次の動きの   行番号
                    int *j,     // 〃           列番号
                    int *val,   // 次の動きの評価値
                    int minlib  // カレント・ストーンのリバーティー。
                 )
{
    int ti,
        tj,
        tval    // 隣位置の評価値
        ;
    int found = 0;

    *i = -1;   *j = -1;	*val = -1;

    // カレント位置をマークします。
    ma[m][n] = 1;

    //--------------------------------------------------------------------------
    // 北ネイバーを調べます。
    if (m != 0) // 0行でなければ。
    {
        // p[m - 1][n] は北隣。
        if (p[m - 1][n] == EMPTY)
        {
            ti = m - 1; // 北隣の位置i,jをセット
            tj = n;
            
            // 北隣のリバーティーを調べます。
            lib = 0;
            countlib(ti, tj, mymove);
            tval = fval(lib, minlib);   // 評価値計算
            
            found = 1;
        }
        else if (
                        (p[m - 1][n] == mymove) // 北隣がコンピューターの石で、
                    &&  !ma[m - 1][n]           // 北隣のマーキングが 0 なら
                )
        {
            if (findnextmove(m - 1, n, &ti, &tj, &tval, minlib))    // 再帰的に検索
            {
                found = 1;
            }
        }
    }

    if (found)  // 見つかったら1
    {
        found = 0;
        if (tval > *val && fioe(ti, tj) != 1)
        {
            *val = tval;    // 高い方の評価値を残している?
            *i = ti;        // 高い方の交点i,jを残している?
            *j = tj;
        }
    }

    //--------------------------------------------------------------------------
    // 南ネイバーを調べます。
    if (m != 18)    // 18行でなければ。
    {
        // p[m + 1][n] は南隣。
        if (p[m + 1][n] == EMPTY)
        {
            ti = m + 1; // 南隣の位置i,jをセット
            tj = n;
            
            lib = 0;
            countlib(ti, tj, mymove);
            tval = fval(lib, minlib);
            found = 1;
        }
        else if ((p[m + 1][n] == mymove) && !ma[m + 1][n])
        {
            if (findnextmove(m + 1, n, &ti, &tj, &tval, minlib))
            {
                found = 1;
            }
        }
    }

    if (found)  // 見つかったら1
    {
        found = 0;
        if (tval > *val && fioe(ti, tj) != 1)
        {
            *val = tval;
            *i = ti;
            *j = tj;
        }
    }

    //--------------------------------------------------------------------------
    // 西ネイバーを調べます。
    if (n != 0) // 0列でなければ。
    {
        // p[m][n - 1] は西隣。
        if (p[m][n - 1] == EMPTY)
        {
            ti = m;      // 西隣の位置i,jをセット
            tj = n - 1;

            lib = 0;
            countlib(ti, tj, mymove);
            tval = fval(lib, minlib);
            found = 1;
        }
        else
        {
            if ((p[m][n - 1] == mymove) && !ma[m][n - 1])
            {
                if (findnextmove(m, n - 1, &ti, &tj, &tval, minlib))
                {
                    found = 1;
                }
            }
        }
    }

    if (found)  // 見つかっていれば 1
    {
        found = 0;
        if (tval > *val && fioe(ti, tj) != 1)
        {
            *val = tval;
            *i = ti;
            *j = tj;
        }
    }

    //--------------------------------------------------------------------------
    // 東ネイバーを調べます。
    if (n != 18)    // 18列でなければ。
    {
        // p[m][n + 1] は東隣。
        if (p[m][n + 1] == EMPTY)
        {
            ti = m;      // 東隣の位置i,jをセット
            tj = n + 1;

            lib = 0;
            countlib(ti, tj, mymove);
            tval = fval(lib, minlib);
            found = 1;
        }
        else
        {
            if ((p[m][n + 1] == mymove) && !ma[m][n + 1])
            {
                if (findnextmove(m, n + 1, &ti, &tj, &tval, minlib))
                {
                    found = 1;
                }
            }
        }
    }

    if (found)  // 見つかっていれば 1
    {
        found = 0;
        if (tval > *val && fioe(ti, tj) != 1)
        {
            *val = tval;
            *i = ti;
            *j = tj;
        }
    }

    //--------------------------------------------------------------------------
    if (*val > 0)   // 次の動きを見つけた。
    {
        return 1;
    }
    else    // 次の動きは失敗。
    {
        return 0;
    }
}

///
/// 新しい動きを評価する関数です。
///
int fval
        (
            int newlib, // 新しいリバーティー
            int minlib  // 現在のリバーティー
        )
{
    int k,  // リバーティーの差
        val // 評価値
        ;

    if (newlib <= minlib)
    {
        val = -1;   // 評価値は -1
    }
    else
    {
        k = newlib - minlib;    // リバーティーの差
        
        val =   40  // 40を基本に。
                +
                (k - 1) * 50    // リバーティーの差のおよそ 50倍
                /
                (minlib * minlib * minlib)  // 現在のリバーティーの3乗
                ;
    }

    return val;
}

UEUESHIMA_Komado_80x80x8_09_Nikoniko

「ほうほう☆」


2015-11-26 0:06

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「findopen.c は、合法手のリストを作っているんじゃないかなんだぜ☆?」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/

//
//  findopen.c -- Find possible moves from カレント位置から可能な動きを探します。
//

#include "gnugo.h"

extern unsigned char p[19][19];     // 碁盤
extern unsigned char ma[19][19];    // マーキング用の作業用行列
extern int mik, mjk;                // コンピューターが取った石の位置

///
/// 位置m, n からの 全てが開いているスペースたち i, j を探します。
///
int findopen(
                int m,      // カレント 行番号 0~18
                int n,      // 〃       列番号 0~18
                int i[],    // 可能な動きのための   行配列
                int j[],    // 〃                   列配列
                int color,  // 黒 or 白
                int minlib, // カレント・リバーティー
                int *ct     // 可能な動きの数(配列のインデックス)
            )
{
    // 1 でマークします。
    ma[m][n] = 1;

    // 北ネイバー
    if (m != 0)
    {
        if ((p[m - 1][n] == EMPTY) && (((m - 1) != mik) || (n != mjk)))
        {
            i[*ct] = m - 1;
            j[*ct] = n;
            ++*ct;
            if (*ct == minlib)
            {
                return 1;
            }
        }
        else if ((p[m - 1][n] == color) && !ma[m - 1][n])
        {
            if (findopen(m - 1, n, i, j, color, minlib, ct) && (*ct == minlib))
            {
                return 1;
            }
        }
    }

    // 南ネイバーを調べます。
    if (m != 18)
    {
        if ((p[m + 1][n] == EMPTY) && (((m + 1) != mik) || (n != mjk)))
        {
            i[*ct] = m + 1;
            j[*ct] = n;
            ++*ct;
            if (*ct == minlib)
            {
                return 1;
            }
        }
        else
        {
            if ((p[m + 1][n] == color) && !ma[m + 1][n])
            {
                if (findopen(m + 1, n, i, j, color, minlib, ct) && (*ct == minlib))
                {
                    return 1;
                }
            }
        }
    }

    // 西ネイバーを調べます。
    if (n != 0)
    {
        if ((p[m][n - 1] == EMPTY) && ((m != mik) || ((n - 1) != mjk)))
        {
            i[*ct] = m;
            j[*ct] = n - 1;
            ++*ct;
            if (*ct == minlib)
            {
                return 1;
            }
        }
        else if ((p[m][n - 1] == color) && !ma[m][n - 1])
        {
            if (findopen(m, n - 1, i, j, color, minlib, ct) && (*ct == minlib))
            {
                return 1;
            }
        }
    }

    // 東ネイバーを調べます。
    if (n != 18)
    {
        if ((p[m][n + 1] == EMPTY) && ((m != mik) || ((n + 1) != mjk)))
        {
            i[*ct] = m;
            j[*ct] = n + 1;
            ++*ct;
            if (*ct == minlib)
            {
                return 1;
            }
        }
        else if ((p[m][n + 1] == color) && !ma[m][n + 1])
        {
            if (findopen(m, n + 1, i, j, color, minlib, ct) && (*ct == minlib))
            {
                return 1;
            }
        }
    }

    // open space を見つけるのに失敗したら
    return 0;
}

UEUESHIMA_Komado_80x80x8_09_Nikoniko

「ほうほう☆!」


00:41

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「findpatn.c は、定跡じゃないかなんだぜ☆!」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/

//
// findpatn.c -- 序盤の動きたちと、パターンたちからの、コンピューターの動きを探します。
//

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤
extern int mymove, umove;       // コンピューターの色、相手の色
extern int opn[9];              // 序盤の動きを示します。

///
/// 次の動きのためにマッチするパターンを探します。
///
int findpatn(
                int *i,     // 次の動きの   行番号
                int *j,     // 〃           列番号
                int *val    // 〃           評価値
            )
{
    int m, n;
    int ti, tj, tval;
    static int cnd, mtype;  // ゲーム・ツリー・ノード番号、ムーブ・タイプ。
        //  mtype = 0 basic
        //          1 inverted
        //          2 reflected
        //          3 inverted & reflected

    // 序盤で占領できる(オキュパイ;occupy)の角(corners)。
    if (opn[4]) // 最後の動きの続き
    {
        opn[4] = 0; // フラグをクリアーします。
        if (opening(i, j, &cnd, mtype))
        {
            opn[4] = 1; // もっと動くならフラグをリセット。
        }
        
        if (p[*i][*j] == EMPTY)  // 妥当な動き
        {
            *val = 80;  // 評価値
            return 1;
        }
        else
        {
            opn[4] = 0;
        }
    }

    // 西北の角
    if (opn[0])
    {
        opn[0] = 0; // フラグをクリアー。
        if (openregion(0, 0, 5, 5))
        {
            cnd = 0;
            mtype = 0;
            opening(i, j, &cnd, mtype);  // 次の手のための新しいノードを取得します。
            if (opening(i, j, &cnd, mtype))
            {
                opn[4] = 1;
            }
            *val = 80;  // 評価値
            return 1;
        }
    }

    // 南西の角
    if (opn[1])
    {
        opn[1] = 0;
        if (openregion(13, 0, 18, 5))
        {
            cnd = 0;
            mtype = 1;
            opening(i, j, &cnd, mtype); // 次の手のための新しいノードを取得します。
            if (opening(i, j, &cnd, mtype))
            {
                opn[4] = 1;
            }
            *val = 80;  // 評価値
            return 1;
        }
    }

    // 北東の角
    if (opn[2])
    {
        opn[2] = 0;
        if (openregion(0, 13, 5, 18))
        {
            cnd = 0;
            mtype = 2;
            opening(i, j, &cnd, mtype);   // 次の手のための新しいノードを取得します。
            if (opening(i, j, &cnd, mtype))
            {
                opn[4] = 1;
            }
            *val = 80;  // 評価値
            return 1;
        }
    }

    // 南東の角
    if (opn[3])
    {
        opn[3] = 0;
        if (openregion(13, 13, 18, 18))
        {
            cnd = 0;
            mtype = 3;
            opening(i, j, &cnd, mtype);   // 次の手のための新しいノードを取得します。
            if (opening(i, j, &cnd, mtype))
            {
                opn[4] = 1;
            }
            *val = 80;  // 評価値
            return 1;
        }
    }

    //
    // 辺(edges)のオキュパイ(occupy)
    //
    
    // 北辺
    if (opn[5])
    {
        opn[5] = 0;
        if (openregion(0, 6, 4, 11))
        {
            *i = 3;     // 次の指し手の位置i,j
            *j = 9;
            *val = 80;  // 評価値
            return 1;
        }
    }

    // 南辺
    if (opn[6])
    {
        opn[6] = 0;
        if (openregion(18, 6, 14, 11))
        {
            *i = 15;     // 次の指し手の位置i,j
            *j =  9;
            *val = 80;  // 評価値
            return 1;
        }
    }

    // 西辺
    if (opn[7])
    {
        opn[7] = 0;
        if (openregion(6, 0, 11, 4))
        {
            *i =  9;     // 次の指し手の位置i,j
            *j =  3;
            *val = 80;  // 評価値
            return 1;
        }
    }

    // 東辺
    if (opn[8])
    {
        opn[8] = 0;
        if (openregion(6, 18, 11, 14))
        {
            *i =  9;     // 次の指し手の位置i,j
            *j = 15;
            *val = 80;  // 評価値
            return 1;
        }
    }

    *i = -1;
    *j = -1;
    *val = -1;

    //
    // ローカル・パターンを探します。
    //
    for (m = 0; m < 19; m++) // 19路盤
    {
        for (n = 0; n < 19; n++)
        {
            if
            (
                (p[m][n] == mymove) // コンピューターの石
                &&
                (
                    matchpat(m, n, &ti, &tj, &tval)
                    &&
                    (tval > *val)   // 評価値が高ければ
                )
            )
            {
                *val = tval;  // 評価値
                *i = ti;     // 次の指し手の位置i,j
                *j = tj;
            }
        }
    }

    if (*val > 0)   // パターンを見つけました。
    {
        return 1;
    }
    else    // パターンは見つかりませんでした。
    {
        return 0;
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「おっおっ☆! 定跡っぽいな☆!」


00:55

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「findsavr.c は、防御の指し手を探すのかなんだぜ☆?」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// findsavr.c -- 石たちの攻撃からの防御のためのコンピューターの次の動きを探します。
//

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤
extern unsigned char l[19][19]; // カレント色のリバーティー
extern int mymove;              // コンピューターの色

///
/// もし、幾つかのピースズが脅かされているなら、動きを探します。
///
int findsaver
            (
                int *i,     // 次の動きの   行番号
                int *j,     // 〃           列番号
                int *val    // 〃           評価値
            )
{
    int m,      // 行
        n,      // 列
        minlib  // 最小リバーティー 1~3 のループカウンター
        ;
    int ti,     // 行
        tj,     // 列
        tval    // 評価値
        ;

    *i = -1;    // 位置i,j
    *j = -1;
    *val = -1;  // 評価値
    for (minlib = 1; minlib < 4; minlib++)
    {
        // 最小リバーティーといっしょのピースを数えます。
        for (m = 0; m < 19; m++)
        {
            for (n = 0; n < 19; n++)
            {
                if
                (
                        (p[m][n] == mymove) // コンピューターの色
                    &&  (l[m][n] == minlib) // リバーティーの数
                )
                {
                    // セーブ・ピースズへの動きを探します。
                    initmark();
                    if
                    (
                        findnextmove(m, n, &ti, &tj, &tval, minlib)
                        &&
                        (tval > *val)   // 評価値が高ければ
                    )
                    {
                        *val = tval;    // 評価値
                        *i = ti;        // 位置i,j
                        *j = tj;
                    }
                }
            }
        }
    }

    if (*val > 0)   // 動きが見つかれば
    {
        return 1;
    }
    else    // 動きが見つからなかったら
    {
        return 0;
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「ほうほう☆!」


1:10

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「findwinr.c は、相手の石を取れる動きを探すんじゃないのかなんだぜ☆?」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// findwinr.c -- 相手の石たちを攻撃するコンピューターの次の動きを探します。
//

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤
extern unsigned char l[19][19]; // カレント色のリバーティー
extern int mymove, umove;       // コンピューターの色、相手の色
extern int lib;                 // リバーティーのカレント石

//
// 取るか、攻撃する相手のピースを探します。
//
int findwinner
                (
                    int *i,     // 次の動きの   行番号
                    int *j,     // 〃           列番号
                    int *val    // 〃           評価値
                )
{
    int m,
        n,
        ti[3],
        tj[3],
        tval,
        ct,
        u,
        v,
        lib1
        ;

    *i = -1;    // 位置i,j
    *j = -1;
    *val = -1;  // 評価値

    //
    // リバーティーが4つ未満の相手の石を探します。
    //
    for (m = 0; m < 19; m++)    // 19路盤
    {
        for (n = 0; n < 19; n++)
        {
            if (
                (p[m][n] == umove)  // 相手の石
                &&
                (l[m][n] < 4)   // リバーティーが 3以下
            )
            {
                ct = 0;
                initmark();
                if (findopen(m, n, ti, tj, umove, l[m][n], &ct))
                {
                    if (l[m][n] == 1)
                    {
                        if (*val < 120) // 評価値が 120 未満なら
                        {
                            *val = 120; // 評価値
                            *i = ti[0]; // 位置i,j
                            *j = tj[0];
                        }
                    }
                    else
                    {
                        for (u = 0; u < (int)l[m][n]; u++)
                        {
                            for (v = 0; v < (int)l[m][n]; v++)
                            {
                                if (u != v)
                                {
                                    lib = 0;
                                    countlib(ti[u], tj[u], mymove);
                                    
                                    if (lib > 0)    // 妥当な動き
                                    {
                                        lib1 = lib;
                                        p[ti[u]][tj[u]] = mymove;
                                        
                                        // look ahead opponent move
                                        lib = 0;
                                        countlib(ti[v], tj[v], umove);
                                        
                                        if
                                        (
                                            (lib1 == 1)
                                            &&
                                            (lib > 0)
                                        )
                                        {
                                            tval = 0;
                                        }
                                        else
                                        {
                                            tval = 120 - 20 * lib;
                                        }
                                            
                                        if (*val < tval)    // より高い評価値
                                        {
                                            *val = tval;    // 評価値
                                            *i = ti[u];     // 位置i,j
                                            *j = tj[u];
                                        }
                                        p[ti[u]][tj[u]] = EMPTY;
                                    }
                                }
                            }//v
                        }//u
                    }
                }
            }
        }//n
    }//m

    if (*val > 0)   // 動きを見つけた。
    {
        return 1;
    }
    else    // 勝者の動きを見つけるのには失敗した。
    {
        return 0;
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「ほうほうほう☆!」


01:24

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「19路盤の左上が 0,0 で、右下が 18,18 なのかだぜ☆?」


01:33

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「fioe.c は、指定した交点i,j が、自分の陣地かどうかを判定するんじゃないかなんだぜ☆!」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// fioe.c -- もし、カレント位置が自分の目(eye)なら、チェックします。
//

#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤
extern int mymove;              // コンピューターの色

int fioe
        (
            int i,  // 石の 行番号 0~18
            int j   // 〃   列番号 0~18
        )
{
    // 上辺を調べます。
    if (i == 0)
    {
        if (
            (j == 0)    // 列0  北西
            &&
            (
                // 北西の隅を囲む2つの石がコンピューターの色なら。
                (p[1][0] == mymove)
                &&
                (p[0][1] == mymove)
            )
        )
        {
            return 1;
        }
        if (
            (j == 18)   // 列18 北東
            &&
            (
                // 北東の隅を囲む2つの石がコンピューターの色なら。
                (p[1][18] == mymove)
                &&
                (p[0][17] == mymove)
            )
        )
        {
            return 1;
        }
        
        if
        (
            // 上辺で、3方向がコンピューターの石なら
            (p[1][j] == mymove) // コンピューターの石
            &&
            (   // 左右ともコンピューターの石
                (p[0][j - 1] == mymove)
                &&
                (p[0][j + 1] == mymove)
            )
        )
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    
    // 下辺を調べます。
    if (i == 18)
    {
        if
        (
            (j == 0)    //  列0 南西
            &&
            (
                // 南西の隅を囲む2つの石がコンピューターの色なら。
                (p[17][0] == mymove)
                &&
                (p[18][1] == mymove)
            )
        )
        {
            return 1;
        }
        
        if
        (
            (j == 18)   //  列18    南東
            &&
            (
                // 南東の隅を囲む2つの石がコンピューターの色なら。
                (p[17][18] == mymove)
                &&
                (p[18][17] == mymove)
            )
        )
        {
            return 1;
        }
        
        if
        (
            // 下辺で、3方向がコンピューターの石なら
            (p[17][j] == mymove)
            &&
            (
                (p[18][j - 1] == mymove)
                &&
                (p[18][j + 1] == mymove)
            )
        )
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    
    // 左辺を調べます。
    if (j == 0) // 列0
    {
        if
        (
            // 左辺で、3方向がコンピューターの石なら
            (p[i][1] == mymove)
            &&
            (
                (p[i - 1] [0] == mymove)
                &&
                (p[i + 1][0] == mymove)
            )
        )
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    
    // 右辺を調べます。
    if (j == 18)
    {
        if
        (
            // 右辺で、3方向がコンピューターの石なら
            (p[i][17] == mymove)
            &&
            (
                (p[i - 1] [18] == mymove)
                &&
                (p[i + 1][18] == mymove)
            )
        )
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }

    // 中央のピースを調べます。
    if (
        // 4方向がコンピューターの石なら
        (
                (p[i][j - 1] == mymove)
            &&  (p[i][j + 1] == mymove)
        )
        &&
        (
                (p[i - 1][j] == mymove)
            &&  (p[i + 1][j] == mymove)
        )
    )
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「なるほど、なるほど☆!」


01:50

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「genmove.c は、指し手生成みたいだぜ☆

緊迫していない場面では、ランダムに置くみたいだな☆ww」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// genmove.c -- コンピューターの次の動きを作ります。
//

#include <stdio.h>
#include <stdlib.h>
#include "gnugo.h"

#define MAXTRY 400

extern unsigned char p[19][19]; // 碁盤
extern int mymove, umove;       // コンピューターの色、相手の色
extern int lib;                 // カレント石のリバーティー
extern int pass;                // パスを示します

//
// コンピューターの動きを作ります。
//
void genmove    (
                    int *i,
                    int *j
                )
{
    int ti, tj, tval;
    char a;
    int ii, m, n, val;
    int try = 0;   // トライの数

    // ムーブと評価値を初期化します。
    *i = -1;
    *j = -1;
    val = -1;

    // 相手のピースズのリバーティーを再評価します。
    eval(umove);

    // 相手のピースを取ったり、攻めたりする手を探します。
    if (findwinner(&ti, &tj, &tval))
    {
        if (tval > val) // 評価値がより高ければ
        {
            val = tval; // 評価値
            *i = ti;    // 位置i,j
            *j = tj;
        }
    }

    // もし脅かされていれば、幾つかのピースを守ります。
    if (findsaver(&ti, &tj, &tval))
    {
        if (tval > val)
        {
            val = tval; // 評価値
            *i = ti;    // 位置i,j
            *j = tj;
        }
    }

    // 新しい動きのためのローカル・プレー・パターンに一致するか試します。
    if (findpatn(&ti, &tj, &tval))
    {
        if (tval > val)
        {
            val = tval; // 評価値
            *i = ti;    // 位置i,j
            *j = tj;
        }
    }

    // 緊迫していなければ、ランダムに打ちます。
    if (val < 0)
    {
        do
        {
            // 行は 0~18 でランダム。
            *i = rand() % 19;

            // 低いラインを避ける、中央の領域
            if
            (
                (*i < 2)
                ||
                (*i > 16)
                ||
                (
                    (*i > 5)
                    &&
                    (*i < 13)
                )
            )
            {
                *i = rand() % 19;
                if
                (
                    (*i < 2)
                    ||
                    (*i > 16)
                )
                {
                    *i = rand() % 19;
                }
            }

            // 列は 0~18 でランダム。
            *j = rand() % 19;

            // 低いラインを避ける、中央の領域
            if
            (
                (*j < 2)
                ||
                (*j > 16)
                ||
                (
                    (*j > 5)
                    &&
                    (*j < 13)
                )
            )
            {
                *j = rand() % 19;

                if
                (
                    (*j < 2)
                    ||
                    (*j > 16)
                )
                {
                    *j = rand() % 19;
                }
            }
            lib = 0;
            countlib(*i, *j, mymove);
        }
    }

    // 非合法手、リバーティーが1つか自殺手、自分の陣地を埋める手を避けます。
    /* avoid illegal move, liberty one or suicide, fill in own eye */
    while
    (
        (++try < MAXTRY)
        &&
        (
            (p[*i][*j] != EMPTY)
            ||
            (lib < 2)
            ||
            fioe(*i, *j)
        )
    );

    if (try >= MAXTRY)  // コンピューターはパス。
    {
        pass++;
        printf("I pass.\n");
        *i = -1;
    }
    else   // 妥当な動きを見つけます。
    {
        pass = 0;      
        printf("my move: ");
        if (*j < 8)
        {
            a = *j + 65;
        }
        else
        {
            a = *j + 66;
        }
            
        printf("%c", a);
        ii = 19 - *i;
        if (ii < 10)
        {
            printf("%1d\n", ii);
        }
        else
        {
            printf("%2d\n", ii);
        }
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「ほうほう☆!」


02:03

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「getij.c は、3文字ぐらいの文字列を、囲碁盤の行列の数字に変換するぜ☆

なんか不思議な感じ☆」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// getij.c -- 入力文字列から、行、列の番号を取得します。
//

#include "gnugo.h"

//
// 入力文字列を、i,j 座標へ変換します。
//
int getij
        (
            char move[],    // 指し手文字列
            int *i,         // 指し手の 行番号
            int *j          // 〃       列番号
        )
{
    int k;

    // 1文字目
    if
    (
        // A~H なら
        (move[0] >= 'A')
        &&
        (move[0] <= 'H')
    )
    {
        // 0~7列 に変換
        *j = move[0] - 'A';
    }
    else
    {
        if
        (
            // J~T なら
            (move[0] >= 'J')
            &&
            (move[0] <= 'T')
        )
        {
            // 8~18列 に変換
            *j = move[0] - 'B';
        }
        else
        {
            // a~h なら
            if ((move[0] >= 'a') && (move[0] <= 'h'))
            {
                // 0~7列 に変換
                *j = move[0] - 'a';
            }
            else
            {
                // j~t なら
                if ((move[0] >= 'j') && (move[0] <= 't'))
                {
                    // 8~18列に変換
                    *j = move[0] - 'b';
                }
                else
                {
                    return 0;
                }
            }
        }
    }

    // 2文字目は、段に使う
    k = move[1] - '0';
    
    // 3文字目は段
    if (move[2])
    {
        k = k * 10 + move[2] - '0';
    }
    *i = 19 - k;
    
    if ((*i >= 0) && (*i <= 18))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「囲碁の棋譜ってどんなだぜ☆?ww」


02:19

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「getmove.c は、人間のコマンドライン入力に対応しているんじゃ

ないかなんだぜ☆?」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// getmove.c -- 相手の入力コマンドを取得します。
//

#include <stdio.h>
#include <string.h>
#include "gnugo.h"

extern unsigned char p[19][19]; // 碁盤
extern int mymove, umove;       // コンピューターの色、相手の色
extern int play;                // ゲームの状態
extern int pass;                // パスを示します
extern int mk, uk;              // 取ったピース
extern int opn[9];              // 序盤の動きを示します

//
// 盤の位置へ動かす人間の反応を同時翻訳します。
//
void getmove
            (
                char move[],    // 指し手文字列
                int *i,         // 次の手の 行番号
                int *j          // 〃       列番号
            )
{
    FILE *fp;   // セーブ・ファイル
    int m,  // 行
        n   // 列
        ;

    if (strcmp(move, "stop") == 0)  // ゲームを終了します。
    {
        play = 0;
    }
    else
    {
        if (strcmp(move, "save") == 0)  // データを保存して、ゲームを終了します。
        {
            fp = fopen("gnugo.dat", "w");   // 盤設定を保存します。

            for (m = 0; m < 19; m++)// 19路盤
            {
                for (n = 0; n < 19; n++)
                {
                    fprintf(fp, "%c", p[m][n]);
                }
            }

            // コンピューターの色、お互いの取ったピース
            fprintf(fp, "%d %d %d ", mymove, mk, uk);
            
            // 序盤定跡フラグ
            for (m = 0; m < 9; m++)
            {
                fprintf(fp, "%d ", opn[m]);
            }

            fclose(fp);
            play = -1;
        }
        else
        {
            if (strcmp(move, "pass") == 0)  // 人間のパス
            {
                pass++;
                *i = -1;    // パスのシグナル
            }
            else
            {
                pass = 0;
                // move[0] from A~T
                // move[1] move[2] from 1~19
                // 指し手を座標に変換します。
                if (
                    !getij(move, i, j)
                    ||
                    (p[*i][*j] != EMPTY)
                    ||
                    suicide(*i, *j)
                )
                {
                    printf("illegal move !\n");
                    printf("your move? ");
                    scanf("%s", move);
                    getmove(move, i, j);
                }
            }
        }
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「CUIアプリケーションだったのかだぜ☆ww」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「だな☆」


02:24

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「gnugo.h は、C言語らしい、ヘッダーファイルだぜ☆ww」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// gnugo.h -- GNUの碁のコモン・ヘッダー
//

// 定義
#define EMPTY 0
#define WHITE 1
#define BLACK 2

// public 関数
extern void count(
                    int i,
                    int j,
                    int color
                 );

extern void countlib(
                        int m,
                        int n,
                        int color
                    );

extern void endgame(void);

extern void eval(
                    int color
                );

extern void examboard(
                        int color
                     );

extern int getij(
                    char move[],
                    int *i,
                    int *j
                );

extern unsigned int findcolor(
                                int i,
                                int j
                             );

extern int findnextmove(
                        int m,
                        int n,
                        int *i,
                        int *j,
                        int *val,
                        int minlib
                       );

extern int findopen(
                    int m,
                    int n,
                    int i[],
                    int j[],
                    int color,
                    int minlib,
                    int *ct
                   );

extern int findpatn(
                    int *i,
                    int *j,
                    int *val
                   );

extern int findsaver(
                        int *i,
                        int *j,
                        int *val
                    );

extern int findwinner(
                        int *i,
                        int *j,
                        int *val
                     );

extern int fioe(
                    int i,
                    int j
               );

extern void genmove(
                    int *i,
                    int *j
                   );

extern void getmove(
                    char move[],
                    int *i,
                    int *j
                   );

extern void initmark(void);

extern int matchpat(
                    int m,
                    int n,
                    int *i,
                    int *j,
                    int *val
                   );

extern int opening(
                    int *i,
                    int *j,
                    int *cnd,
                    int type
                  );

extern int openregion(
                        int i1,
                        int j1,
                        int i2,
                        int j2
                     );

extern void showboard(void);

extern void showinst(void);

extern void sethand(
                    int i
                   );

extern int suicide(
                    int i,
                    int j
                  );

UEUESHIMA_Komado_80x80x8_02_nitaari

「ほうほう☆」


02:29

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「initmark.c は、碁盤をピクロスみたいにチェックしていく表があって、

それを まっさら にクリアーする関数だぜ☆」

/*
                 GNUGO - the game of Go (Wei-Chi)
                Version 1.2   last revised 10-31-95
           Copyright (C) Free Software Foundation, Inc.
                      written by Man L. Li
                      modified by Wayne Iba
        modified by Frank Pursel <fpp%minor.UUCP@dragon.com>
                    documented by Bob Webber
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation - version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License in file COPYING for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Please report any bug/fix, modification, suggestion to

           manli@cs.uh.edu
*/
//
// initmark.c -- 作業用行列を初期化します。
//

#include "gnugo.h"

extern unsigned char ma[19][19];    // マーキング用の作業用行列

//
// 全てのマークを 0 で初期化します。
//
void initmark(void)
{
    int i, j;

    for (i = 0; i < 19; i++)
    {
        for (j = 0; j < 19; j++)
        {
            ma[i][j] = 0;
        }
    }
}

UEUESHIMA_Komado_80x80x8_02_nitaari

「ほうほう☆ww」

KITASHIRAKAWA_Chiyuri_80x100x8_01_Futu

「ちょっと、記事が長くなったので、次の記事に移るぜ☆」

KIFUWARABE_80x100x8

「おう☆!」


ソースコードを どんどん読んでいるぜ☆! CUI だったんだな☆www

第9回UEC杯コンピュータ囲碁大会に向けて、微速微進、遅々前進なんだぜ☆!

はてなブックマーク - 【囲碁】きふわらべがポナンザを倒す☆!目指せ第9回UEC杯コンピュータ囲碁大会(3) ぽつぽつ、ソースコードを読んでいくんだぜ☆
[`yahoo` not found]
[`yahoo_buzz` not found]
このエントリーを Google ブックマーク に追加
Digg にシェア
Facebook にシェア
reddit にシェア
LinkedIn にシェア
[`evernote` not found]
StumbleUpon にシェア
GREE にシェア
email this
LINEで送る
Pocket