hanabiapp.game.agent.intentional_agent

  1import pdb
  2import pprint
  3import copy
  4from .agent import Agent
  5from ..action import Action
  6
  7class IntentionalAgent(Agent):
  8  """
  9  意図的な（ルールベースの）エージェントを表現するクラス．
 10  
 11  エージェントは知識とボードの状態に基づいて意図的なアクションを決定する．
 12  """
 13  def __init__(self, name, player_number,is_cui=True):
 14    """
 15    IntentionalAgent のコンストラクタ．
 16    
 17    Args:
 18        name (str): エージェントの名前
 19        player_number (int): プレイヤーの番号
 20        is_cui (bool, optional): CUIモードかどうか（デフォルトはTrue）
 21    """
 22    super().__init__(name, player_number)
 23    self.need_hle_convert= False
 24    self.hints = {}
 25    self.gothint = None
 26    self.last_knowledge = []
 27    self.last_board = []
 28    self.explanation = []
 29  
 30  def format_card(self, card):
 31    """
 32    カードの色とランクを色コード＋数字でフォーマットする（表示用）．
 33    
 34    Args:
 35        card (tuple): カードの色と数字のタプル
 36    
 37    Returns:
 38        str: フォーマットされたカードの文字列（例: "B3"）
 39    """
 40    color_code = self.game_const.COLOR_NAMES[card[0]]  # カードの色コード（例: B）
 41    number = card[1]  # カードの数字
 42    return f"{color_code}{number}" # カードの色コード＋数字（例: B3）
 43
 44  def format_intention(self, intention):
 45        """
 46        プレイヤーの意図をフォーマットして文字列に変換する関数．
 47        
 48        Args:
 49            intention (str or None): 意図の種類（PLAY, DISCARD, CANDISCARD など）
 50        
 51        Returns:
 52            str: 整形された意図の文字列
 53        """
 54        # invalidhintなどの文字列の場合はそのまま返す
 55        if isinstance(intention, str):
 56            return intention
 57        # 意図のフォーマット表示
 58        if intention == "PLAY":
 59            return "Play"
 60        elif intention == "DISCARD":
 61            return "Discard"
 62        elif intention == "CANDISCARD":
 63            return "CanDiscard"
 64        return "Keep"
 65  
 66  def format_knowledge(self, k):
 67        """
 68        プレイヤーの知識をフォーマットして文字列に変換する関数．
 69        
 70        Args:
 71            k (dict): カードの知識情報
 72        
 73        Returns:
 74            str: 整形された知識の文字列
 75        """
 76        # プレイヤーの知識をフォーマットして文字列に変換するメソッド
 77        # k: カードに関する知識を表す辞書（各色とランクの情報）
 78        result = ""  # フォーマットされた知識を保持する文字列
 79        for col in self.game_ins.game_const.ALL_COLORS:
 80            for i, cnt in enumerate(k[col]):
 81                if cnt > 0:
 82                    # カウントが0より大きい場合のみ情報を追加
 83                    # 色名とランク、そしてその可能性の数を文字列に追加
 84                    result += self.game_ins.game_const.COLOR_NAMES[col] + " " + str(i + 1) + ": " + str(cnt) + "n"
 85        return result
 86
 87  def print_l_2d(self,name,l_2d):
 88    """
 89    2次元リストのデータを整形して出力する関数（CUIモードのみ）．
 90    
 91    Args:
 92        name (str): 出力時のタイトル
 93        l_2d (list): 出力する2次元リスト
 94    """
 95    if self.is_cui:
 96      print(f"{name}:")
 97      pprint.pprint(l_2d,width=100,compact=True)
 98  
 99  def act(self, game_ins):
