gamedev-the-steward/simulation/definitions/ContentCatalog.gd

class_name ContentCatalog
extends RefCounted

const CORE_PACK_PATH := "res://simulation/definitions/packs/core.tres"

var _valid := false
var _errors: Array[String] = []
var _packs: Array[SimulationContentPack] = []
var _actions: Array[ActionDefinition] = []
var _professions: Array[ProfessionDefinition] = []
var _capability_tags: Array[CapabilityTagDefinition] = []
var _items: Array[ItemDefinition] = []
var _resources: Array[ResourceDefinition] = []
var _storages: Array[StorageDefinition] = []
var _enemies: Array[EnemyDefinition] = []
var _animals: Array[AnimalDefinition] = []
var _packs_by_id: Dictionary = {}
var _actions_by_id: Dictionary = {}
var _professions_by_id: Dictionary = {}
var _capability_tags_by_id: Dictionary = {}
var _items_by_id: Dictionary = {}
var _resources_by_id: Dictionary = {}
var _storages_by_id: Dictionary = {}
var _enemies_by_id: Dictionary = {}
var _animals_by_id: Dictionary = {}


static func create_core(
	supported_handler_ids: Array[StringName] = [],
	supported_presentation_cue_ids: Array[StringName] = []
) -> ContentCatalog:
	var catalog := ContentCatalog.new()
	var pack := load(CORE_PACK_PATH) as SimulationContentPack
	if pack == null:
		catalog._errors = ["Core content pack failed to load from '%s'" % CORE_PACK_PATH]
		return catalog
	var packs: Array[SimulationContentPack] = [pack]
	catalog.rebuild(packs, supported_handler_ids, supported_presentation_cue_ids)
	return catalog


