Datasets:
Download metadata/reference/Scripts/ai/rl/RLObservationEncoder.gd from Adocrafter/Chessovania: direct link, hf CLI and curl.
- Browser
- Download file 7.74 kB
-
https://huggingface.co/datasets/Adocrafter/Chessovania/resolve/main/metadata/reference/Scripts/ai/rl/RLObservationEncoder.gd
- Command line
-
hf download hf://datasets/Adocrafter/Chessovania/metadata/reference/Scripts/ai/rl/RLObservationEncoder.gd
-
curl -L -o RLObservationEncoder.gd https://huggingface.co/datasets/Adocrafter/Chessovania/resolve/main/metadata/reference/Scripts/ai/rl/RLObservationEncoder.gd
7.74 kB
| class_name RLObservationEncoder | |
| extends RefCounted | |
| const PIECE_ORDER := ["pawn", "knight", "bishop", "rook", "queen", "king"] | |
| const MATERIAL_VALUES := { | |
| "pawn": 10, | |
| "knight": 30, | |
| "bishop": 40, | |
| "rook": 50, | |
| "queen": 90, | |
| "king": 0, | |
| } | |
| func encode( | |
| game_manager: GameManager, | |
| perspective_color: Piece.PieceColor, | |
| hand_size: int = 5 | |
| ) -> Dictionary: | |
| var state: Dictionary = capture_state(game_manager, perspective_color, hand_size) | |
| return { | |
| "state": state, | |
| "board_channels": _encode_board_channels(game_manager, perspective_color), | |
| "hand": _encode_hand(game_manager, perspective_color, hand_size), | |
| "active_effects": _encode_active_effects(game_manager), | |
| } | |
| func capture_state( | |
| game_manager: GameManager, | |
| perspective_color: Piece.PieceColor, | |
| hand_size: int = 5 | |
| ) -> Dictionary: | |
| var enemy_color: Piece.PieceColor = _opposite_color(perspective_color) | |
| return { | |
| "current_turn": game_manager.current_turn, | |
| "game_over": game_manager.game_over, | |
| "winner": _winner(game_manager), | |
| "white_health": game_manager.white_health, | |
| "black_health": game_manager.black_health, | |
| "friendly_health": _health_for(game_manager, perspective_color), | |
| "enemy_health": _health_for(game_manager, enemy_color), | |
| "friendly_material": _material_for(game_manager, perspective_color), | |
| "enemy_material": _material_for(game_manager, enemy_color), | |
| "friendly_king_threatened": _is_king_threatened(game_manager, perspective_color), | |
| "enemy_king_threatened": _is_king_threatened(game_manager, enemy_color), | |
| "has_moved_piece_this_turn": game_manager.has_moved_piece_this_turn, | |
| "forced_piece": _forced_piece_key(game_manager), | |
| "pieces": _piece_state(game_manager), | |
| "hand_ids": _hand_ids(game_manager, perspective_color, hand_size), | |
| "active_effects": _effect_state(game_manager), | |
| } | |
| func state_hash(state: Dictionary) -> String: | |
| return JSON.stringify(state).sha256_text() | |
| func capture_hash( | |
| game_manager: GameManager, | |
| perspective_color: Piece.PieceColor, | |
| hand_size: int = 5 | |
| ) -> String: | |
| return state_hash(capture_state(game_manager, perspective_color, hand_size)) | |
| func _encode_board_channels( | |
| game_manager: GameManager, | |
| perspective_color: Piece.PieceColor | |
| ) -> Array: | |
| var channels: Array = [] | |
| for _i in range(12): | |
| var channel: PackedInt32Array = PackedInt32Array() | |
| channel.resize(64) | |
| channels.append(channel) | |
| for piece in game_manager.board.pieces_by_position.values(): | |
| if not piece or not is_instance_valid(piece): | |
| continue | |
| var piece_index: int = PIECE_ORDER.find(piece.piece_type) | |
| if piece_index < 0: | |
| continue | |
| var color_offset: int = 0 if piece.piece_color == perspective_color else 6 | |
| var channel_index: int = color_offset + piece_index | |
| var square_index: int = piece.board_position.y * 8 + piece.board_position.x | |
| var channel: PackedInt32Array = channels[channel_index] | |
| channel[square_index] = 1 | |
| channels[channel_index] = channel | |
| return channels | |
| func _encode_hand( | |
| game_manager: GameManager, | |
| perspective_color: Piece.PieceColor, | |
| hand_size: int | |
| ) -> Array[Dictionary]: | |
| var result: Array[Dictionary] = [] | |
| var hand: Array = _hand_for(game_manager, perspective_color) | |
| for i in range(hand_size): | |
| if i >= hand.size(): | |
| result.append({ | |
| "card_id": "", | |
| "card_index": -1, | |
| "rarity": -1, | |
| "is_playable": false, | |
| }) | |
| continue | |
| var card_data: CardData = hand[i] as CardData | |
| var card_id: String = CardRegistry.get_card_id(card_data) | |
| result.append({ | |
| "card_id": card_id, | |
| "card_index": _card_index(card_id), | |
| "rarity": int(card_data.rarity) if card_data else -1, | |
| "is_playable": false, | |
| }) | |
| return result | |
| func _encode_active_effects(game_manager: GameManager) -> Array[Dictionary]: | |
| var result: Array[Dictionary] = [] | |
| if not game_manager.card_effect_system: | |
| return result | |
| for entry in game_manager.card_effect_system.active_effects: | |
| var effect: CardEffect = entry.get("effect", null) | |
| result.append({ | |
| "effect": _effect_key(effect), | |
| "turns_remaining": int(entry.get("turns_remaining", 0)), | |
| "permanent": bool(entry.get("permanent", false)), | |
| }) | |
| return result | |
| func _piece_state(game_manager: GameManager) -> Array[Dictionary]: | |
| var pieces: Array[Dictionary] = [] | |
| for piece in game_manager.board.pieces_by_position.values(): | |
| if not piece or not is_instance_valid(piece): | |
| continue | |
| pieces.append({ | |
| "type": piece.piece_type, | |
| "color": piece.piece_color, | |
| "x": piece.board_position.x, | |
| "y": piece.board_position.y, | |
| "has_moved": piece.has_moved, | |
| }) | |
| pieces.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: | |
| if int(a["y"]) != int(b["y"]): | |
| return int(a["y"]) < int(b["y"]) | |
| if int(a["x"]) != int(b["x"]): | |
| return int(a["x"]) < int(b["x"]) | |
| if int(a["color"]) != int(b["color"]): | |
| return int(a["color"]) < int(b["color"]) | |
| return str(a["type"]) < str(b["type"]) | |
| ) | |
| return pieces | |
| func _hand_ids( | |
| game_manager: GameManager, | |
| perspective_color: Piece.PieceColor, | |
| hand_size: int | |
| ) -> Array[String]: | |
| var ids: Array[String] = [] | |
| var hand: Array = _hand_for(game_manager, perspective_color) | |
| for i in range(hand_size): | |
| if i >= hand.size(): | |
| ids.append("") | |
| continue | |
| var card_data: CardData = hand[i] as CardData | |
| ids.append(CardRegistry.get_card_id(card_data)) | |
| return ids | |
| func _effect_state(game_manager: GameManager) -> Array[Dictionary]: | |
| var effects: Array[Dictionary] = _encode_active_effects(game_manager) | |
| effects.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: | |
| return str(a["effect"]) < str(b["effect"]) | |
| ) | |
| return effects | |
| func _hand_for(game_manager: GameManager, color: Piece.PieceColor) -> Array: | |
| if not game_manager.card_manager: | |
| return [] | |
| if color == Piece.PieceColor.WHITE: | |
| return game_manager.card_manager.hand_white | |
| return game_manager.card_manager.hand_black | |
| func _material_for(game_manager: GameManager, color: Piece.PieceColor) -> int: | |
| var total: int = 0 | |
| for piece in game_manager.board.pieces_by_position.values(): | |
| if not piece or not is_instance_valid(piece) or piece.piece_color != color: | |
| continue | |
| total += int(MATERIAL_VALUES.get(piece.piece_type, 0)) | |
| return total | |
| func _health_for(game_manager: GameManager, color: Piece.PieceColor) -> int: | |
| if color == Piece.PieceColor.WHITE: | |
| return game_manager.white_health | |
| return game_manager.black_health | |
| func _is_king_threatened(game_manager: GameManager, color: Piece.PieceColor) -> bool: | |
| if not game_manager.chess_rules: | |
| return false | |
| var king: Piece = game_manager.chess_rules.get_king(color) | |
| if not king: | |
| return false | |
| return game_manager.chess_rules.is_square_attacked( | |
| king.board_position, | |
| _opposite_color(color) | |
| ) | |
| func _winner(game_manager: GameManager) -> int: | |
| if game_manager.white_health <= 0: | |
| return Piece.PieceColor.BLACK | |
| if game_manager.black_health <= 0: | |
| return Piece.PieceColor.WHITE | |
| return -1 | |
| func _forced_piece_key(game_manager: GameManager) -> String: | |
| if not game_manager.forced_piece or not is_instance_valid(game_manager.forced_piece): | |
| return "" | |
| var piece: Piece = game_manager.forced_piece | |
| return "%s:%d:%d:%d" % [ piece.piece_type, piece.piece_color, piece.board_position.x, piece.board_position.y, ] | |
| func _card_index(card_id: String) -> int: | |
| if card_id == "": | |
| return -1 | |
| var keys: Array[String] = CardRegistry.get_all_type_keys() | |
| keys.sort() | |
| return keys.find(card_id) | |
| func _effect_key(effect: CardEffect) -> String: | |
| if not effect: | |
| return "" | |
| var script: Script = effect.get_script() | |
| if script: | |
| var global_name: String = script.get_global_name() | |
| if global_name != "": | |
| return global_name | |
| return script.resource_path | |
| return effect.get_class() | |
| func _opposite_color(color: Piece.PieceColor) -> Piece.PieceColor: | |
| if color == Piece.PieceColor.WHITE: | |
| return Piece.PieceColor.BLACK | |
| return Piece.PieceColor.WHITE | |