Chessovania / metadata /reference /Scripts /ai /rl /RLNumericObservationEncoder.gd
Adocrafter's picture
Upload of the Chessovania RL Dataset
765e9a2 verified
Raw History Blame Contribute Delete
7.36 kB
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