def temp_process(hai_id, janshi, yama, taku, shanten_suu, itr):
#def temp_process(temp_list):
global hash_table
#temp_list = y()
#print(time.time())
#global pure_point_sum, sum_list
#start = time.time()
#hai_id = temp_list[0]
#janshi = temp_list[1]
#yama = temp_list[2]
#taku = temp_list[3]
#shanten_suu = temp_list[4]
#itr = temp_list[5]
taku.hash_table = hash_table
itr = 50
print(hai_id)
#print(str(time.time()-start))
print(itr)
for j in range(itr):
count = 1.0
temp_janshi = copy.deepcopy(janshi)
temp_yama = yama.copy()
temp_janshi.tehai.remove(function.hai_convert_reverse(
hai_id)) # = function.tehai_convert_reverse(temp_tehai)
temp_janshi.sutehai.append(function.hai_convert_reverse(hai_id))
if j == 0:
init_shanten_suu = shanten_check_new.shanten_check(
temp_janshi, taku.hash_table)
a, b = yuukouhai_explore(temp_yama, init_shanten_suu, count,
taku.hash_table, temp_janshi, taku)
def temp_process(temp_list):
global pure_point_sum, sum_list
#print("bbbbbbbbbbbbbbbbbbbbbbb")
hai_id = temp_list[0]
janshi = temp_list[1]
yama = temp_list[2]
taku = temp_list[3]
shanten_suu = temp_list[4]
itr = temp_list[5]
for j in range(itr):
count = 1.0
temp_janshi = copy.deepcopy(janshi)
temp_yama = yama.copy()
temp_janshi.tehai.remove(function.hai_convert_reverse(
hai_id)) # = function.tehai_convert_reverse(temp_tehai)
temp_janshi.sutehai.append(function.hai_convert_reverse(hai_id))
if j == 0:
init_shanten_suu = shanten_check_new.shanten_check(
temp_janshi, taku.hash_table)
a, b = yuukouhai_explore(temp_yama, init_shanten_suu, count,
taku.hash_table, temp_janshi, taku)
sum_list[hai_id] += a
pure_point_sum[hai_id] += b
#shanten_suu + 1で平均打点を割る
pure_point_sum[hai_id] /= max(init_shanten_suu + 1, 1) * itr
def yuukouhai_explore(yama, shanten_suu, count, hash_table, janshi, taku):
nokori_tsumo_kaisuu = int(taku.yama_nokori / 4) + 1
yuukouhai_boost = 1.45
shanten_const = np.sum(yama) / nokori_tsumo_kaisuu * 10
yuukouhai_list = find_yuukouhai(janshi, shanten_suu, hash_table)
yuukouhai_prob_list = create_yuukouhai_prob_list(yuukouhai_list, yama)
#yuukouhai_prob_listの要素がない場合
if len(yuukouhai_prob_list) == 0:
yuukouhai_prob_list = yuukouhai_list
index = random.choice(yuukouhai_prob_list)
janshi.tehai.append(function.hai_convert_reverse(index))
yuukouhai_num = 0.001
for i in yuukouhai_list:
yuukouhai_num += yama[i]
#ツモって来る牌が自身の捨て牌にあれば補正
if function.hai_convert_reverse(index) in janshi.sutehai:
furiten_hosei = 0.25
else:
furiten_hosei = 1.0
#テンパイ時に待ち牌に対してブーストを行う
if shanten_suu == 0:
count *= yuukouhai_num**(
yuukouhai_boost) / shanten_const * furiten_hosei
else:
count *= yuukouhai_num / shanten_const * furiten_hosei
yama[index] -= 1
shanten_suu -= 1
if shanten_suu == -1:
agarihai_str = function.hai_convert_reverse(index)
#tehai_str = function.tehai_convert_reverse(tehai)
##temp_janshi = copy.deepcopy(janshi)
#temp_janshi.tehai = tehai_str
#print(tehai_str)
#print(temp_janshi.fuurohai)
#print(count)
point_temp = tensu_calc.tensu_calc(janshi, taku, agarihai_str)
if len(point_temp) == 0:
point = 0
elif point_temp[0] == point_temp[1]:
point = point_temp[0] * 3
else:
point = point_temp[0] * 2 + point_temp[1]
#print(point)
return count * point
#return count*teyaku_check.teyaku_check(janshi, taku, agarihai_str)[0]
yuukou_sutehai_index_list = find_yuukou_sutehai(janshi, shanten_suu,
hash_table)
index2 = random.choice(yuukou_sutehai_index_list)
janshi.tehai.remove(function.hai_convert_reverse(index2))
return yuukouhai_explore(yama, shanten_suu, count, hash_table, janshi,
taku)
def yuukouhai_explore(yama, shanten_suu, count, hash_table, janshi, taku , janshi_list, bakyou_list, danger_degree_list):
nokori_tsumo_kaisuu = int(taku.yama_nokori/4)+1
yuukouhai_boost = 1.45
shanten_const = np.sum(yama) / nokori_tsumo_kaisuu * 10
yuukouhai_list = find_yuukouhai(janshi, shanten_suu, hash_table)
yuukouhai_prob_list = create_yuukouhai_prob_list(yuukouhai_list, yama)
#yuukouhai_prob_listの要素がない場合
if len(yuukouhai_prob_list) == 0:
yuukouhai_prob_list = yuukouhai_list
index = random.choice(yuukouhai_prob_list)
janshi.tehai.append(function.hai_convert_reverse(index))
yuukouhai_num = 0.001
for i in yuukouhai_list:
yuukouhai_num += yama[i]
#ツモって来る牌が自身の捨て牌にあれば補正
if function.hai_convert_reverse(index) in janshi.sutehai:
furiten_hosei = 0.25
else:
furiten_hosei = 1.0
#テンパイ時に待ち牌に対してブーストを行う
if shanten_suu == 0:
count *= yuukouhai_num**(yuukouhai_boost)/shanten_const/danger_degree_list[function.akadora_hai_convert2(index)]*furiten_hosei
#print(yuukouhai_num)
#print(np.sum(yama))
else:
count *= yuukouhai_num/shanten_const/danger_degree_list[function.akadora_hai_convert2(index)]*furiten_hosei
yama[index] -= 1
shanten_suu -= 1
if shanten_suu == -1:
agarihai_str = function.hai_convert_reverse(index)
#ロンアガリを想定（三暗刻防止）
del janshi.tehai[-1]
point_temp = tensu_calc.tensu_calc(janshi, taku, agarihai_str)
if len(point_temp) == 0:
point = 0
else:
point = point_temp[0]
#print(point)
#print(count*point)
if point > 0:
#条件判断用
fixed_point = point + taku.kyoutaku_tensuu + taku.kaze_honba[1] * 300.0
else:
fixed_point = point
return count * point, fixed_point, point
yuukou_sutehai_index_list = find_yuukou_sutehai(janshi, shanten_suu, hash_table)
index2 = random.choice(yuukou_sutehai_index_list)
janshi.tehai.remove(function.hai_convert_reverse(index2))
return yuukouhai_explore(yama, shanten_suu, count, hash_table, janshi, taku, janshi_list, bakyou_list, danger_degree_list)
def renew_vertual_yama_pon(self, hai_str, janshi_pon):
hai_index = function.hai_convert(hai_str)
#hai_strが5でjanshi_ponのfuuro_akadora_list[-1]がTrueなら赤ドラを追加
if hai_index % 10 == 5 and janshi_pon.fuuro_akadora_list[-1]:
self.vertual_yama.remove(hai_str)
self.vertual_yama.remove(
function.hai_convert_reverse(hai_index - 5))
#赤5が鳴かれたとき
elif hai_index % 10 == 0:
self.vertual_yama.remove(
function.hai_convert_reverse(hai_index + 5))
self.vertual_yama.remove(
function.hai_convert_reverse(hai_index + 5))
else:
self.vertual_yama.remove(hai_str)
self.vertual_yama.remove(hai_str)
def new_yuukouhai_explore(shanten_suu, janshi, taku):
hash_table = taku.hash_table
tehai = np.array(function.tehai_convert(janshi.tehai))
#ツモって来る牌に赤ドラは考慮しない
yama = np.array(
function.tehai_convert(
function.akadora_convert(janshi.vertual_yama)[0]))
init_shanten_suu = shanten_suu
#index_list = [0]*len(tehai)
sum_list = [0] * len(tehai)
#mean_list = [0]*len(tehai)
hai_list = find_yuukou_sutehai(janshi, init_shanten_suu, hash_table)
#print(hai_list)
#副露した時でアガリ役なしの場合
if len(hai_list) == 0:
return random.choice(range(len(janshi.tehai))), 0
#バグ防止用
for i in hai_list:
sum_list[i] += 0.001
#print(hai_list)
itr = 25
for i in hai_list:
for j in range(itr):
count = 1.
temp_janshi = copy.deepcopy(janshi)
temp_tehai = tehai.copy()
temp_yama = yama.copy()
temp_tehai[i] -= 1
temp_janshi.tehai = function.tehai_convert_reverse(temp_tehai)
a = yuukouhai_explore(temp_yama, init_shanten_suu, count,
hash_table, temp_janshi, taku)
#index_list[i] += 1
sum_list[i] += a
sum_list[i] /= float(itr)
#for i in range(len(tehai)):
# mean_list[i] = sum_list[i]/float(itr)
maximum_index_num = -1
#print(janshi.tehai)
#print(np.round(sum_list,2))
maximum_expect = np.max(sum_list)
return_hai_str = function.hai_convert_reverse(np.argmax(sum_list))
#print(return_hai_str)
for i in range(len(janshi.tehai)):
if janshi.tehai[i] == return_hai_str:
maximum_index_num = i
break
#print(maximum_index_num)
assert maximum_index_num >= 0
return maximum_index_num, maximum_expect
def renew_vertual_yama_ankan(self, hai_str):
hai_index = function.hai_convert(hai_str)
if hai_index % 10 == 5 and hai_index < 30:
aka_hai_str = function.hai_convert_reverse(hai_index - 5)
self.vertual_yama.remove(aka_hai_str)
self.vertual_yama.remove(hai_str)
self.vertual_yama.remove(hai_str)
self.vertual_yama.remove(hai_str)
else:
self.vertual_yama.remove(hai_str)
self.vertual_yama.remove(hai_str)
self.vertual_yama.remove(hai_str)
self.vertual_yama.remove(hai_str)
def yuukouhai_explore(yama, shanten_suu, count, hash_table, janshi, taku):
yuukouhai_boost = 1.45
yuukouhai_list = find_yuukouhai(janshi, shanten_suu, hash_table)
yuukouhai_prob_list = create_yuukouhai_prob_list(yuukouhai_list, yama)
#yuukouhai_prob_listの要素がない場合
if len(yuukouhai_prob_list) == 0:
yuukouhai_prob_list = yuukouhai_list
index = random.choice(yuukouhai_prob_list)
tehai = function.tehai_convert(janshi.tehai)
tehai[index] += 1
yuukouhai_num = 0
for i in yuukouhai_list:
yuukouhai_num += yama[i]
#テンパイ時に待ち牌に対してブーストを行う
if shanten_suu == 0:
count *= yuukouhai_num**(yuukouhai_boost)/len(yama)
else:
count *= yuukouhai_num/len(yama)
yama[index] -= 1
shanten_suu -= 1
if shanten_suu == -1:
agarihai_str = function.hai_convert_reverse(index)
tehai_str = function.tehai_convert_reverse(tehai)
temp_janshi = copy.deepcopy(janshi)
temp_janshi.tehai = tehai_str
point_temp = tensu_calc.tensu_calc(temp_janshi, taku, agarihai_str)
if len(point_temp) == 0:
point = 0
elif point_temp[0] == point_temp[1]:
point = point_temp[0]*3
else:
point = point_temp[0] * 2 + point_temp[1]
return count * point
temp_janshi2 = copy.deepcopy(janshi)
temp_tehai = tehai.copy()
temp_janshi2.tehai = function.tehai_convert_reverse(temp_tehai)
yuukou_sutehai_index_list = find_yuukou_sutehai(temp_janshi2, shanten_suu, hash_table)
index2 = random.choice(yuukou_sutehai_index_list)
tehai[index2] -= 1
temp_tehai = tehai.copy()
temp_janshi2.tehai = function.tehai_convert_reverse(temp_tehai)
return yuukouhai_explore(yama, shanten_suu, count, hash_table, temp_janshi2, taku)
def new_yuukouhai_explore(shanten_suu, janshi, taku, kuikae_list):
hash_table = taku.hash_table
tehai = np.array(function.tehai_convert(janshi.tehai))
yama = np.array(function.tehai_convert(function.akadora_convert(janshi.vertual_yama)[0]))
init_shanten_suu = shanten_suu
sum_list = [0]*len(tehai)
hai_list = find_yuukou_sutehai(janshi, init_shanten_suu, hash_table)
#hai_listからkuikae_listを削除
temp_hai_list = hai_list.copy()
for i in range(len(hai_list)):
if temp_hai_list[i] in kuikae_list:
hai_list.remove(temp_hai_list)
#副露した時でアガリ役なしの場合
if len(hai_list) == 0:
return random.choice(range(len(janshi.tehai))), 0
#バグ防止用
for i in hai_list:
sum_list[i] += 0.001
itr = 25
for j in range(itr):
count = 1.
for i in hai_list:
temp_janshi = copy.deepcopy(janshi)
temp_tehai = tehai.copy()
temp_yama = yama.copy()
temp_tehai[i] -= 1
temp_janshi.tehai = function.tehai_convert_reverse(temp_tehai)
a = yuukouhai_explore(temp_yama, init_shanten_suu, count, hash_table, temp_janshi, taku)
sum_list[i] += a
maximum_index_num = -1
maximum_expect = np.max(sum_list)
return_hai_str = function.hai_convert_reverse(np.argmax(sum_list))
for i in range(len(janshi.tehai)):
if janshi.tehai[i] == return_hai_str:
maximum_index_num = i
break
assert maximum_index_num >= 0
return maximum_index_num, maximum_expect
]
taku.dorahyouji = ["1m"]
janshi.tehai = input_data
input_str = []
input_str.extend(
function.tehai_convert_binary(function.tehai_convert(janshi.tehai)))
input_str.extend(
function.bin_convert(function.tehai_convert(taku.dorahyouji)[0], 5))
input_str.extend(function.bin_convert(janshi.kaze, 2))
input_str.extend(function.bin_convert(taku.kaze_honba[0], 3))
input_str = input_string_convert(input_str)
print(input_str)
#2→41 3→124 4→データ型改善
main_nn = N_network(124, 38)
main_nn.model.load_weights("v1.hdf5")
x = convert(input_str)
x = np.array(x)
y = x.reshape(1, 124) #重要
print("input")
print(y)
result = main_nn.model.predict(y)
print("result")
print(result)
print("AI 打：" + function.hai_convert_reverse(np.argmax(result)))
def new_yuukouhai_explore(shanten_suu, janshi, taku):
#print("aaaaaaaaaaaaaaaaaaaaa")
global sum_list, pure_point_sum
global janshi_global, yama_global, taku_global, shanten_suu_global, itr_global
hash_table = taku.hash_table
tehai = np.array(function.tehai_convert(janshi.tehai))
#ツモって来る牌に赤ドラは考慮しない
yama = np.array(
function.tehai_convert(
function.akadora_convert(janshi.vertual_yama)[0]))
init_shanten_suu = shanten_suu
#index_list = [0]*len(tehai)
sum_list = [0] * len(tehai)
pure_point_sum = [0] * len(tehai)
print(len(sum_list))
#mean_list = [0]*len(tehai)
if shanten_suu >= 2:
hai_list = find_yuukou_sutehai(janshi, init_shanten_suu, hash_table)
#テンパイならシャンテン戻しも考える
else:
hai_list = function.tehai_convert3(janshi.tehai)
#print(hai_list)
#副露した時でアガリ役なしの場合
if len(hai_list) == 0:
#print("no_hai_list_error")
return [0.001] * len(janshi.tehai), [0.001] * len(
janshi.tehai), [0.001] * len(janshi.tehai)
#バグ防止用
for i in hai_list:
sum_list[i] += 0.001
#print(hai_list)
if init_shanten_suu >= 2:
itr = 25
elif init_shanten_suu == 1:
itr = 20
else:
itr = 15
itr_global = itr
janshi_global = janshi
yama_global = yama
taku_global = taku
taku.hash_table = None
shanten_suu_global = shanten_suu
temp_list = [[hai_id, janshi, yama, taku, shanten_suu, itr]
for hai_id in reversed(hai_list)]
p = Pool(multi.cpu_count())
print(multi.cpu_count())
print(hai_list)
#print(time.time())
p.starmap(temp_process, temp_list)
#p.map(test_process, hai_list)
p.close()
taku.hash_table = hash_table
for i in hai_list:
print(i)
for j in range(itr):
count = 1.0
temp_janshi = copy.deepcopy(janshi)
#temp_tehai = tehai.copy()
temp_yama = yama.copy()
#temp_tehai[i] -= 1
temp_janshi.tehai.remove(function.hai_convert_reverse(
i)) # = function.tehai_convert_reverse(temp_tehai)
temp_janshi.sutehai.append(function.hai_convert_reverse(i))
if j == 0:
init_shanten_suu = shanten_check_new.shanten_check(
temp_janshi, taku.hash_table)
a, b = yuukouhai_explore(temp_yama, init_shanten_suu, count,
hash_table, temp_janshi, taku)
#index_list[i] += 1
sum_list[i] += a
pure_point_sum[i] += b
#shanten_suu + 1で平均打点を割る
pure_point_sum[i] /= max(init_shanten_suu + 1, 1) * itr
def new_yuukouhai_explore(shanten_suu, janshi, taku, kuikae_list, top4_list, janshi_list, bakyou_list):
hash_table = taku.hash_table
tehai = np.array(function.tehai_convert(janshi.tehai))
danger_degree_list = danger_degree.create_danger_degree_list(janshi_list, taku, bakyou_list)
#print(danger_degree_list)
#ツモって来る牌に赤ドラは考慮しない
yama = np.array(function.tehai_convert(function.akadora_convert(janshi.vertual_yama)[0]))
init_shanten_suu = shanten_suu
#index_list = [0]*len(tehai)
sum_list = [0]*len(tehai)
pure_point_sum = [0]*len(tehai)
pure_pure_point_sum = [0]*len(tehai)
max_point = [0]*len(tehai)
#mean_list = [0]*len(tehai)
if init_shanten_suu >= 2:
hai_list = top4_list
else:
hai_list = find_yuukou_sutehai(janshi, init_shanten_suu, hash_table)
#print(hai_list)
#hai_listからkuikae_listを削除
temp_hai_list = hai_list.copy()
for i in range(len(hai_list)):
if temp_hai_list[i] in kuikae_list:
hai_list.remove(temp_hai_list[i])
#副露した時でアガリ役なしの場合
if len(hai_list) == 0:
#print("no_hai_list_error")
return [0.001]*len(janshi.tehai), [0.001]*len(janshi.tehai), [0.001]*len(janshi.tehai), [0.001]*len(janshi.tehai), [0.001]*len(janshi.tehai), [0.001]*len(janshi.tehai)
#バグ防止用
for i in hai_list:
sum_list[i] += 0.001
#print(hai_list)
if init_shanten_suu >= 2:
itr = 20
else:
itr = 25
for i in hai_list:
for j in range(itr):
count = 1.
temp_janshi = copy.deepcopy(janshi)
temp_yama = yama.copy()
temp_janshi.tehai.remove(function.hai_convert_reverse(i))
temp_janshi.sutehai.append(function.hai_convert_reverse(i))
#評価用の修正されたpoint, 普通の点数
a, b, c = yuukouhai_explore(temp_yama, init_shanten_suu, count, hash_table, temp_janshi, taku , janshi_list, bakyou_list, danger_degree_list)
#オーラス用max_pointの更新など
if b > max_point[i]:
max_point[i] = b
pure_point_sum[i] += b
pure_pure_point_sum[i] += c
#index_list[i] += 1
sum_list[i] += a
pure_pure_point_sum[i] /= max(init_shanten_suu + 1, 1)*itr
normalized_index_list = np.array(sum_list)/np.sum(np.array(sum_list))
normalized_list = np.zeros(len(janshi.tehai))
sum_list_for_tehai_str = np.zeros(len(janshi.tehai))
pure_point_mean = np.array(pure_point_sum)/float(itr)
max_point_list = np.zeros(len(janshi.tehai))
pure_point_mean_list = np.zeros(len(janshi.tehai))
pure_point_sum_for_tehai_str = np.zeros(len(janshi.tehai))
for i in range(len(janshi.tehai)):
normalized_list[i] = normalized_index_list[function.hai_convert(janshi.tehai[i])]
sum_list_for_tehai_str[i] = sum_list[function.hai_convert(janshi.tehai[i])]
max_point_list[i] = max_point[function.hai_convert(janshi.tehai[i])]
pure_point_mean_list[i] = pure_point_mean[function.hai_convert(janshi.tehai[i])]
pure_point_sum_for_tehai_str[i] = pure_pure_point_sum[function.hai_convert(janshi.tehai[i])]
mean_list_for_tehai_str = sum_list_for_tehai_str/float(itr)
return normalized_list, sum_list_for_tehai_str, mean_list_for_tehai_str, max_point_list, pure_point_mean_list, pure_point_sum_for_tehai_str
def jicha_tsumo(janshi, taku, splitted_read_text):
output = ""
start = time.time()
taku.yama_nokori -= 1
hai_136 = int(splitted_read_text[1].strip("T"))
#print(hai_136)
print("ツモ牌:" + function_tenhou.hai_convert_136_to_str(hai_136))
print("残りツモ回数:" + str(int(taku.yama_nokori / 4)) + "回")
hai_str = function_tenhou.hai_convert_136_to_str(hai_136)
janshi[0].tsumo(hai_str, hai_136)
print(janshi[0].tehai)
print("シャンテン数: " +
str(shanten_check_new.shanten_check(janshi[0], taku.hash_table)))
#暗槓&カカン
temp_ankan = janshi[0].ankan(taku)
if temp_ankan != -1:
print("AI 暗槓: " + function.hai_convert_reverse(temp_ankan))
output = function.hai_convert_reverse(temp_ankan)
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Kan", output)
return None
temp_kakan = janshi[0].kakan(taku)
if temp_kakan[0] != -1:
print("AI 加槓: " + function.hai_convert_reverse(temp_kakan[1]))
if temp_kakan[2]:
output = function.hai_convert_reverse(temp_kakan[1] - 5)
else:
output = function.hai_convert_reverse(temp_kakan[1])
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Kan", output)
return None
#ツモアガリか立直
if len(splitted_read_text) > 2:
#ツモアガリ
if splitted_read_text[3] == "64":
if shanten_check_new.shanten_check(janshi[0],
taku.hash_table) >= 3:
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
print("AI 九種九牌流局")
gui_click("Kyuusyu")
return None
if splitted_read_text[3] == "16" or splitted_read_text[
3] == "48" or splitted_read_text[3] == "112":
#とりあえずツモアガリする
print("AI ツモアガリ")
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Agari")
return None
#立直
if splitted_read_text[3] == "32":
#a→点数がthreshに届いてるか, b→立直時or保留時の打牌index, c→保留するかどうか
a, b, c = riichi_hantei3.riichi_hantei(janshi[0], taku)
#オーラスなら条件考慮
if taku.bakyou_list[0]:
hai_str = function.hai_convert_reverse(b)
#アガリ点の平均値
dama_point = function.dama_hantei(janshi[0], taku, hai_str)
if a:
#全ての待ち牌に対してダマでロンアガリできる
if dama_point:
if taku.bakyou_list[0] == 1 or taku.bakyou_list[0] == 3:
print("AI ダマテン")
print("AI 打:" + hai_str)
output = hai_str
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Dahai", output)
janshi[0].riipai()
return None
else:
#ダマでは点数が足りない
if taku.bakyou_list[1] > dama_point:
print("AI リーチ")
taku.riichi_dahai = hai_str
print("AI 打:" + taku.riichi_dahai)
#天鳳に出力
if time.time(
) - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Riichi")
janshi[0].riipai()
return None
#ダマでも点数が足りる
else:
print("AI ダマテン")
print("AI 打:" + hai_str)
output = hai_str
if time.time(
) - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Dahai", output)
janshi[0].riipai()
return None
#ダマでロンアガリできない待ち牌がある
else:
print("AI リーチ")
taku.riichi_dahai = hai_str
print("AI 打:" + taku.riichi_dahai)
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Riichi")
janshi[0].riipai()
return None
elif c:
print("AI リーチ保留")
temp_index = 0
print("AI 打:" + hai_str)
output = hai_str
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Dahai", output)
janshi[0].riipai()
return None
#threshに足りてない(aとほぼ同じ。ラスの時だけ立直)
else:
pass
#全ての待ち牌に対してダマでロンアガリできる
if dama_point:
if taku.bakyou_list[0] == 1 or taku.bakyou_list[0] == 3:
print("AI ダマテン")
print("AI 打:" + hai_str)
output = hai_str
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Dahai", output)
janshi[0].riipai()
return None
else:
#ダマでは点数が足りない
if taku.bakyou_list[1] > dama_point:
print("AI リーチ")
taku.riichi_dahai = hai_str
print("AI 打:" + taku.riichi_dahai)
#天鳳に出力
if time.time(
) - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Riichi")
janshi[0].riipai()
return None
#ダマでも点数が足りる
else:
print("AI ダマテン")
print("AI 打:" + hai_str)
output = hai_str
if time.time(
) - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Dahai", output)
janshi[0].riipai()
return None
#ダマでロンアガリできない待ち牌がある
else:
#ラスの時だけ立直
if taku.bakyou_list[0] == 4:
print("AI リーチ")
taku.riichi_dahai = hai_str
print("AI 打:" + taku.riichi_dahai)
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Riichi")
janshi[0].riipai()
return None
#オーラス以外
else:
if a:
print("AI リーチ")
b_str = function.hai_convert_reverse(b)
temp_index = 0
for j in range(len(janshi[0].tehai)):
if b_str == janshi[0].tehai[j]:
temp_index = j
break
taku.riichi_dahai = janshi[0].tehai[temp_index]
print("AI 打:" + taku.riichi_dahai)
#janshi[0].func_riichi(taku)
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Riichi")
janshi[0].riipai()
return None
elif c:
print("AI リーチ保留")
b_str = function.hai_convert_reverse(b)
temp_index = 0
for j in range(len(janshi[0].tehai)):
if b_str == janshi[0].tehai[j]:
temp_index = j
break
print("AI 打:" + b_str)
output = b_str
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Dahai", output)
janshi[0].riipai()
return None
#ツモアガリも立直もしない時
max_index = int(janshi[0].dahai(taku, janshi, taku.bakyou_list))
hai_str = janshi[0].tehai[max_index]
print("AI 打:" + hai_str)
#天鳳に出力 立直時はしない
if not janshi[0].riichi:
output = hai_str
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Dahai", output)
janshi[0].riipai()
def tacha_dahai(key, janshi, taku, splitted_read_text):
output2 = ["", ""]
start = time.time()
hai_136 = int(splitted_read_text[1].strip(key))
hai_str = function_tenhou.hai_convert_136_to_str(hai_136)
janshi[0].vertual_yama.remove(hai_str)
janshi[key_to_index[key]].sutehai.append(hai_str)
janshi[key_to_index[key]].tedashi_flag.append(key.isupper) #keyが大文字なら手出し
janshi[key_to_index[key]].temp_genbutsu = []
for k in range(1, 4):
janshi[k].temp_genbutsu.append(hai_str)
print(key_to_char[key] + " 打:" + hai_str)
taku.last_dahai = hai_136 #直前の打牌。鳴きに利用する。
taku.last_teban = key_to_index[key] #直前の打牌をしたプレイヤー
#以下鳴き 鳴きの基本方針→赤ドラを副露牌に含められるときは必ず含める
if len(splitted_read_text) > 2:
#ロン通知
if int(splitted_read_text[3]) >= 8:
#あがる
print("AI ロン")
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Agari")
return None
#ポン通知
elif splitted_read_text[3] == "1" or splitted_read_text[3] == "3":
#ポン打診
pon_index = janshi[0].pon(taku, hai_str, janshi, taku.bakyou_list)
if pon_index[0]:
print("AI ポン")
#ポンする
#ポンする牌のindex
pon_hai_index = function_tenhou.hai_convert_136_to_index(
taku.last_dahai)
#赤なら普通の5に書き換え
if pon_hai_index % 10 == 0:
pon_hai_index += 5
#もし赤じゃない5をポンするなら
if pon_hai_index % 10 == 5 and pon_hai_index < 30:
tehai_index = function.tehai_convert(janshi[0].tehai)
#もし同じ色の赤を持っていたら
if tehai_index[pon_hai_index - 5] == 1:
output2 = [
function.hai_convert_reverse(pon_hai_index - 5),
function.hai_convert_reverse(pon_hai_index)
]
else:
output2 = [
function.hai_convert_reverse(pon_hai_index),
function.hai_convert_reverse(pon_hai_index)
]
else:
output2 = [
function.hai_convert_reverse(pon_hai_index),
function.hai_convert_reverse(pon_hai_index)
]
#print("ポンする牌:" + output2)
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
print(output2)
gui_click("Pon_Chii", output2)
#打牌時の情報を追加
taku.naki_dahai = pon_index[1]
print("AI 打:" + taku.naki_dahai)
return None
else:
#鳴かない
print("AI スルー")
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Cancel")
return None
#チー通知
elif splitted_read_text[3] == "4":
#チー打診
chii_index = janshi[0].chii(taku, hai_str, janshi,
taku.bakyou_list)
if chii_index[0] != -1:
print("AI チー: index = " + str(chii_index[0]))
#チーする
#チーする牌のindex
chii_hai_index = function_tenhou.hai_convert_136_to_index(
taku.last_dahai)
#赤をチー
if chii_hai_index % 10 == 0:
chii_hai_index += 5
if chii_index[0] == 0:
output2[0] = function.hai_convert_reverse(
chii_hai_index - 2)
output2[1] = function.hai_convert_reverse(
chii_hai_index - 1)
elif chii_index[0] == 1:
output2[0] = function.hai_convert_reverse(
chii_hai_index - 1)
output2[1] = function.hai_convert_reverse(
chii_hai_index + 1)
else: # chii_index[0] == 2:
output2[0] = function.hai_convert_reverse(
chii_hai_index + 1)
output2[1] = function.hai_convert_reverse(
chii_hai_index + 2)
#赤以外をチー
else:
if chii_index[0] == 0:
output2[0] = function.hai_convert_reverse(
chii_hai_index - 2)
output2[1] = function.hai_convert_reverse(
chii_hai_index - 1)
elif chii_index[0] == 1:
output2[0] = function.hai_convert_reverse(
chii_hai_index - 1)
output2[1] = function.hai_convert_reverse(
chii_hai_index + 1)
else: # chii_index[0] == 2:
output2[0] = function.hai_convert_reverse(
chii_hai_index + 1)
output2[1] = function.hai_convert_reverse(
chii_hai_index + 2)
#赤の書き換え
if chii_index[2]:
for j in range(2):
if output2[j] == "5m":
output2[j] = "5M"
elif output2[j] == "5p":
output2[j] = "5P"
elif output2[j] == "5s":
output2[j] = "5S"
#天鳳に出力
print(output2)
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Pon_Chii", output2)
#打牌時の情報を追加
taku.naki_dahai = chii_index[1]
print("AI 打:" + taku.naki_dahai)
return None
else:
#鳴かない
print("AI スルー")
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Cancel")
return None
#ポンチー通知#ポンチーダイミンカン通知
elif splitted_read_text[3] == "5" or splitted_read_text[3] == "7":
#ポンチー打診
pon_index = janshi[0].pon(taku, hai_str, janshi, taku.bakyou_list)
if pon_index[0]:
print("AI ポン")
#ポンする
#ポンする牌のindex
pon_hai_index = function_tenhou.hai_convert_136_to_index(
taku.last_dahai)
#赤なら普通の5に書き換え
if pon_hai_index % 10 == 0:
pon_hai_index += 5
#もし赤じゃない5をポンするなら
if pon_hai_index % 10 == 5 and pon_hai_index < 30:
tehai_index = function.tehai_convert(janshi[0].tehai)
#もし同じ色の赤を持っていたら
if tehai_index[pon_hai_index - 5] == 1:
output2 = [
function.hai_convert_reverse(pon_hai_index - 5),
function.hai_convert_reverse(pon_hai_index)
]
else:
output2 = [
function.hai_convert_reverse(pon_hai_index),
function.hai_convert_reverse(pon_hai_index)
]
else:
output2 = [
function.hai_convert_reverse(pon_hai_index),
function.hai_convert_reverse(pon_hai_index)
]
#print("ポンする牌:" + output)
#天鳳に出力
print(output2)
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Pon_Chii", output2)
#打牌時の情報を追加
taku.naki_dahai = pon_index[1]
print("AI 打:" + taku.naki_dahai)
return None
chii_index = janshi[0].chii(taku, hai_str, janshi,
taku.bakyou_list)
if chii_index[0] != -1:
print("AI チー: index = " + str(chii_index[0]))
#チーする
#チーする牌のindex
chii_hai_index = function_tenhou.hai_convert_136_to_index(
taku.last_dahai)
#赤をチー
if chii_hai_index % 10 == 0:
chii_hai_index += 5
if chii_index[0] == 0:
output2[0] = function.hai_convert_reverse(
chii_hai_index - 2)
output2[1] = function.hai_convert_reverse(
chii_hai_index - 1)
elif chii_index[0] == 1:
output2[0] = function.hai_convert_reverse(
chii_hai_index - 1)
output2[1] = function.hai_convert_reverse(
chii_hai_index + 1)
else: # chii_index[0] == 2:
output2[0] = function.hai_convert_reverse(
chii_hai_index + 1)
output2[1] = function.hai_convert_reverse(
chii_hai_index + 2)
#赤以外をチー
else:
if chii_index[0] == 0:
output2[0] = function.hai_convert_reverse(
chii_hai_index - 2)
output2[1] = function.hai_convert_reverse(
chii_hai_index - 1)
elif chii_index[0] == 1:
output2[0] = function.hai_convert_reverse(
chii_hai_index - 1)
output2[1] = function.hai_convert_reverse(
chii_hai_index + 1)
else: # chii_index[0] == 2:
output2[0] = function.hai_convert_reverse(
chii_hai_index + 1)
output2[1] = function.hai_convert_reverse(
chii_hai_index + 2)
#赤の書き換え
if chii_index[2]:
for j in range(2):
if output2[j] == "5m":
output2[j] = "5M"
elif output2[j] == "5p":
output2[j] = "5P"
elif output2[j] == "5s":
output2[j] = "5S"
#天鳳に出力
print(output2)
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Pon_Chii", output2)
#打牌時の情報を追加
taku.naki_dahai = chii_index[1]
print("AI 打:" + taku.naki_dahai)
return None
#鳴かない
print("AI スルー")
#天鳳に出力
if time.time() - start < taku.sleep_time_thresh:
time.sleep(taku.sleep_time)
gui_click("Cancel")
return None
return None
def new_yuukouhai_explore(shanten_suu, janshi, taku):
hash_table = taku.hash_table
tehai = np.array(function.tehai_convert(janshi.tehai))
#ツモって来る牌に赤ドラは考慮しない
yama = np.array(
function.tehai_convert(
function.akadora_convert(janshi.vertual_yama)[0]))
init_shanten_suu = shanten_suu
#index_list = [0]*len(tehai)
sum_list = [0] * len(tehai)
pure_point_sum = [0] * len(tehai)
#mean_list = [0]*len(tehai)
if shanten_suu >= 2:
hai_list = find_yuukou_sutehai(janshi, init_shanten_suu, hash_table)
#テンパイならシャンテン戻しも考える
else:
hai_list = function.tehai_convert3(janshi.tehai)
#print(hai_list)
#副露した時でアガリ役なしの場合
if len(hai_list) == 0:
#print("no_hai_list_error")
return [0.001] * len(janshi.tehai), [0.001] * len(
janshi.tehai), [0.001] * len(janshi.tehai)
#バグ防止用
for i in hai_list:
sum_list[i] += 0.001
#print(hai_list)
if init_shanten_suu >= 2:
itr = 25
elif init_shanten_suu == 1:
itr = 20
else:
itr = 15
for i in hai_list:
for j in range(itr):
count = 1.0
temp_janshi = copy.deepcopy(janshi)
#temp_tehai = tehai.copy()
temp_yama = yama.copy()
#temp_tehai[i] -= 1
temp_janshi.tehai.remove(function.hai_convert_reverse(
i)) # = function.tehai_convert_reverse(temp_tehai)
temp_janshi.sutehai.append(function.hai_convert_reverse(i))
if j == 0:
init_shanten_suu = shanten_check_new.shanten_check(
temp_janshi, taku.hash_table)
a, b = yuukouhai_explore(temp_yama, init_shanten_suu, count,
hash_table, temp_janshi, taku)
#index_list[i] += 1
sum_list[i] += a
pure_point_sum[i] += b
#shanten_suu + 1で平均打点を割る
pure_point_sum[i] /= max(init_shanten_suu + 1, 1) * itr
#print(np.max(sum_list))
normalized_index_list = np.array(sum_list) / np.sum(np.array(sum_list))
normalized_list = np.zeros(len(janshi.tehai))
sum_list_for_tehai_str = np.zeros(len(janshi.tehai))
pure_point_sum_for_tehai_str = np.zeros(len(janshi.tehai))
for i in range(len(janshi.tehai)):
normalized_list[i] = normalized_index_list[function.hai_convert(
janshi.tehai[i])]
sum_list_for_tehai_str[i] = sum_list[function.hai_convert(
janshi.tehai[i])]
pure_point_sum_for_tehai_str[i] = pure_point_sum[function.hai_convert(
janshi.tehai[i])]
sum_list_for_tehai_str = np.array(sum_list_for_tehai_str)
mean_list_for_tehai_str = sum_list_for_tehai_str / float(itr)
pure_point_sum_for_tehai_str = np.array(pure_point_sum_for_tehai_str)
return normalized_list, mean_list_for_tehai_str, pure_point_sum_for_tehai_str
def renew_vertual_yama_chii(self, hai_str, chii_index, janshi_chii):
hai_index = function.hai_convert(hai_str)
#もし3が鳴かれてjanshi_chiiのfuuro_akadora_list[-1]がTrueならchii_indexは2で確定で5は赤
if hai_index % 10 == 3 and janshi_chii.fuuro_akadora_list[-1]:
hai_str1 = function.hai_convert_reverse(hai_index + 1)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index - 3)
self.vertual_yama.remove(hai_str2)
#もし7が鳴かれてjanshi_chiiのfuuro_akadora_list[-1]がTrueならchii_indexは0で確定で5は赤
elif hai_index % 10 == 7 and janshi_chii.fuuro_akadora_list[-1]:
hai_str1 = function.hai_convert_reverse(hai_index - 1)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index - 7)
self.vertual_yama.remove(hai_str2)
#もし4が鳴かれてjanshi_chiiのfuuro_akadora_list[-1]がTrueならchii_indexは1か2で5は赤
elif hai_index % 10 == 4 and janshi_chii.fuuro_akadora_list[-1]:
#345
if chii_index == 1:
hai_str1 = function.hai_convert_reverse(hai_index - 1)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index - 4)
self.vertual_yama.remove(hai_str2)
else: #chii_index == 2
hai_str1 = function.hai_convert_reverse(hai_index - 4)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index + 2)
self.vertual_yama.remove(hai_str2)
#もし6が鳴かれてjanshi_chiiのfuuro_akadora_list[-1]がTrueならchii_indexは0か1で5は赤
elif hai_index % 10 == 6 and janshi_chii.fuuro_akadora_list[-1]:
if chii_index == 0:
hai_str1 = function.hai_convert_reverse(hai_index - 6)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index - 2)
self.vertual_yama.remove(hai_str2)
else: #chii_index = 1
hai_str1 = function.hai_convert_reverse(hai_index - 6)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index + 1)
self.vertual_yama.remove(hai_str2)
#もし赤5が鳴かれた場合
elif hai_index % 10 == 0:
hai_index += 5
if chii_index == 0:
hai_str1 = function.hai_convert_reverse(hai_index - 1)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index - 2)
self.vertual_yama.remove(hai_str2)
elif chii_index == 1:
hai_str1 = function.hai_convert_reverse(hai_index - 1)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index + 1)
self.vertual_yama.remove(hai_str2)
elif chii_index == 2:
hai_str1 = function.hai_convert_reverse(hai_index + 1)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index + 2)
self.vertual_yama.remove(hai_str2)
#それ以外
else:
if chii_index == 0:
hai_str1 = function.hai_convert_reverse(hai_index - 1)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index - 2)
self.vertual_yama.remove(hai_str2)
elif chii_index == 1:
hai_str1 = function.hai_convert_reverse(hai_index - 1)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index + 1)
self.vertual_yama.remove(hai_str2)
elif chii_index == 2:
hai_str1 = function.hai_convert_reverse(hai_index + 1)
self.vertual_yama.remove(hai_str1)
hai_str2 = function.hai_convert_reverse(hai_index + 2)
self.vertual_yama.remove(hai_str2)
def riichi_hantei(janshi, taku):
nokori_tsumo_kaisuu = int(taku.yama_nokori / 4)
nokori_tsumo_kaisuu2 = nokori_tsumo_kaisuu - 1
#閾値 場況によって変える予定
thresh = 1000
yuukou_sutehai = find_yuukou_sutehai(janshi, 0, taku.hash_table)
itr = int(3000.0 / (len(yuukou_sutehai) * max(nokori_tsumo_kaisuu, 1)))
itr2 = itr
#print(itr)
agari_sum_list = np.zeros(38)
agari_sum_list2 = np.zeros(38)
#agari_sum_list[yuukou_sutehai] = 0.1
temp_taku = copy.deepcopy(taku)
dora_mem = temp_taku.dorahyouji.copy()
len_dora = len(temp_taku.dorahyouji)
dora_memory_list = []
yama_memory_list = []
#裏ドラリストを作成
for j in range(itr):
temp_vertual_yama = janshi.vertual_yama.copy()
dora_temp = []
for k in range(len_dora):
rand_index = random.randrange(len(temp_vertual_yama))
dora_temp.append(temp_vertual_yama[rand_index])
del temp_vertual_yama[rand_index]
dora_memory_list.append(dora_temp)
random.shuffle(temp_vertual_yama)
yama_memory_list.append(temp_vertual_yama[0:nokori_tsumo_kaisuu])
#保存用
yama_memory_list2 = copy.deepcopy(yama_memory_list)
for index in yuukou_sutehai:
#バグ防止
agari_sum_list[index] += 1
yama_memory_list = copy.deepcopy(yama_memory_list2)
for j in range(itr):
temp_janshi = copy.deepcopy(janshi)
temp_janshi.tehai.remove(function.hai_convert_reverse(index))
temp_janshi.riichi = 1
temp_taku.dorahyouji = dora_mem.copy()
#フリテンの場合は減点
#furiten_flag = function.furiten_hantei(temp_janshi, temp_taku)
#裏ドラをランダムで設定
temp_taku.dorahyouji.extend(dora_memory_list[j])
#if furiten_flag:
# furiten_penalty = 0.7
#else:
# furiten_penalty = 1.0
agari_sum_list[index] += monte_carlo_riichi(
temp_janshi, temp_taku, nokori_tsumo_kaisuu,
yama_memory_list[j]) #*furiten_penalty
mean_list = agari_sum_list / float(itr)
max_index = np.argmax(mean_list)
print("立直時打点期待値: " + str(mean_list[max_index]) + "点")
for index in yuukou_sutehai:
yama_memory_list = copy.deepcopy(yama_memory_list2)
#バグ防止
agari_sum_list2[index] += 1
for j in range(itr2):
temp_janshi = copy.deepcopy(janshi)
temp_janshi.tehai.remove(function.hai_convert_reverse(index))
temp_taku.dorahyouji = dora_mem.copy()
#裏ドラをランダムで設定
temp_taku.dorahyouji.extend(dora_memory_list[j])
temp_janshi.tehai.append(yama_memory_list[j][0])
del yama_memory_list[j][0]
if shanten_check_new.shanten_check(temp_janshi,
taku.hash_table) == -1:
point = tensu_calc.tensu_calc(temp_janshi, temp_taku,
temp_janshi.tehai[-1])
if janshi.kaze == 0:
agari_point = point[0] * 3
else:
agari_point = point[0] * 2 + point[1]
agari_sum_list2[index] += agari_point
else:
yuukou_sutehai2 = find_yuukou_sutehai(temp_janshi, 0,
taku.hash_table)
temp2 = random.choice(yuukou_sutehai2)
temp_janshi.tehai.remove(function.hai_convert_reverse(temp2))
temp_janshi.riichi = 1
#フリテンの場合は減点
#furiten_flag = function.furiten_hantei(temp_janshi, temp_taku)
#if furiten_flag:
# furiten_penalty = 0.7
#else:
# furiten_penalty = 1.0
agari_sum_list2[index] += monte_carlo_riichi(
temp_janshi, temp_taku, nokori_tsumo_kaisuu2,
yama_memory_list[j]) #*furiten_penalty
mean_list2 = agari_sum_list2 / float(itr2)
max_index2 = np.argmax(mean_list2)
print("立直保留時打点期待値: " + str(mean_list2[max_index2]) + "点")
if max(mean_list2[max_index2], mean_list[max_index]) < thresh:
return [False, max_index, 0]
if mean_list2[max_index2] > mean_list[max_index] + 175:
return [False, max_index2, mean_list2[max_index]]
else:
if mean_list[max_index] > thresh:
return [True, max_index, mean_list[max_index]]
return [False, max_index, 0]