func rebuild(
	content_packs: Array[SimulationContentPack],
	supported_handler_ids: Array[StringName] = [],
	supported_presentation_cue_ids: Array[StringName] = []
) -> Array[String]:
	_clear_published_content()
	var errors: Array[String] = []
	var pack_list := content_packs.duplicate()
	pack_list.sort_custom(_sort_packs)
	var supported_handlers := {}
	for handler_id in supported_handler_ids:
		if handler_id.is_empty():
			errors.append("Supported handler ID is empty")
		elif supported_handlers.has(handler_id):
			errors.append("Duplicate supported handler '%s'" % handler_id)
		else:
			supported_handlers[handler_id] = true
	var cue_ids := (
		supported_presentation_cue_ids
		if not supported_presentation_cue_ids.is_empty()
		else PresentationCueIds.get_all()
	)
	var supported_cues := {}
	for cue_id in cue_ids:
		if cue_id.is_empty():
			errors.append("Supported presentation cue ID is empty")
		elif supported_cues.has(cue_id):
			errors.append("Duplicate supported presentation cue '%s'" % cue_id)
		else:
			supported_cues[cue_id] = true

	var packs_by_id := {}
	var actions_by_id := {}
	var professions_by_id := {}
	var capability_tags_by_id := {}
	var items_by_id := {}
	var resources_by_id := {}
	var storages_by_id := {}
	var enemies_by_id := {}
	var animals_by_id := {}
	var actions: Array[ActionDefinition] = []
	var professions: Array[ProfessionDefinition] = []
	var capability_tags: Array[CapabilityTagDefinition] = []
	var items: Array[ItemDefinition] = []
	var resources: Array[ResourceDefinition] = []
	var storages: Array[StorageDefinition] = []
	var enemies: Array[EnemyDefinition] = []
	var animals: Array[AnimalDefinition] = []

	for pack in pack_list:
		if pack == null:
			errors.append("Content pack list contains a null pack")
			continue
		for error in pack.validate():
			errors.append("Pack '%s': %s" % [pack.pack_id, error])
		if packs_by_id.has(pack.pack_id):
			errors.append("Duplicate pack_id '%s'" % pack.pack_id)
		else:
			packs_by_id[pack.pack_id] = pack
		_collect_actions(pack, actions, actions_by_id, errors)
		_collect_professions(pack, professions, professions_by_id, errors)
		_collect_capability_tags(pack, capability_tags, capability_tags_by_id, errors)
		_collect_items(pack, items, items_by_id, errors)
		_collect_resources(pack, resources, resources_by_id, errors)
		_collect_storages(pack, storages, storages_by_id, errors)
		_collect_enemies(pack, enemies, enemies_by_id, errors)
		_collect_animals(pack, animals, animals_by_id, errors)

	for pack in pack_list:
		if pack == null:
			continue
		for required_pack_id in pack.required_pack_ids:
			if not required_pack_id.is_empty() and not packs_by_id.has(required_pack_id):
				errors.append(
					(
						"Pack '%s' references unknown required pack '%s'"
						% [pack.pack_id, required_pack_id]
					)
				)
		for required_handler_id in pack.required_handler_ids:
			if (
				not required_handler_id.is_empty()
				and not supported_handlers.has(required_handler_id)
			):
				errors.append(
					(
						"Pack '%s' references unknown required handler '%s'"
						% [pack.pack_id, required_handler_id]
					)
				)

	_validate_action_references(
		actions,
		actions_by_id,
		professions_by_id,
		items_by_id,
		capability_tags_by_id,
		supported_handlers,
		supported_cues,
		errors
	)
	_validate_item_references(items, capability_tags_by_id, supported_cues, errors)
	_validate_resource_references(
		resources, items_by_id, actions_by_id, capability_tags_by_id, supported_cues, errors
	)
	_validate_storage_references(
		storages, items_by_id, actions_by_id, capability_tags_by_id, supported_cues, errors
	)
	_validate_enemy_references(enemies, items_by_id, errors)
	_validate_animal_references(animals, actions_by_id, errors)
	errors.sort()
	_errors = errors
	if not errors.is_empty():
		return get_errors()

	actions.sort_custom(_sort_actions)
	professions.sort_custom(_sort_professions)
	capability_tags.sort_custom(_sort_capability_tags)
	items.sort_custom(_sort_items)
	resources.sort_custom(_sort_resources)
	storages.sort_custom(_sort_storages)
	enemies.sort_custom(_sort_enemies)
	animals.sort_custom(_sort_animals)
	_packs = pack_list
	_actions = actions
	_professions = professions
	_capability_tags = capability_tags
	_items = items
	_resources = resources
	_storages = storages
	_enemies = enemies
	_animals = animals
	_packs_by_id = packs_by_id
	_actions_by_id = actions_by_id
	_professions_by_id = professions_by_id
	_capability_tags_by_id = capability_tags_by_id
	_items_by_id = items_by_id
	_resources_by_id = resources_by_id
	_storages_by_id = storages_by_id
	_enemies_by_id = enemies_by_id
	_animals_by_id = animals_by_id
	_valid = true
	return []


func is_valid() -> bool:
	return _valid


func get_errors() -> Array[String]:
	return _errors.duplicate()


func get_packs() -> Array[SimulationContentPack]:
	return _packs.duplicate()


func get_actions() -> Array[ActionDefinition]:
	return _actions.duplicate()


func get_professions() -> Array[ProfessionDefinition]:
	return _professions.duplicate()


func get_capability_tags() -> Array[CapabilityTagDefinition]:
	return _capability_tags.duplicate()


func get_items() -> Array[ItemDefinition]:
	return _items.duplicate()


func get_resources() -> Array[ResourceDefinition]:
	return _resources.duplicate()


func get_storages() -> Array[StorageDefinition]:
	return _storages.duplicate()


func get_enemies() -> Array[EnemyDefinition]:
	return _enemies.duplicate()


func get_animals() -> Array[AnimalDefinition]:
	return _animals.duplicate()


func get_pack(pack_id: StringName) -> SimulationContentPack:
	return _packs_by_id.get(pack_id) as SimulationContentPack


func get_action(action_id: StringName) -> ActionDefinition:
	return _actions_by_id.get(action_id) as ActionDefinition


func get_profession(profession_id: StringName) -> ProfessionDefinition:
	return _professions_by_id.get(profession_id) as ProfessionDefinition


