rimlike/scenes/ai/doctor_provider.gd

class_name DoctorProvider extends WorkProvider
## WorkProvider for the Doctor work category. Slots into the 5-layer pawn AI
## (Decision → WorkProvider → Job + JobRunner) at priority 9 — above sleep (8)
## so able-bodied doctors volunteer for rescue before their own rest.
## Phase 17 will expose this via the work-priority matrix so the player can
## set individual pawns to Doctor=Off.
##
## Rescue model (Phase 9):
##   A doctor pawn picks the nearest downed pawn that has no doctor already
##   assigned to them.  The job is a 4-toil sequence:
##     1. walk_to(patient.tile)    — doctor walks to the downed pawn
##     2. rescue(patient_path)     — single-tick marker (doctor "arrived")
##     3. walk_to(medical_bed.tile)— doctor walks to the nearest medical bed
##     4. treat(patient_path)      — multi-tick: snap patient to bed, heal until
##                                   HP ≥ 50 AND not bleeding, or 600-tick timeout
##
## Phase 9 simplification: the patient is teleported to the bed on the first
## tick of the treat toil (no carry visual). Phase 17 may add a proper carry
## animation and render the patient following the doctor during the walk.
##
## Bed preference: medical beds (is_medical=true) over regular beds.
## Fallback: any available bed if no medical bed exists.
## Hard fail: if no bed is available at all, the job is not issued and
## Audit.log records the skip so the developer can see the bottleneck.
##
## Pawn and Bed are intentionally duck-typed to avoid the class_name
## registration-order trap documented in Phase 2/3.
##
## docs/architecture.md "Doctor work — Downed priority"
## docs/design.md "Downed & death"


func _init() -> void:
	category = &"doctor"
	# Priority 9 > sleep (8) > eat (7) > construction (6) > …
	# Above sleep: saving a downed pawn beats the doctor's personal rest need.
	# Phase 17 may let the player tune this per-pawn via the work-priority matrix.
	priority = 9


# ── WorkProvider override ─────────────────────────────────────────────────────

## Returns a 4-toil rescue Job for `pawn`, or null if there is nothing to do.
##
## `pawn` is duck-typed: must expose .is_downed(), .carried_item, .tile,
## .pawn_name, and .get_path().
func find_best_for(pawn) -> Job:
	# Downed pawns can't doctor (Decision Layer 1 also blocks them via
	# is_incapacitated(); this guard is belt-and-suspenders).
	if pawn.has_method("is_downed") and pawn.is_downed():
		return null

	# Don't interrupt an active carry — finish hauling first.
	if pawn.carried_item != null:
		return null

	# Find the nearest downed pawn that isn't this pawn and has no other doctor
	# already assigned (prevents two doctors converging on one wounded pawn).
	var best_patient = null
	var best_dist: int = 999999
	for p in World.pawns:
		if not p.has_method("is_downed") or not p.is_downed():
			continue
		if p == pawn:
			continue
		if Job.is_target_taken_by_other(p, pawn):
			continue
		var d: int = abs(p.tile.x - pawn.tile.x) + abs(p.tile.y - pawn.tile.y)
		if d < best_dist:
			best_dist = d
			best_patient = p

	if best_patient == null:
		return null

	# Find the nearest available medical bed (preferred) or any available bed.
	var medical_bed = _find_best_bed()
	if medical_bed == null:
		Audit.log(
			"doctor",
			"%s: no bed available for %s — rescue skipped" % [pawn.pawn_name, best_patient.pawn_name]
		)
		return null

	var j := Job.new()
	j.label = "Rescue %s → bed at %s" % [best_patient.pawn_name, medical_bed.tile]
	j.target_node = best_patient
	# 4-toil sequence per the doctor rescue model above.
	j.toils.append(Toil.walk_to(best_patient.tile))
	j.toils.append(Toil.rescue(best_patient.get_path()))
	j.toils.append(Toil.walk_to(medical_bed.tile))
	j.toils.append(Toil.treat(best_patient.get_path()))
	return j


# ── helpers ───────────────────────────────────────────────────────────────────

## Returns the best available bed for medical treatment.
## Prefers beds with is_medical=true; falls back to any available bed.
## Returns null when no bed is available at all.
func _find_best_bed():
	# First pass: look for a medical bed.
	for bed in World.beds:
		if not bed.is_available():
			continue
		if bed.get("is_medical") == true:
			return bed
	# Second pass: accept any available bed if no medical bed was found.
	for bed in World.beds:
		if bed.is_available():
			return bed
	return null