100    """
101    プレイヤーの次のアクションを決定する関数．
102    
103    Args:
104        game_ins (Game): ゲームのインスタンス
105    
106    Returns:
107        Action: 選択されたアクション
108    """
109    #===============================================================================================
110    # もともと原作では引数で受け取っていた変数．
111    self.game_ins = game_ins
112    player_number = self.player_number
113    hands = self.game_ins.hands
114    knowledge = self.game_ins.knowledge
115    trash = self.game_ins.trash
116    board = self.game_ins.board
117    hints = self.game_ins.hints
118    #===============================================================================================
119
120    # 変数の初期化
121    handsize = len(hands[player_number])
122    possible = []
123    result = None
124    self.explanation = []  # プレイヤーの行動を説明するための初期化
125    self.explanation.append(["oppHand:"] + list(map(self.format_card, hands[1 - player_number])))
126    self.gothint = None
127
128    #===============================================================================================
129    # 己のknowledgeから，持ちうるカード（(色,数字)のタプル）をリストアップ（枚数情報除く）
130    for k in knowledge[self.player_number]:
131      possible.append(self.get_possible(k))
132    #===============================================================================================
133    playable_cards= [] # プレイ可能なカードのが手札の何番目にあるかの添え字がappendされるリスト
134    discardable_cards = [] # 廃棄可能なカードのが手札の何番目にあるかの添え字がappendされるリスト
135    for i, card in enumerate(possible):
136      # The above code is using an f-string to print out the value of the variable `card`. The syntax
137      # `{card=}` is a shorthand way to include both the variable name and its value in the output.
138      # print(f"{card=}")
139      # ボード上のその色のカードが次に必要な数字かどうかを確認
140      if self.playable(card,self.game_ins.board):
141        playable_cards.append(i)
142        self.print_log("Intentional:プレイ可能カードを持っていれるので，それをプレイします．")
143        # The code is creating a `result` object with an action of playing a card at a specific
144        # position `i`.
145        result = Action(self.game_ins.game_const.PLAY, card_position=i)
146        # result = Action(self.game_ins.game_const.PLAY, card_position=self.game_ins.random.choice(playable_cards))
147      if self.discardable(card,self.game_ins.board):
148        # possibleの中から，破棄可能なカードが見つかったら，それをdiscardable_cardsにメモしておく
149        discardable_cards.append(i)
150
151    # print(f"{playable_cards=}")
152    # もし自分が破棄可能カードを持っていて，かつヒントトークンを回復させる余地（ヒントトークンが８個未満）があれば，破棄する
153    if discardable_cards and hints < 8 and not result:
154      self.print_log("Intentional:破棄可能カードを持っており，かつヒントトークンを回復できるので，それを捨てます．")
155      result = Action(self.game_ins.game_const.DISCARD, card_position=self.game_ins.random.choice(discardable_cards))
156
157    
158    #===============================================================================================
159    # 相手視点のゴールの設定
160    opponent_playables = [] # 相手の手札のうち，プレイ可能なカード群
161    opponent_useless = [] # 相手の手札のうち，ボード上ですでに出ている無価値なカード群
162    opponent_potentially_discardables = [] # 相手の手札のうち，ボード上で"出ていない"かつ"5未満"のカード群を将来的に捨てれるとみなした，潜在的な捨てカード候補群
163
164    # すでに場にでているカードの情報を取得
165    board_and_trash_cards = []
166    # board辞書を(色, 数字)のタプルのリストに変換して，すでに場に出たカードをメモに加える
167    for color, count in board.items():
168        for number in range(1, count + 1):
169            board_and_trash_cards .append((color, number))
170    # self.print_log(f"board:{board}")
171    board_and_trash_cards  += trash  # 捨てられたカードもリストに追加
172    # self.print_log(f"board_and_trash_cards :{board_and_trash_cards }")
173
174    intentions = [None for _ in range(handsize)]  # 各カード，普通意図するゴールを保持するためのリストを初期化
175
176    # self.print_log(f"hands:{hands}")
177    # 各プレイヤーの手札を確認
178    for i, hand in enumerate(hands.items()):
179      if i != player_number:  # 他プレイヤーの手札をチェック（自分自身ではない）
180        # hand:(1, [(2, 2), (3, 3), (3, 1), (0, 2), (2, 1)])というタプルなので，手札部分だけ取り出す
181        for j, card in enumerate(hand[1]):
182          color, number = card
183          # --- プレイ可能かどうかのチェック ---
184          if board[color] + 1 == number:
185            # 相手の手札のあるカードがプレイ可能な場合、プレイ可能リストに追加
186            opponent_playables.append(card)
187            # ヒントを出したらプレイ可能という意図を込めたアクションをゴールとしてintentionsにセット
188            # 実際にアクションをとるわけではないので，Actionオブジェクトではなく，"PLAY"をセット
189            intentions[j] = "PLAY"
190          
191          # --- 既に無価値なカードのチェック ---
192          if board[color] >= number:
193            # ボード上ですでに出ているカードは無価値とみなし，無価値リストに追加
194            opponent_useless.append(card)
195            # ヒントを出したら無価値カード，という意図を込めたアクションをゴールとしてintentionsにセット
196            # ただし，意図としてはプレイの方が強いので，プレイの意図がない場合のみ無価値カードとして意図をセット
197            if not intentions[j]:
198              intentions[j] = "DISCARD"
199
200          # --- 将来的に捨てても良いカードのチェック ---
201          if number < 5 and (color, number) not in board_and_trash_cards:
202            # ボードにまだないカードで5未満のものは、将来的に捨てても良いと判断
203            opponent_potentially_discardables.append(card)
204            # ただし，意図としてはプレイ＆無価値示唆の方が強いので，プレイ＆無価値示唆の意図がない場合のみ潜在的な捨てカード候補群として意図をセット
205            if not intentions[j]:
206              intentions[j] = "CANDISCARD"
207
208    # self.print_log(f"opponent_playables:{opponent_playables}")
209    # self.print_log(f"opponent_useless:{opponent_useless}")
210    # self.print_log(f"opponent_potentially_discardables:{opponent_potentially_discardables}")
211
212    self.explanation.append(["intentions:"] + list(map(self.format_intention, intentions)))
213
214    #===============================================================================================
215    # スモールステップ 5: 相手の行動を予測する
216    if hints > 0:
217      valid_hints = []  # 有効なヒントを保存するリスト
218      
219      # 各色に対してヒントを与える可能性をチェック
220      for color in self.game_ins.game_const.ALL_COLORS:
221  
222        assumed_color_hint_action = ("HINT_COLOR", color) # 色ヒントを仮定
223        # self.print_log(f"||||||||||||||pretend :{assumed_color_hint_action[0]},{self.game_ins.game_const.COLOR_NAMES[assumed_color_hint_action[1]]}||||||||||||||")
224        opponent_knowledge = knowledge[1 - player_number]  # 相手の知識を取得
225        opponent_hands = hands[1 - player_number]  # 相手の手札を取得
226
227        is_valid, score, explanation = self.pretend(assumed_color_hint_action, opponent_knowledge, intentions, opponent_hands, board)
228        # self.print_log(f"is_valid:{is_valid},score:{score},explanation:{explanation}")
229
230        # 各仮定結果を説明リストに追加
231        self.explanation.append([f"Prediction for: Hint Color {self.game_ins.game_const.COLOR_NAMES[color]}"] + list(map(self.format_intention, explanation))+[f"Score: {score}"])
232
233        if is_valid:
234            valid_hints.append((assumed_color_hint_action, score))  # 有効であればヒントを保存
235            
236      # 各ランクに対してヒントを与える可能性をチェック
237      for rank in range(1, 6):
238          action = ("HINT_NUMBER", rank)
239          # self.print_log(f"||||||||||||||pretend :{action[0]},{action[1]}||||||||||||||")
240          # ヒントを仮定して評価
241          is_valid, score, explanation = self.pretend(action, knowledge[1 - player_number], intentions, hands[1 - player_number], board)
242          # 各仮定結果を説明リストに追加
243          self.explanation.append([f"Prediction for: Hint Rank {rank}"] + list(map(self.format_intention, explanation))+[f"Score: {score}"])
244          if is_valid:
245              valid_hints.append((action, score))  # 有効であればヒントを保存
246      
247
248      
249      # self.print_log(f"valid_hints:{valid_hints}")
250      # ヒントの候補が存在し、まだ行動が決まっていない場合
251      if valid_hints and not result:
252          # スコアが高い順にソートして最良のヒントを選択
253          valid_hints.sort(key=lambda x: -x[1])
254          best_action, _ = valid_hints[0] # 最良のヒントを取得
255          # self.print_log(f"best_action:{best_action}")
256          # 最良のヒントをアクションとして設定
257          if best_action[0] == "HINT_COLOR":
258              self.print_log("Intentional:最良の色ヒントを出します．")
259              result = Action(game_ins.game_const.HINT_COLOR, pnr = 1 - player_number, color = best_action[1])
260          else:
261              self.print_log("Intentional:最良の数字ヒントを出します．")
262              result = Action(game_ins.game_const.HINT_NUMBER, pnr = 1 - player_number, number = best_action[1])
263
264    #===============================================================================================
265
266    # --- スモールステップ 6: 最終的な捨てる行動のスコアリングと選択 ---
267    
268    # self.explanation.append(["My Knowledge"] + list(map(self.format_knowledge, knowledge[player_number]))) # みにくいknowledgeの表示はコメントアウト
269    discard_actions = [Action(game_ins.game_const.DISCARD, card_position=i) for i in range(handsize)]
270    scores = list(map(lambda p: self.pretend_discard(p, knowledge[player_number], board, trash), discard_actions))
271    scores.sort(key=lambda x: -x[1])  # スコアが高い順にソート
272
273
274    # カスタムフォーマットでdiscard_scoresを表示
275    formatted_scores = [
276        (index, action.card_position, score, details)
277        for index, (action, score, details) in enumerate(scores)
278    ]
279
280    # self.print_l_2d("discard_scores",scores)
281
282    # self.print_log(f"result:{result}")
283    # self.print_l_2d("explanation",self.explanation)
284
285    if result:
286        return result
287    else:
288        self.print_log("Intentional:最良の捨てる行動を選択します．")
289        # self.print_l_2d("discard_scores",formatted_scores)
290        return scores[0][0]  # 最もスコアが高い捨てる行動を選択
291
292    # # もし相手がプレイ可能なカードを持っておらず，ヒントトークンがない場合，自分のカードをランダムに選んで捨てる
293    # self.print_log("Intentional:自分のカードをランダムに選んで捨てます．")
294    # #self.print_log(f"random_pick_card_position:{random_pick_card_position}")
295    # return Action(self.game.game_const.DISCARD, card_position=self.game.random.choice(range(self.game.hand_size)))
296
297  def pretend(self, assumed_hint_action, opponent_knowledge, intentions, opponent_hands, board):
298    """
299    指定したヒントアクションを仮定し，その有効性を評価する関数．
300    
301    Args:
302        assumed_hint_action (tuple): 仮定するアクション（アクションの種類と値）
303        opponent_knowledge (list): 相手の知識状態
304        intentions (list): 各カードに対する意図
305        opponent_hands (list): 相手の手札
306        board (dict): 現在のボードの状態
307    
308    Returns:
309        tuple: (有効性の判定, スコア, 説明)
310    """
311    
312    # アクションを仮定して評価する関数 (詳細版)
313    (assumed_action_type, assumed_action_value) = assumed_hint_action # 仮定したアクションの種類と値を取得
314    is_positive_list_card_matching_hint = []  # 各カードがヒントに合致するかどうか
315    has_positive_card_matching_hint = False  # 少なくとも1枚がヒントに合致するか．事実上のヒントを出したときに指さされたカードかどうか．
316    is_change_opponent_knowledge = False  # ヒントによって新しい情報が得られるか
317
318    # アクションが色のヒントの場合
319    if assumed_action_type == "HINT_COLOR":
320        new_opponent_knowledge = [] # 仮定した色ヒントアクションで得られる，相手の新しい知識を保存するリスト
321        # 各カードに対して
322        for i, (col, num) in enumerate(opponent_hands):
323            is_positive_list_card_matching_hint.append(assumed_action_value == col)  # カードがヒントと合致するかどうか
324            opponent_card_knowledge = opponent_knowledge[i] # 仮定した色ヒントアクションをとる前「１枚分」のカードの知識
325            # 仮定した色ヒントアクションをとった後のカード「１枚分」の知識
326            new_opponent_each_card_knowledge = self.hint_color(opponent_card_knowledge, assumed_action_value, assumed_action_value == col)
327            # 仮定した色ヒントアクションをとった後のカード「１枚分」の知識を追加
328            new_opponent_knowledge.append(new_opponent_each_card_knowledge)
329
330            # 仮定した色ヒントアクションが相手手札の１枚の色と合致するなら
331            if assumed_action_value == col:
332                has_positive_card_matching_hint = True  # 少なくとも1枚がヒントに合致することを確認
333                # 「１枚分」のカードの知識を比較し，新しい情報が得られるかを確認
334                if new_opponent_knowledge[-1] != opponent_knowledge[i]:
335                    is_change_opponent_knowledge = True  # 新しい情報が得られたらTrue
336            
337            # self.print_log(f"op_hand color:{col},num:{num}")
338            # self.print_l_2d("new_opponent_knowledge",new_opponent_knowledge)
339            # self.print_log(f"new_opponent_knowledge[-1]:{new_opponent_knowledge[-1]}")
340            # self.print_log(f"opponent_knowledge[i]:{opponent_knowledge[i]}")
341            # self.print_log(f"has_positive_card_matching_hint:{has_positive_card_matching_hint}")
342            # self.print_log(f"is_change_opponent_knowledge:{is_change_opponent_knowledge}")
343            # self.print_log("\n")
344
345    else:
346        # アクションがランクのヒントの場合
347        new_opponent_knowledge = [] # 仮定した色ヒントアクションで得られる，相手の新しい知識を保存するリスト
348        # 各カードに対して
349        for i, (col, num) in enumerate(opponent_hands):
350            is_positive_list_card_matching_hint.append(assumed_action_value == num)  # カードがヒントと合致するかどうか
351            opponent_card_knowledge = opponent_knowledge[i] # 仮定した色ヒントアクションをとる前「１枚分」のカードの知識
352            # 仮定した色ヒントアクションをとった後のカード「１枚分」の知識
353            new_opponent_each_card_knowledge = self.hint_rank(opponent_card_knowledge, assumed_action_value, assumed_action_value == num)
354            # 仮定した色ヒントアクションをとった後のカード「１枚分」の知識を追加
355            new_opponent_knowledge.append(new_opponent_each_card_knowledge)
356
357            if assumed_action_value == num:
358                has_positive_card_matching_hint = True  # 少なくとも1枚がヒントに合致することを確認
359                # 「１枚分」のカードの知識を比較し，新しい情報が得られるかを確認
360                if new_opponent_knowledge[-1] != opponent_knowledge[i]:
361                    is_change_opponent_knowledge = True  # 新しい情報が得られたらTrue
362
363            # self.print_log(f"op_hand color:{col},num:{num}")
364            # self.print_l_2d("new_opponent_knowledge",new_opponent_knowledge)
365            # self.print_log(f"new_opponent_knowledge[-1]:{new_opponent_knowledge[-1]}")
366            # self.print_log(f"opponent_knowledge[i]:{opponent_knowledge[i]}")
367            # self.print_log(f"has_positive_card_matching_hint:{has_positive_card_matching_hint}")
368            # self.print_log(f"is_change_opponent_knowledge:{is_change_opponent_knowledge}")
369            # self.print_log("\n")
370
371    # ヒントがどのカードにも一致しなければ無効なヒント
372    if not has_positive_card_matching_hint:
373        # self.print_log("Invalid hint")
374        return False, 0, ["Invalid hint"]
375    # ヒントが新しい情報をもたらさなければ無効なヒント
376    if not is_change_opponent_knowledge:
377        # self.print_log("No new information")
378        return False, 0, ["No new information"]
379    
380    score = 0  # ヒントのスコアを初期化
381    predictions = []  # 各カードに対する予測結果のリスト
382    has_positive_effect_at_least_one_card = False  # 少なくとも1枚のカードに対して正の影響があるかどうかを示すフラグ
383
384    # self.print_log(f"intentions:{intentions}")
385    # self.print_log(f"opponent_hands:{opponent_hands}")
386    # self.print_l_2d("new_opponent_knowledge",new_opponent_knowledge)
387    # self.print_log(f"is_positive_list_card_matching_hint:{is_positive_list_card_matching_hint}")
388    
389    # 各カードについて意図と一致するか確認
390    for i, card, new_know, is_positive in zip(intentions, opponent_hands, new_opponent_knowledge, is_positive_list_card_matching_hint):
391        # self.print_log(f"i:{i}")
392        #self.print_log(f"new_know:{new_know}")
393        #self.print_log(f"is_positive:{is_positive}")
394
395        # 新しい知識に基づいて,相手がとるだろうアクションを決定
396        opponent_whattodo_action = self.whattodo(new_know, is_positive, board)
397
398        # self.print_log(f"opponent_whattodo_action:{opponent_whattodo_action}")
399        
400        if opponent_whattodo_action == "PLAY" and i != "PLAY":
401            # アクションがプレイだが、意図がプレイでない場合は無効なヒント
402            # self.print_log("op-ac;play,but Invalid hint")
403            return False, 0, predictions + ["PLAY"]
404        
405        if opponent_whattodo_action == "DISCARD" and i not in ["DISCARD", "CANDISCARD"]:
406            # アクションが捨てるだが、意図が捨てるまたは将来的に捨てる可能性のあるカードでない場合は無効なヒント
407            # self.print_log("op-ac;discard,but Invalid hint")
408            return False, 0, predictions + ["DISCARD"]
409        
410        if opponent_whattodo_action == "PLAY" and i == "PLAY":
411            # アクションがプレイであり、意図もプレイの場合はスコアを加算
412            has_positive_effect_at_least_one_card = True # 少なくとも1枚のカードに対して正の影響がある
413            predictions.append("PLAY")
414            score += 3
415        elif opponent_whattodo_action == "DISCARD" and i in ["DISCARD", "CANDISCARD"]:
416            # アクションが捨てるであり、意図が捨てるもしくは将来的に捨てる可能性がある場合はスコアを加算
417            has_positive_effect_at_least_one_card = True # 少なくとも1枚のカードに対して正の影響がある
418            predictions.append("DISCARD")
419            if i == "DISCARD":
420                score += 2 # 捨てる意図の場合はスコアを2加算
421            else:
422                score += 1 # 将来的に捨てる可能性がある場合はスコアを1加算
423        else:
424            predictions.append(None)  # それ以外の場合は何も追加しない
425        
426    # self.print_log(f"score:{score}")
427    # self.print_log(f"predictions:{predictions}")
428      
429    # 少なくとも1枚のカードに対して正の影響があるか確認
430    if not has_positive_effect_at_least_one_card:
431        return False, score, predictions
432    return True, score, predictions
433
434  def whattodo(self, knowledge, pointed, board):
435      """
436      プレイヤーの知識に基づいて，次に取るべきアクションを決定する関数．
437      
438      Args:
439          knowledge (list): カードに関する知識のリスト
440          pointed (bool): ヒントで指摘されたかどうか
441          board (dict): 現在のボードの状態
442      
443      Returns:
444          str or None: PLAY, DISCARD, もしくは None
445      """
446      # プレイヤーの知識に基づいて、次に取るべきアクションを決定
447      # knowledge: 各カードに関するプレイヤーの知識を表すリスト
448      # pointed: そのカードがプレイヤーに対して指摘されたかどうかを示すフラグ（ヒントが与えられたかどうか）
449      # board: 現在のボードの状態（各色ごとの進行状況）
450
451      # カードに関する知識から、どの色・ランクのカードである可能性があるかを取得
452      possible = self.get_possible(knowledge)
453
454      # self.print_log(f"possible:{possible}")
455
456      # ボードにプレイできるかどうかを確認
457      play = self.potentially_playable(possible, board)
458      # self.print_log(f"play:{play}")
459
460      # カード捨てても良いかどうかを確認
461      discard = self.potentially_discardable(possible, board)
462      # self.print_log(f"discard:{discard}")
463
464      # カードがプレイ可能で、かつそのカードが指摘されている場合
465      if play and pointed:
466          return "PLAY"  # プレイアクションを返す
467
468      # カードが捨てても良く、かつそのカードが指摘されている場合
469      if discard and pointed:
470          return "DISCARD"  # 捨てるアクションを返す
471
472      # どちらでもない場合は何もしない（None を返す）
473      return None
474
475  def hint_color(self, opponent_card_knowledge, assumed_action_hint_color, truth):
476    """
477    色のヒントを適用して新しい知識を生成する関数．
478    
479    Args:
480        opponent_card_knowledge (list): 相手のカード知識
481        assumed_action_hint_color (int): 与えるヒントの色
482        truth (bool): ヒントが実際の色と一致するかどうか
483    
484    Returns:
485        list: 更新されたカード知識
486    """
487    # 色のヒントを適用して新しい知識を生成
488    # truth は、ヒントが正しいかどうか（与えられた色に合致するか）を示すフラグ
489    result = []  # 新しい知識の結果を保存するリスト
490    for col in self.game_ins.game_const.ALL_COLORS:
491      if truth == (col == assumed_action_hint_color):
492        # truth が True で、col がヒントと一致する場合
493        # または truth が False で、col が一致しない場合
494        # 現在の知識をそのまま新しい知識にコピー
495        result.append(opponent_card_knowledge[col][:])
496      else:
497        # それ以外の場合、情報をリセット（ゼロにする）
498        result.append([0 for _ in opponent_card_knowledge[col]])
499    return result
500  
501  def hint_rank(self, opponent_card_knowledge, assumed_action_hint_rank, truth):
502    """
503    ランクのヒントを適用して新しい知識を生成する関数．
504    
505    Args:
506        opponent_card_knowledge (list): 相手のカード知識
507        assumed_action_hint_rank (int): 与えるヒントのランク
508        truth (bool): ヒントが実際のランクと一致するかどうか
509    
510    Returns:
511        list: 更新されたカード知識
512    """
513    # ランクのヒントを適用して新しい知識を生成
514    # truth は、与えられたランクと一致するかどうかを示すフラグ
515    result = []  # 新しい知識の結果を保存するリスト
516    for col in self.game_ins.game_const.ALL_COLORS:
517        col_knowledge = []  # 各色に対する知識を保存するリスト
518        for i, k in enumerate(opponent_card_knowledge[col]):
519            if truth == (i + 1 == assumed_action_hint_rank):
520                # truth が True で、ランクが一致する場合
521                # または truth が False で、ランクが一致しない場合
522                # 現在の知識をそのまま新しい知識にコピー
523                col_knowledge.append(k)
524            else:
525                # それ以外の場合、情報をリセット（ゼロにする）
526                col_knowledge.append(0)
527        result.append(col_knowledge)
528    return result
529
530
531  def get_possible(self,knowledge):
532    """
533    各カードに対する知識に基づいて，プレイヤーが持っている可能性があるカードのリストを返す．
534    
535    Args:
536        knowledge (list): カードに関する知識
537    
538    Returns:
539        list: 可能性のあるカードのリスト（色と数字のタプル）
540    """
541    possible = []
542    for color in self.game.game_const.ALL_COLORS:
543      for number, count in enumerate(knowledge[color]):
544
545        if count > 0:
546          possible.append((color, number + 1))  # 色と数字のペアを追加
547    #check_type_and_dtype(possible)
548    return possible
549  
550  def playable(self,possible, board):
551    """
552    可能性のあるカードの中でプレイ可能なものがあるかを確認する関数．
553    
554    Args:
555        possible (list): 可能性のあるカードのリスト（色と数字のタプル）
556        board (dict): 現在のボードの状態
557    
558    Returns:
559        bool: プレイ可能なカードがあればTrue，なければFalse
560    """
561    # ヒントの可能性から，プレイ可能だと確定してるかどうかを確認するメソッド
562    #self.print_log("playable関数")
563    for (color,number) in possible:
564      # self.print_log(f"color:{color},number:{number}")
565      # self.print_log(f"{color}色の最大値:{board[color]}")
566      if board[color] + 1 != number:
567        # self.print_log(f"Playable:{color,number} is False")
568        return False # possibleのリスト内で、少なくとも1つでもplayableでないタプルが含まれていると、そのリスト全体に対してFalseが返されます
569    # self.print_log(f"Playable:{possible} is True")
570    return True 
571  
572  def discardable(self,possible, board):
573    """
574    可能性のあるカードの中で廃棄可能なものがあるかを確認する関数．
575    
576    Args:
577        possible (list): 可能性のあるカードのリスト（色と数字のタプル）
578        board (dict): 現在のボードの状態
579    
580    Returns:
581        bool: 廃棄可能なカードがあればTrue，なければFalse
582    """
583    # ヒントの可能性から，廃棄可能だと確定してるかどうかを確認するメソッド
584    for (color,number) in possible:
585      if board[color] < number: 
586        return False
587    #self.print_log("Discardable: ",possible)
588    return True # ボード上のその色のカードよりも小さい数字なら破棄しても問題ない
589
590  def potentially_playable(self, possible, board):
591    """
592    可能性のあるカードの中でプレイ可能なものがあるかを確認する関数．
593    
594    Args:
595        possible (list): 可能性のあるカードのリスト（色と数字のタプル）
596        board (dict): 現在のボードの状態
597    
598    Returns:
599        bool: プレイ可能なカードがあればTrue，なければFalse
600    """
601    # ヒントの可能性から，「プレイ可能なカードが１枚でもあるか」を確認するメソッド
602    for (color, number) in possible:
603        if board[color] + 1 == number:
604            return True
605    return False
606
607  def potentially_discardable(self, possible, board):
608      """
609      可能性のあるカードの中で廃棄可能なものがあるかを確認する関数．
610      
611      Args:
612          possible (list): 可能性のあるカードのリスト（色と数字のタプル）
613          board (dict): 現在のボードの状態
614      
615      Returns:
616          bool: 廃棄可能なカードがあればTrue，なければFalse
617      """
618      # ヒントの可能性から，「廃棄可能なカードが１枚でもあるか」を確認するメソッド
619      for (color, number) in possible:
620          if board[color] >= number:
621              return True
622      return False
623  
624  def pretend_discard(self, act, knowledge, board, trash):
625      """
626      指定したヒントアクションを仮定し，その有効性を評価する関数．
627      
628      Args:
629          assumed_hint_action (tuple): 仮定するアクション（アクションの種類と値）
630          opponent_knowledge (list): 相手の知識状態
631          intentions (list): 各カードに対する意図
632          opponent_hands (list): 相手の手札
633          board (dict): 現在のボードの状態
634      
635      Returns:
636          tuple: (有効性の判定, スコア, 説明)
637      """
638      # 捨てるアクションを仮定して、可能性やスコアを評価するメソッド
639      # act: 捨てるアクション（Action オブジェクト）
640      # knowledge: 現在のプレイヤーのカードに関する知識
641      # board: 現在のボードの状態（各色ごとの進行状況）
642      # trash: 既に捨てられたカードの情報
643      HINT_VALUE = 0.5
644
645      # --- ステップ 1: 現在のカードの知識をコピー ---
646      # 現在の知識を深いコピーで保存し、元の知識に影響を与えないようにする
647      which = copy.deepcopy(knowledge[act.card_position])
648
649      # self.print_log(f"which:{which}")
650
651      # --- ステップ 2: 捨てられたカードの情報を反映 ---
652      # 既に捨てられているカードの情報を知識に反映させることで、現状のカードの可能性を減らす
653      for (col, num) in trash:
654          if which[col][num - 1] > 0:
655              which[col][num - 1] -= 1
656
657      # self.print_log(f"which without trash:{which}")
658
659      # --- ステップ 3: ボードの情報を反映 ---
660      # 既にボード上でプレイされているカードの情報を知識に反映させることで、プレイ済みのカードの可能性を減らす
661      # self.print_log(f"board:{board}")
662      for col in self.game_ins.game_const.ALL_COLORS:
663          for i in range(board[col]):
664              if which[col][i] > 0:
665                  which[col][i] -= 1
666
667      # self.print_log(f"which without board:{which}")
668
669      # --- ステップ 4: 残りの可能性を計算 ---
670      # カードがどの色・ランクである可能性が残っているかを計算する
671      possibilities = sum(map(sum, which))
672      # self.print_log(f"possibilities:{possibilities}")
673      expected = 0  # 期待値を初期化（このアクションの価値を評価するためのもの）
674      terms = []  # 各計算の詳細を保持するリスト
675
676      # --- ステップ 5: 各カードの価値を評価 ---
677      # 各色とランクに対して、カードの可能性を評価し、期待値を計算
678      for col in self.game_ins.game_const.ALL_COLORS:
679          for i, cnt in enumerate(which[col]):
680              rank = i + 1  # ランクは0から始まるため、1を加えて調整
681              if cnt > 0:  # カードがそのランクである可能性がある場合のみ評価
682                  prob = cnt * 1.0 / possibilities  # このカードがそのランクである確率を計算
683                  if board[col] >= rank:
684                      # 既にボード上にあるカードよりも低いランクの場合、価値を加算
685                      # この場合は捨てても問題ないので、正の価値として考慮
686                      expected += prob * HINT_VALUE
687                      terms.append((col, rank, cnt, prob, prob * HINT_VALUE))
688                  else:
689                      # プレイ可能なカードの場合、距離に応じて価値を減少させる
690                      dist = rank - board[col]  # 現在のボードからの距離を計算
691                      if cnt > 1:
692                          # カードの数が複数ある場合、距離の二乗で割ることで価値を減少させる
693                          value = prob * (6 - rank) / (dist * dist)
694                      else:
695                          # カードが1枚しかない場合の価値
696                          value = (6 - rank)
697                      if rank == 5:
698                          # ランクが5の場合は追加の価値を加算（重要なカードであるため）
699                          value += HINT_VALUE
700                      value *= prob  # 確率に基づいて価値を調整
701                      expected -= value  # 期待値から減算（捨てることによるリスクを考慮）
702                      terms.append((col, rank, cnt, prob, -value))
703      
704      # --- ステップ 6: 結果を返す ---
705      # 捨てるアクション、期待される価値、詳細な評価結果を返す
706      return (act, expected, terms)