func get_capability_tag(tag_id: StringName) -> CapabilityTagDefinition:
	return _capability_tags_by_id.get(tag_id) as CapabilityTagDefinition


func get_item(item_id: StringName) -> ItemDefinition:
	return _items_by_id.get(item_id) as ItemDefinition


func get_resource(resource_id: StringName) -> ResourceDefinition:
	return _resources_by_id.get(resource_id) as ResourceDefinition


func get_storage(storage_id: StringName) -> StorageDefinition:
	return _storages_by_id.get(storage_id) as StorageDefinition


func get_enemy(enemy_id: StringName) -> EnemyDefinition:
	return _enemies_by_id.get(enemy_id) as EnemyDefinition


func get_animal(animal_definition_id: StringName) -> AnimalDefinition:
	return _animals_by_id.get(animal_definition_id) as AnimalDefinition


func get_authoring_report() -> Dictionary:
	return {
		"valid": _valid,
		"errors": get_errors(),
		"packs": _ids_for(_packs, &"pack_id"),
		"actions": _ids_for(_actions, &"action_id"),
		"professions": _ids_for(_professions, &"profession_id"),
		"capability_tags": _ids_for(_capability_tags, &"tag_id"),
		"items": _ids_for(_items, &"item_id"),
		"resources": _ids_for(_resources, &"resource_id"),
		"storages": _ids_for(_storages, &"storage_id"),
		"enemies": _ids_for(_enemies, &"enemy_id"),
		"animals": _ids_for(_animals, &"animal_definition_id"),
	}


func _clear_published_content() -> void:
	_valid = false
	_errors.clear()
	_packs.clear()
	_actions.clear()
	_professions.clear()
	_capability_tags.clear()
	_items.clear()
	_resources.clear()
	_storages.clear()
	_enemies.clear()
	_animals.clear()
	_packs_by_id.clear()
	_actions_by_id.clear()
	_professions_by_id.clear()
	_capability_tags_by_id.clear()
	_items_by_id.clear()
	_resources_by_id.clear()
	_storages_by_id.clear()
	_enemies_by_id.clear()
	_animals_by_id.clear()


static func _collect_actions(
	pack: SimulationContentPack,
	definitions: Array[ActionDefinition],
	definitions_by_id: Dictionary,
	errors: Array[String]
) -> void:
	for definition in pack.actions:
		if definition == null:
			continue
		if definitions_by_id.has(definition.action_id):
			errors.append("Duplicate action_id '%s'" % definition.action_id)
			continue
		definitions_by_id[definition.action_id] = definition
		definitions.append(definition)


static func _collect_professions(
	pack: SimulationContentPack,
	definitions: Array[ProfessionDefinition],
	definitions_by_id: Dictionary,
	errors: Array[String]
) -> void:
	for definition in pack.professions:
		if definition == null:
			continue
		if definitions_by_id.has(definition.profession_id):
			errors.append("Duplicate profession_id '%s'" % definition.profession_id)
			continue
		definitions_by_id[definition.profession_id] = definition
		definitions.append(definition)


static func _collect_items(
	pack: SimulationContentPack,
	definitions: Array[ItemDefinition],
	definitions_by_id: Dictionary,
	errors: Array[String]
) -> void:
	for definition in pack.items:
		if definition == null:
			continue
		if definitions_by_id.has(definition.item_id):
			errors.append("Duplicate item_id '%s'" % definition.item_id)
			continue
		definitions_by_id[definition.item_id] = definition
		definitions.append(definition)


static func _collect_capability_tags(
	pack: SimulationContentPack,
	definitions: Array[CapabilityTagDefinition],
	definitions_by_id: Dictionary,
	errors: Array[String]
) -> void:
	for definition in pack.capability_tags:
		if definition == null:
			continue
		if definitions_by_id.has(definition.tag_id):
			errors.append("Duplicate tag_id '%s'" % definition.tag_id)
			continue
		definitions_by_id[definition.tag_id] = definition
		definitions.append(definition)


