class_name RLNumericObservationEncoder extends RefCounted const SCHEMA_VERSION := 1 const ACTION_ID_MODE := "state_local_cards" const BOARD_CHANNEL_COUNT := 12 const BOARD_SQUARE_COUNT := 64 const HAND_FEATURE_COUNT := 3 const EFFECT_FEATURE_COUNT := 2 const EFFECT_SLOT_NAMES: Array[String] = [ "extended_range", "temporary_monarch", ] const SCALAR_NAMES: Array[String] = [ "current_turn", "game_over", "winner", "white_health", "black_health", "friendly_health", "enemy_health", "friendly_material", "enemy_material", "friendly_king_threatened", "enemy_king_threatened", "has_moved_piece_this_turn", "cards_used_this_turn", "max_cards_per_turn", "card_actions_enabled", "pending_card_credit_count", ] const HAND_FEATURE_NAMES: Array[String] = [ "card_index", "rarity", "is_playable", ] const EFFECT_FEATURE_NAMES: Array[String] = [ "active", "turns_remaining", ] func observation_size(hand_size: int = 5) -> int: return ( BOARD_CHANNEL_COUNT * BOARD_SQUARE_COUNT + SCALAR_NAMES.size() + hand_size * HAND_FEATURE_COUNT + EFFECT_SLOT_NAMES.size() * EFFECT_FEATURE_COUNT ) func schema(hand_size: int = 5) -> Dictionary: var board_offset: int = 0 var scalar_offset: int = board_offset + BOARD_CHANNEL_COUNT * BOARD_SQUARE_COUNT var hand_offset: int = scalar_offset + SCALAR_NAMES.size() var effect_offset: int = hand_offset + hand_size * HAND_FEATURE_COUNT return { "schema_version": SCHEMA_VERSION, "observation_size": observation_size(hand_size), "action_id_mode": ACTION_ID_MODE, "layout": { "board_channels": { "offset": board_offset, "size": BOARD_CHANNEL_COUNT * BOARD_SQUARE_COUNT, "channels": BOARD_CHANNEL_COUNT, "squares": BOARD_SQUARE_COUNT, "order": "friendly pawn,knight,bishop,rook,queen,king then enemy pawn,knight,bishop,rook,queen,king", }, "scalars": { "offset": scalar_offset, "size": SCALAR_NAMES.size(), "names": SCALAR_NAMES, }, "hand": { "offset": hand_offset, "size": hand_size * HAND_FEATURE_COUNT, "hand_size": hand_size, "features_per_slot": HAND_FEATURE_COUNT, "feature_names": HAND_FEATURE_NAMES, }, "effects": { "offset": effect_offset, "size": EFFECT_SLOT_NAMES.size() * EFFECT_FEATURE_COUNT, "slots": EFFECT_SLOT_NAMES, "features_per_slot": EFFECT_FEATURE_COUNT, "feature_names": EFFECT_FEATURE_NAMES, }, }, } func encode(observation: Dictionary, hand_size: int = 5) -> Array[float]: var vector: Array[float] = [] vector.resize(observation_size(hand_size)) vector.fill(0.0) var offset: int = 0 offset = _write_board_channels(vector, offset, observation.get("board_channels", [])) offset = _write_scalars(vector, offset, observation) offset = _write_hand(vector, offset, observation.get("hand", []), hand_size) _write_effects(vector, offset, observation.get("active_effects", [])) return vector func _write_board_channels(vector: Array[float], offset: int, raw_channels: Variant) -> int: var channels: Array = [] if raw_channels is Array: channels = raw_channels for channel_index in range(BOARD_CHANNEL_COUNT): var channel_data: Variant = null if channel_index < channels.size(): channel_data = channels[channel_index] for square_index in range(BOARD_SQUARE_COUNT): vector[offset] = _channel_value(channel_data, square_index) offset += 1 return offset func _write_scalars(vector: Array[float], offset: int, observation: Dictionary) -> int: var state: Dictionary = {} if observation.get("state", {}) is Dictionary: state = observation.get("state", {}) vector[offset] = _as_float(state.get("current_turn", 0)) offset += 1 vector[offset] = _as_float(state.get("game_over", false)) offset += 1 vector[offset] = _as_float(state.get("winner", -1), -1.0) offset += 1 vector[offset] = _as_float(state.get("white_health", 0)) offset += 1 vector[offset] = _as_float(state.get("black_health", 0)) offset += 1 vector[offset] = _as_float(state.get("friendly_health", 0)) offset += 1 vector[offset] = _as_float(state.get("enemy_health", 0)) offset += 1 vector[offset] = _as_float(state.get("friendly_material", 0)) offset += 1 vector[offset] = _as_float(state.get("enemy_material", 0)) offset += 1 vector[offset] = _as_float(state.get("friendly_king_threatened", false)) offset += 1 vector[offset] = _as_float(state.get("enemy_king_threatened", false)) offset += 1 vector[offset] = _as_float(state.get("has_moved_piece_this_turn", false)) offset += 1 vector[offset] = _as_float(observation.get("cards_used_this_turn", 0)) offset += 1 vector[offset] = _as_float(observation.get("max_cards_per_turn", 0)) offset += 1 vector[offset] = _as_float(observation.get("card_actions_enabled", false)) offset += 1 vector[offset] = _as_float(observation.get("pending_card_credit_count", 0)) offset += 1 return offset func _write_hand( vector: Array[float], offset: int, raw_hand: Variant, hand_size: int ) -> int: var hand: Array = [] if raw_hand is Array: hand = raw_hand for hand_index in range(hand_size): var entry: Dictionary = {} if hand_index < hand.size() and hand[hand_index] is Dictionary: entry = hand[hand_index] vector[offset] = _as_float(entry.get("card_index", -1), -1.0) offset += 1 vector[offset] = _as_float(entry.get("rarity", -1), -1.0) offset += 1 vector[offset] = _as_float(entry.get("is_playable", false)) offset += 1 return offset func _write_effects(vector: Array[float], offset: int, raw_effects: Variant) -> int: var effect_offsets: Dictionary = {} for slot_index in range(EFFECT_SLOT_NAMES.size()): effect_offsets[slot_index] = offset + slot_index * EFFECT_FEATURE_COUNT var effects: Array = [] if raw_effects is Array: effects = raw_effects for raw_effect in effects: if not (raw_effect is Dictionary): continue var effect: Dictionary = raw_effect var slot_index: int = _effect_slot_index(str(effect.get("effect", ""))) if slot_index < 0: continue var slot_offset: int = int(effect_offsets[slot_index]) vector[slot_offset] = 1.0 vector[slot_offset + 1] = maxf( vector[slot_offset + 1], _as_float(effect.get("turns_remaining", 0)) ) return offset + EFFECT_SLOT_NAMES.size() * EFFECT_FEATURE_COUNT func _channel_value(channel_data: Variant, square_index: int) -> float: if channel_data is PackedInt32Array: var int_channel: PackedInt32Array = channel_data if square_index < int_channel.size(): return float(int_channel[square_index]) if channel_data is PackedFloat32Array: var float_channel: PackedFloat32Array = channel_data if square_index < float_channel.size(): return float(float_channel[square_index]) if channel_data is Array: var array_channel: Array = channel_data if square_index < array_channel.size(): return _as_float(array_channel[square_index]) return 0.0 func _effect_slot_index(effect_name: String) -> int: var normalized: String = effect_name.to_lower() if normalized.find("extended") >= 0 or normalized.find("range") >= 0: return 0 if normalized.find("temporary") >= 0 or normalized.find("monarch") >= 0: return 1 return -1 func _as_float(value: Variant, default_value: float = 0.0) -> float: if value == null: return default_value if value is bool: return 1.0 if bool(value) else 0.0 if value is int or value is float: return float(value) return default_value