static func _collect_resources(
	pack: SimulationContentPack,
	definitions: Array[ResourceDefinition],
	definitions_by_id: Dictionary,
	errors: Array[String]
) -> void:
	for definition in pack.resources:
		if definition == null:
			continue
		if definitions_by_id.has(definition.resource_id):
			errors.append("Duplicate resource_id '%s'" % definition.resource_id)
			continue
		definitions_by_id[definition.resource_id] = definition
		definitions.append(definition)


static func _collect_storages(
	pack: SimulationContentPack,
	definitions: Array[StorageDefinition],
	definitions_by_id: Dictionary,
	errors: Array[String]
) -> void:
	for definition in pack.storages:
		if definition == null:
			continue
		if definitions_by_id.has(definition.storage_id):
			errors.append("Duplicate storage_id '%s'" % definition.storage_id)
			continue
		definitions_by_id[definition.storage_id] = definition
		definitions.append(definition)


static func _collect_enemies(
	pack: SimulationContentPack,
	definitions: Array[EnemyDefinition],
	definitions_by_id: Dictionary,
	errors: Array[String]
) -> void:
	for definition in pack.enemies:
		if definition == null:
			continue
		if definitions_by_id.has(definition.enemy_id):
			errors.append("Duplicate enemy_id '%s'" % definition.enemy_id)
			continue
		definitions_by_id[definition.enemy_id] = definition
		definitions.append(definition)


static func _collect_animals(
	pack: SimulationContentPack,
	definitions: Array[AnimalDefinition],
	definitions_by_id: Dictionary,
	errors: Array[String]
) -> void:
	for definition in pack.animals:
		if definition == null:
			continue
		if definitions_by_id.has(definition.animal_definition_id):
			errors.append("Duplicate animal_definition_id '%s'" % definition.animal_definition_id)
			continue
		definitions_by_id[definition.animal_definition_id] = definition
		definitions.append(definition)


static func _validate_action_references(
	actions: Array[ActionDefinition],
	actions_by_id: Dictionary,
	professions_by_id: Dictionary,
	items_by_id: Dictionary,
	capability_tags_by_id: Dictionary,
	supported_handlers: Dictionary,
	supported_cues: Dictionary,
	errors: Array[String]
) -> void:
	for definition in actions:
		_validate_tag_ids(
			"Action '%s' actor" % definition.action_id,
			definition.actor_capability_tags,
			CapabilityTagDefinition.DOMAIN_ACTOR,
			capability_tags_by_id,
			errors
		)
		_validate_tag_ids(
			"Action '%s' target" % definition.action_id,
			definition.target_capability_tags,
			CapabilityTagDefinition.DOMAIN_TARGET,
			capability_tags_by_id,
			errors
		)
		_validate_presentation_cue(
			"Action '%s'" % definition.action_id,
			definition.presentation_cue_id,
			supported_cues,
			errors
		)
		for handler_field in [
			["selection policy", definition.selection_policy_id],
			["target policy", definition.target_policy_id],
			["completion handler", definition.completion_handler_id],
		]:
			var handler_id: StringName = handler_field[1]
			if not handler_id.is_empty() and not supported_handlers.has(handler_id):
				errors.append(
					(
						"Action '%s' references unknown %s '%s'"
						% [definition.action_id, handler_field[0], handler_id]
					)
				)
		if (
			not definition.preferred_profession_id.is_empty()
			and not professions_by_id.has(definition.preferred_profession_id)
		):
			errors.append(
				(
					"Action '%s' references unknown profession '%s'"
					% [definition.action_id, definition.preferred_profession_id]
				)
			)
		if (
			definition.target_type == SimulationIds.TARGET_RESOURCE
			and not actions_by_id.has(definition.resource_action_id)
		):
			errors.append(
				(
					"Action '%s' references unknown resource action '%s'"
					% [definition.action_id, definition.resource_action_id]
				)
			)
		if (
			not definition.completion_cost_resource_id.is_empty()
			and not items_by_id.has(definition.completion_cost_resource_id)
		):
			errors.append(
				(
					"Action '%s' references unknown completion cost item '%s'"
					% [definition.action_id, definition.completion_cost_resource_id]
				)
			)
		elif not definition.completion_cost_resource_id.is_empty():
			var cost_item := (
				items_by_id.get(definition.completion_cost_resource_id) as ItemDefinition
			)
			if cost_item != null and not cost_item.is_resource():
				errors.append(
					(
						"Action '%s' references non-resource completion cost item '%s'"
						% [definition.action_id, definition.completion_cost_resource_id]
					)
				)
		for effect in definition.effects:
			if effect == null:
				continue
			var effect_item_id: StringName = effect.get("item_id")
			if not effect_item_id.is_empty() and not items_by_id.has(effect_item_id):
				errors.append(
					(
						"Action '%s' effect references unknown item '%s'"
						% [definition.action_id, effect_item_id]
					)
				)
			var scheduled_action_id: StringName = effect.get("scheduled_action_id")
			if not scheduled_action_id.is_empty() and not actions_by_id.has(scheduled_action_id):
				errors.append(
					(
						"Action '%s' effect references unknown action '%s'"
						% [definition.action_id, scheduled_action_id]
					)
				)


static func _validate_item_references(
	items: Array[ItemDefinition],
	capability_tags_by_id: Dictionary,
	supported_cues: Dictionary,
	errors: Array[String]
) -> void:
	for definition in items:
		_validate_tag_ids(
			"Item '%s'" % definition.item_id,
			definition.capability_tag_ids,
			CapabilityTagDefinition.DOMAIN_ITEM,
			capability_tags_by_id,
			errors
		)
		_validate_presentation_cue(
			"Item '%s'" % definition.item_id, definition.presentation_cue_id, supported_cues, errors
		)


static func _validate_resource_references(
	resources: Array[ResourceDefinition],
	items_by_id: Dictionary,
	actions_by_id: Dictionary,
	capability_tags_by_id: Dictionary,
	supported_cues: Dictionary,
	errors: Array[String]
) -> void:
	for definition in resources:
		var item := items_by_id.get(definition.item_id) as ItemDefinition
		if item == null:
			errors.append(
				(
					"Resource '%s' references unknown item '%s'"
					% [definition.resource_id, definition.item_id]
				)
			)
		elif not item.is_resource():
			errors.append(
				(
					"Resource '%s' references non-resource item '%s'"
					% [definition.resource_id, definition.item_id]
				)
			)
		var action := actions_by_id.get(definition.extraction_action_id) as ActionDefinition
		if action == null:
			errors.append(
				(
					"Resource '%s' references unknown action '%s'"
					% [definition.resource_id, definition.extraction_action_id]
				)
			)
		elif action.target_type != SimulationIds.TARGET_RESOURCE:
			errors.append(
				(
					"Resource '%s' references non-resource-target action '%s'"
					% [definition.resource_id, definition.extraction_action_id]
				)
			)
		_validate_tag_ids(
			"Resource '%s'" % definition.resource_id,
			definition.capability_tag_ids,
			CapabilityTagDefinition.DOMAIN_RESOURCE,
			capability_tags_by_id,
			errors
		)
		_validate_presentation_cue(
			"Resource '%s'" % definition.resource_id,
			definition.presentation_cue_id,
			supported_cues,
			errors
		)


static func _validate_storage_references(
	storages: Array[StorageDefinition],
	items_by_id: Dictionary,
	actions_by_id: Dictionary,
	capability_tags_by_id: Dictionary,
	supported_cues: Dictionary,
	errors: Array[String]
) -> void:
	for definition in storages:
		for item_id in definition.accepted_item_ids:
			var item := items_by_id.get(item_id) as ItemDefinition
			if item == null:
				errors.append(
					"Storage '%s' references unknown item '%s'" % [definition.storage_id, item_id]
				)
			elif not item.is_resource():
				errors.append(
					"Storage '%s' accepts non-resource item '%s'" % [definition.storage_id, item_id]
				)
		_validate_tag_ids(
			"Storage '%s' accepted item" % definition.storage_id,
			definition.accepted_item_tag_ids,
			CapabilityTagDefinition.DOMAIN_ITEM,
			capability_tags_by_id,
			errors
		)
		_validate_tag_ids(
			"Storage '%s'" % definition.storage_id,
			definition.capability_tag_ids,
			CapabilityTagDefinition.DOMAIN_STORAGE,
			capability_tags_by_id,
			errors
		)
		for action_id in [definition.deposit_action_id, definition.withdrawal_action_id]:
			if not action_id.is_empty() and not actions_by_id.has(action_id):
				errors.append(
					(
						"Storage '%s' references unknown action '%s'"
						% [definition.storage_id, action_id]
					)
				)
		_validate_presentation_cue(
			"Storage '%s'" % definition.storage_id,
			definition.presentation_cue_id,
			supported_cues,
			errors
		)


static func _validate_tag_ids(
	owner: String,
	tag_ids: Array[StringName],
	expected_domain: StringName,
	capability_tags_by_id: Dictionary,
	errors: Array[String]
) -> void:
	for tag_id in tag_ids:
		var tag := capability_tags_by_id.get(tag_id) as CapabilityTagDefinition
		if tag == null:
			errors.append("%s references unknown tag '%s'" % [owner, tag_id])
		elif tag.domain != expected_domain:
			errors.append(
				(
					"%s references '%s' tag '%s' where '%s' is required"
					% [owner, tag.domain, tag_id, expected_domain]
				)
			)


static func _validate_presentation_cue(
	owner: String, cue_id: StringName, supported_cues: Dictionary, errors: Array[String]
) -> void:
	if not cue_id.is_empty() and not supported_cues.has(cue_id):
		errors.append("%s references unknown presentation cue '%s'" % [owner, cue_id])


static func _validate_enemy_references(
	enemies: Array[EnemyDefinition], items_by_id: Dictionary, errors: Array[String]
) -> void:
	for definition in enemies:
		var weapon := items_by_id.get(definition.weapon_id) as ItemDefinition
		if weapon == null:
			errors.append(
				(
					"Enemy '%s' references unknown weapon '%s'"
					% [definition.enemy_id, definition.weapon_id]
				)
			)
		elif not weapon.is_weapon():
			errors.append(
				(
					"Enemy '%s' references non-weapon item '%s'"
					% [definition.enemy_id, definition.weapon_id]
				)
			)


static func _validate_animal_references(
	animals: Array[AnimalDefinition], actions_by_id: Dictionary, errors: Array[String]
) -> void:
	for definition in animals:
		for action_id in definition.supported_action_ids:
			if not actions_by_id.has(action_id):
				errors.append(
					(
						"Animal '%s' references unknown action '%s'"
						% [definition.animal_definition_id, action_id]
					)
				)


static func _sort_packs(first: SimulationContentPack, second: SimulationContentPack) -> bool:
	if first == null:
		return second != null
	if second == null:
		return false
	return String(first.pack_id) < String(second.pack_id)


static func _sort_actions(first: ActionDefinition, second: ActionDefinition) -> bool:
	return String(first.action_id) < String(second.action_id)


static func _sort_professions(first: ProfessionDefinition, second: ProfessionDefinition) -> bool:
	return String(first.profession_id) < String(second.profession_id)


static func _sort_capability_tags(
	first: CapabilityTagDefinition, second: CapabilityTagDefinition
) -> bool:
	return String(first.tag_id) < String(second.tag_id)


static func _sort_items(first: ItemDefinition, second: ItemDefinition) -> bool:
	return String(first.item_id) < String(second.item_id)


static func _sort_resources(first: ResourceDefinition, second: ResourceDefinition) -> bool:
	return String(first.resource_id) < String(second.resource_id)


static func _sort_storages(first: StorageDefinition, second: StorageDefinition) -> bool:
	return String(first.storage_id) < String(second.storage_id)


static func _sort_enemies(first: EnemyDefinition, second: EnemyDefinition) -> bool:
	return String(first.enemy_id) < String(second.enemy_id)


static func _sort_animals(first: AnimalDefinition, second: AnimalDefinition) -> bool:
	return String(first.animal_definition_id) < String(second.animal_definition_id)


static func _ids_for(definitions: Array, id_property: StringName) -> Array[StringName]:
	var ids: Array[StringName] = []
	for definition in definitions:
		ids.append(StringName(definition.get(id_property)))
	return ids