class_name HumanDB
## Die Erde: ein Stadtbezirk nach japanischem Vorbild. Weite Arterien in einem
## groben Raster spannen Blöcke auf. Am Blockrand stehen die Häuser direkt an
## der Straße, ohne Vorgarten. Ins Blockinnere führen schmale Sackgassen --
## roji --, an denen die hinteren Parzellen hängen. So entsteht die typische
## Mischung aus klarer Ordnung außen und Gewinkel innen.
##
## Anders als das Traumdorf wächst hier nichts: alle Menschen sind von Anfang
## an da und leben ihren Tag.

const EINWOHNER := 16
const ACHSEN := [-72.0, -24.0, 24.0, 72.0]   # Arterien in x wie in z
const ARTERIE := 7.0                          # Breite einer Arterie
const ROJI := 3.2                             # Breite einer Gasse
const RAND_TIEFE := 11.0                      # Tiefe der Parzellen an der Straße
const PARZELLE_MIN := 8.0                     # schmalste Parzelle
const PARZELLE_MAX := 12.0

## Alle Parzellen des Bezirks: {pos, size, dir, strasse}
static var PARZELLEN: Array = []
## Alle Straßenbänder: {a, b, breite}
static var STRASSEN: Array = []
static var NETZ: Netz = Netz.new()
static var ANKER: Dictionary = {}

## Die fünf Sonderbauten. Sie bekommen eine Parzelle an einer Arterie.
static var SONDER: Array = [
	["uni", "Hochschule", Color(0.72, 0.70, 0.66)],
	["cafe", "Café Nadel", Color(0.82, 0.62, 0.45)],
	["buero", "Büro Ostwind", Color(0.62, 0.66, 0.72)],
	["baeckerei", "Bäckerei Keller", Color(0.85, 0.72, 0.50)],
	["werkstatt", "Werkstatt Loos", Color(0.70, 0.58, 0.55)],
]

static var PLACES: Dictionary = {}
static var LIST: Array = []

## Arbeitsplätze, die ein erzeugter Mensch bekommen kann.
static var ARBEIT: Array = ["uni", "cafe", "buero", "baeckerei", "werkstatt"]

static var VORNAMEN: Array = ["Lena", "Bruno", "Mira", "Tobias", "Halim", "Jorunn",
	"Pia", "Anselm", "Ceyda", "Rune", "Malte", "Ida", "Vito", "Nour", "Greta", "Kasper"]
static var NACHNAMEN: Array = ["Vogt", "Keller", "Sahin", "Frank", "Berg", "Ostermann",
	"Ruiz", "Lind", "Aslan", "Weiss", "Petit", "Novak"]
static var BERUFE: Array = ["Illustratorin", "Bäcker", "Studentin", "Sachbearbeiter",
	"Pfleger", "Tischlerin", "Lehrer", "Programmiererin", "Fahrer", "Archivarin",
	"Köchin", "Musiker"]

## Anliegen sind echte Klemmen, keine erzeugten Sätze — sie tragen den Sinn
## des Spiels. Erzeugt werden Person, Wohnort und Tagesablauf drumherum.
static var ANLIEGEN: Array = [
	{
		"traum": "Ihr Bilderbuch endlich zu Ende zeichnen.",
		"problem": "Sie schiebt die letzten zwölf Seiten seit acht Monaten vor sich her. Jeder Entwurf kommt ihr zu schlecht vor, also fängt sie lieber gar nicht erst an.",
		"tags": ["prokrastination", "selbstzweifel", "ablenkung"],
	},
	{
		"traum": "Wieder Klavier spielen wie mit zwanzig.",
		"problem": "Das Klavier steht zugestellt im Flur. Nach der Frühschicht ist er zu müde, um auch nur den Deckel zu öffnen.",
		"tags": ["gewohnheit", "erschoepfung", "ablenkung"],
	},
	{
		"traum": "Die Abschlussarbeit vortragen, ohne zu erstarren.",
		"problem": "Die Arbeit ist längst fertig. Aber vor jedem Vortrag wird ihr schwarz vor Augen, und sie meldet sich wieder ab.",
		"tags": ["angst", "ueberforderung", "selbstzweifel"],
	},
	{
		"traum": "Abends wieder Zeit für die Tochter haben.",
		"problem": "Er sagt zu jeder Bitte ja und sitzt dafür jeden Abend bis acht im Büro. Zu Hause ist er nur noch müde.",
		"tags": ["stress", "grenzen", "erschoepfung"],
	},
	{
		"traum": "Endlich wieder durchschlafen.",
		"problem": "Der Feierabend franst aus, das Handy leuchtet bis zwei. Morgens steht er zerschlagen auf und trinkt sich wach.",
		"tags": ["erschoepfung", "gesundheit", "gewohnheit"],
	},
	{
		"traum": "Den alten Freundeskreis zurückholen.",
		"problem": "Sie wartet seit Monaten, dass sich jemand meldet, und meldet sich selbst nie. Jede Einladung erscheint ihr aufdringlich.",
		"tags": ["einsamkeit", "selbstzweifel"],
	},
	{
		"traum": "Die Werkstatt in der Garage wieder aufmachen.",
		"problem": "Alles liegt bereit, aber der erste Handgriff wirkt jedes Mal wie ein Berg. Am Ende räumt er lieber auf.",
		"tags": ["prokrastination", "ueberforderung"],
	},
	{
		"traum": "Vor Publikum sprechen, ohne dass die Hände zittern.",
		"problem": "Schon Tage vorher liegt ihr der Termin im Magen. Kurz davor wird die Luft knapp und der Kopf leer.",
		"tags": ["angst", "stress"],
	},
	{
		"traum": "Nach dem Rückschlag noch einmal anfangen.",
		"problem": "Seit die Prüfung schiefging, redet sie mit sich, wie sie mit niemandem reden würde. Jeder neue Versuch fühlt sich sinnlos an.",
		"tags": ["rueckschlag", "selbstzweifel"],
	},
	{
		"traum": "Drei Abende in der Woche für sich behalten.",
		"problem": "Der Kalender füllt sich mit fremden Anliegen, weil ein Nein unhöflich wirkt. Am Ende bleibt nichts übrig.",
		"tags": ["grenzen", "stress", "ueberforderung"],
	},
]

## Der Grundtag. Blocker werden später in passende Fenster gesetzt.
## [Stunde, Ort, Tätigkeit, Fenster]
static var GRUNDTAG: Array = [
	[0, "heim", "schlaeft", "nacht"],
	[7, "heim", "morgenroutine", "morgen"],
	[9, "arbeit", "arbeitet", "tag"],
	[12, "cafe", "essen", "tag"],
	[14, "arbeit", "arbeitet", "tag"],
	[17, "park", "unterwegs", "abend"],
	[19, "heim", "ruht", "abend"],
	[21, "heim", "ruht", "abend"],
	[23, "heim", "abendroutine", "nacht"],
]

static var PASSEND: Array = [
	[0, 0],   # Pomodoro          -> aufschieben, zögert
	[6, 4],   # Zwei-Minuten      -> Werkstatt, räumt auf
	[4, 3],   # Wenn-Dann         -> Gewohnheit, Morgenroutine
	[1, 1],   # Gewohnheiten      -> Klavier, isst / Abendroutine
	[9, 0],   # Zerlegen          -> Überforderung, grübelt
	[0, 4],   # Umgebung          -> Ablenkung, räumt auf
	[8, 0],   # Umdeuten          -> Selbstzweifel, grübelt
	[7, 2],   # Box-Atmung        -> Angst, angespannt
	[8, 2],   # Selbstmitgefühl   -> Rückschlag, grübelt
	[4, 1],   # Schlaffenster     -> Erschöpfung, ruht
	[5, 2],   # Hilfe bitten      -> Einsamkeit, wartet
	[3, 3],   # Nein sagen        -> Grenzen, arbeitet
]


static func heim_key(i: int) -> String:
	return "heim_%d" % i


## Baut den ganzen Bezirk neu auf: Straßen, Parzellen, Sonderbauten, Wohnhäuser.
## Die Zahl der Menschen liegt fest -- sie sind alle von Anfang an da.
static func erzeuge(_ungenutzt: int = 0) -> void:
	_bezirk()
	PLACES = {}
	LIST = []
	_park_eintragen()
	_sonderbauten_verteilen()
	_wohnhaeuser_verteilen()
	_anker_setzen()
	for i in range(EINWOHNER):
		LIST.append(_mensch(i))


# ------------------------------------------------------------ Bezirk

## Arterien im Raster, Blöcke dazwischen, roji ins Blockinnere, Parzellen
## an jeder Straße. Danach steht das Straßennetz, auf dem alle laufen.
static func _bezirk() -> void:
	PARZELLEN = []
	STRASSEN = []
	NETZ = Netz.new()
	ANKER = {}
	var rng := RandomNumberGenerator.new()
	rng.seed = 31337

	# Arterien: die Achsen leicht versetzt, damit kein reines Schachbrett steht
	var xs: Array = []
	var zs: Array = []
	for i in range(ACHSEN.size()):
		xs.append(float(ACHSEN[i]) + rng.randf_range(-3.0, 3.0))
		zs.append(float(ACHSEN[i]) + rng.randf_range(-3.0, 3.0))
	var von: float = float(ACHSEN[0]) - 6.0
	var bis: float = float(ACHSEN[ACHSEN.size() - 1]) + 6.0
	for x in xs:
		_strasse(Vector3(x, 0, von), Vector3(x, 0, bis), ARTERIE)
	for z in zs:
		_strasse(Vector3(von, 0, z), Vector3(bis, 0, z), ARTERIE)

	# Blöcke zwischen den Arterien
	for ix in range(xs.size() - 1):
		for iz in range(zs.size() - 1):
			var x0: float = float(xs[ix]) + ARTERIE * 0.5
			var x1: float = float(xs[ix + 1]) - ARTERIE * 0.5
			var z0: float = float(zs[iz]) + ARTERIE * 0.5
			var z1: float = float(zs[iz + 1]) - ARTERIE * 0.5
			if ix == 1 and iz == 1:
				continue        # die Mitte bleibt Park
			_block(Vector3((x0 + x1) * 0.5, 0, (z0 + z1) * 0.5),
				Vector2(x1 - x0, z1 - z0), rng)
	_netz_bauen()


static func _strasse(a: Vector3, b: Vector3, breite: float) -> void:
	STRASSEN.append({"a": a, "b": b, "breite": breite})


## Aus den Straßenbändern ein zusammenhängendes Netz machen: an jeder Kreuzung
## sitzt ein Knoten, dazwischen alle 16 Meter einer.
static func _netz_bauen() -> void:
	for i in range(STRASSEN.size()):
		var a: Vector3 = STRASSEN[i]["a"]
		var b: Vector3 = STRASSEN[i]["b"]
		var laenge := a.distance_to(b)
		if laenge < 0.5:
			continue
		var stellen: Array = [0.0, 1.0]
		for j in range(STRASSEN.size()):
			if j == i:
				continue
			var t := _kreuzung(a, b, STRASSEN[j]["a"], STRASSEN[j]["b"])
			if t >= 0.0:
				stellen.append(t)
		stellen.sort()
		var fein: Array = [float(stellen[0])]
		for k in range(1, stellen.size()):
			var von: float = float(fein[fein.size() - 1])
			var bis: float = float(stellen[k])
			if bis - von < 0.001:
				continue
			var n := maxi(1, int((bis - von) * laenge / 16.0))
			for m in range(1, n + 1):
				fein.append(von + (bis - von) * float(m) / float(n))
		var vorher := -1
		for t2 in fein:
			var idx := NETZ.fuege_knoten(a.lerp(b, float(t2)))
			if vorher >= 0:
				NETZ.verbinde(vorher, idx)
			vorher = idx


## Parameter t auf der Strecke a-b, an dem sie c-d schneidet. -1 wenn nicht.
static func _kreuzung(a: Vector3, b: Vector3, c: Vector3, d: Vector3) -> float:
	var r := b - a
	var s2 := d - c
	var nenner := r.x * s2.z - r.z * s2.x
	if absf(nenner) < 0.0001:
		return -1.0
	var t := ((c.x - a.x) * s2.z - (c.z - a.z) * s2.x) / nenner
	var u := ((c.x - a.x) * r.z - (c.z - a.z) * r.x) / nenner
	if t < 0.0 or t > 1.0 or u < 0.0 or u > 1.0:
		return -1.0
	return t


## Ein Block: außen ein Kranz von Parzellen an den Arterien, innen eine Gasse
## mit den hinteren Parzellen daran. Die Nord- und Südreihe laufen über die
## volle Breite, die Ost- und Westreihe nur dazwischen -- sonst überlappen die
## Ecken.
static func _block(mitte: Vector3, groesse: Vector2, rng: RandomNumberGenerator) -> void:
	var tiefe := minf(RAND_TIEFE, minf(groesse.x, groesse.y) * 0.34)
	var seiten := [
		["back", Vector3(0, 0, 1), groesse.x, groesse.y],
		["forward", Vector3(0, 0, -1), groesse.x, groesse.y],
		["right", Vector3(1, 0, 0), groesse.y - tiefe * 2.0, groesse.x],
		["left", Vector3(-1, 0, 0), groesse.y - tiefe * 2.0, groesse.x],
	]
	for eintrag in seiten:
		var dir: String = eintrag[0]
		var n: Vector3 = eintrag[1]
		var laenge: float = eintrag[2]
		var quer_mass: float = eintrag[3]
		if laenge < PARZELLE_MIN:
			continue
		var quer := Vector3(absf(n.z), 0, absf(n.x))
		var anzahl := maxi(1, int(round(laenge / rng.randf_range(PARZELLE_MIN + 1.0,
			PARZELLE_MAX))))
		var breite := laenge / float(anzahl)
		var rand := mitte + n * (quer_mass * 0.5 - tiefe * 0.5)
		for k in range(anzahl):
			var versatz := (float(k) + 0.5 - float(anzahl) * 0.5) * breite
			var quer_ist := absf(n.z) > 0.0
			PARZELLEN.append({
				"pos": rand + quer * versatz,
				"size": Vector2(breite - 0.8, tiefe - 0.8) if quer_ist
					else Vector2(tiefe - 0.8, breite - 0.8),
				"dir": dir,
			})

	# Blockinneres: eine Gasse von der längeren Seite hinein
	var innen := groesse - Vector2(tiefe, tiefe) * 2.0
	if innen.x < 12.0 or innen.y < 12.0:
		return
	var laengs := innen.y >= innen.x
	var richtung := Vector3(0, 0, -1) if laengs else Vector3(-1, 0, 0)
	# Die Gasse setzt an der Arterie an, sonst hinge sie in der Luft
	var aussen: float = (groesse.y if laengs else groesse.x) * 0.5 + ARTERIE * 0.5
	var start := mitte - richtung * aussen
	var ende := mitte + richtung * ((innen.y if laengs else innen.x) * 0.5 - 2.0)
	_strasse(start, ende, ROJI)
	var flanke := Vector3(1, 0, 0) if laengs else Vector3(0, 0, 1)
	var p_breite := (innen.x if laengs else innen.y) * 0.5 - ROJI * 0.5 - 0.8
	if p_breite < PARZELLE_MIN * 0.8:
		return
	# Nur der Teil im Blockinneren trägt Parzellen
	var innen_start := mitte - richtung * ((innen.y if laengs else innen.x) * 0.5)
	var laenge_g := innen_start.distance_to(ende)
	var anzahl_g := maxi(1, int(round(laenge_g / 13.0)))
	var tief_g := laenge_g / float(anzahl_g) - 0.8
	for seite: float in [1.0, -1.0]:
		for k in range(anzahl_g):
			var t := (float(k) + 0.5) / float(anzahl_g)
			var pos := innen_start.lerp(ende, t) + flanke * (seite * (ROJI * 0.5 + p_breite * 0.5))
			PARZELLEN.append({
				"pos": pos,
				"size": Vector2(p_breite, tief_g) if laengs else Vector2(tief_g, p_breite),
				"dir": ("left" if seite > 0.0 else "right") if laengs
					else ("forward" if seite > 0.0 else "back"),
			})


# ------------------------------------------------------------ Belegung

static func _park_eintragen() -> void:
	PLACES["park"] = {
		"name": "Stadtpark", "pos": [0.0, 0.0], "size": [0.0, 0.0],
		"dir": "none", "color": Color(0.45, 0.65, 0.38),
	}


## Die Sonderbauten bekommen Parzellen an einer Arterie, gut verteilt.
static func _sonderbauten_verteilen() -> void:
	var kandidaten: Array = []
	for i in range(PARZELLEN.size()):
		var p: Dictionary = PARZELLEN[i]
		if minf(p["size"].x, p["size"].y) >= 10.0:
			kandidaten.append(i)
	for s in range(SONDER.size()):
		if kandidaten.is_empty():
			break
		# Das Café gehört in die Mitte -- jeder Tagesablauf führt dorthin.
		# Die übrigen Sonderbauten verteilen sich rundum.
		var wunsch := Vector3.ZERO
		if str(SONDER[s][0]) != "cafe":
			var w := TAU * float(s) / float(SONDER.size() - 1)
			wunsch = Vector3(cos(w), 0, sin(w)) * 42.0
		var idx: int = -1
		var beste := INF
		for k in kandidaten:
			var q: Dictionary = PARZELLEN[k]
			if q.has("belegt"):
				continue
			var d: float = (q["pos"] as Vector3).distance_to(wunsch)
			if d < beste:
				beste = d
				idx = int(k)
		if idx < 0:
			continue
		var p: Dictionary = PARZELLEN[idx]
		p["belegt"] = true
		PLACES[str(SONDER[s][0])] = {
			"name": str(SONDER[s][1]),
			"pos": [p["pos"].x, p["pos"].z],
			"size": [p["size"].x, p["size"].y],
			"dir": p["dir"],
			"color": SONDER[s][2],
		}


## Die Wohnhäuser: gleichmäßig über den Bezirk verteilt, damit die Wege
## nicht alle in derselben Ecke enden.
static func _wohnhaeuser_verteilen() -> void:
	var frei: Array = []
	for i in range(PARZELLEN.size()):
		if not PARZELLEN[i].has("belegt"):
			frei.append(i)
	if frei.is_empty():
		return
	for i in range(EINWOHNER):
		var idx: int = int(frei[(i * 11 + 5) % frei.size()])
		var p: Dictionary = PARZELLEN[idx]
		if p.has("belegt"):
			for versuch in range(frei.size()):
				idx = int(frei[(i * 11 + 5 + versuch) % frei.size()])
				p = PARZELLEN[idx]
				if not p.has("belegt"):
					break
		p["belegt"] = true
		PLACES[heim_key(i)] = {
			"name": "%s %d" % [_nachname(i), i + 1],
			"pos": [p["pos"].x, p["pos"].z],
			"size": [p["size"].x, p["size"].y],
			"dir": p["dir"],
			"color": Color.from_hsv(fmod(0.08 + float(i) * 0.113, 1.0), 0.28, 0.78),
		}


static func _anker_setzen() -> void:
	for key in PLACES:
		var s: Array = PLACES[key]["size"]
		var tuer := Orte.door(PLACES, key)
		if float(s[0]) <= 0.0:
			tuer = Orte.center(PLACES, key)
		ANKER[key] = int(NETZ.andocken(tuer)["knoten"])


## Was diesen Menschen nicht im Tagesablauf aufhält, sondern in Momenten.
## Ein bis zwei Probleme -- die zweite Ebene neben den Ursachen.
static func probleme_von(i: int) -> Array:
	var alle: Array = Probleme.LISTE.keys()
	var out: Array = [str(alle[i % alle.size()])]
	if i % 2 == 1:
		var zweites: String = str(alle[(i + 2) % alle.size()])
		if zweites != out[0]:
			out.append(zweites)
	return out


## Woran der Traum dieses Menschen scheitert. Zwei bis drei Ursachen, nie alle.
## Die erste hängt am Weg gleicher Nummer -- so ist der neueste Mensch immer
## mit dem neuesten Weg anzugehen.
static func ursachen_von(i: int) -> Array:
	var alle: Array = Ursachen.LISTE.keys()
	var erste: String = str(alle[i % alle.size()])
	if i < TechDB.LIST.size():
		erste = str(TechDB.LIST[i]["ursache"])
	var out: Array = [erste]
	var zweite: String = str(alle[(alle.find(erste) + 1 + i % 3) % alle.size()])
	if zweite != erste:
		out.append(zweite)
	if i % 3 == 2:
		var dritte: String = str(alle[(alle.find(erste) + 3) % alle.size()])
		if not out.has(dritte):
			out.append(dritte)
	return out


## Der Tagesablauf: Grundtag, in den je Ursache ein Blocker gesetzt wird.
static func _tagesablauf(i: int, heim: String, arbeit: String) -> Array:
	var slots: Array = []
	for e in GRUNDTAG:
		var ort: String = str(e[1])
		if ort == "heim":
			ort = heim
		elif ort == "arbeit":
			ort = arbeit
		slots.append([int(e[0]), ort, str(e[2]), str(e[3])])
	var belegt: Dictionary = {}
	var nr := 0
	for u in ursachen_von(i):
		for fenster in ["tag", "abend", "morgen", "nacht"]:
			var kandidaten: Array = Ursachen.blocker_fuer(str(u), fenster)
			if kandidaten.is_empty():
				continue
			var blocker: String = str(kandidaten[(i + nr) % kandidaten.size()])
			var gesetzt := false
			for k in range(slots.size()):
				if belegt.has(k) or str(slots[k][2]) == "schlaeft":
					continue
				if str(slots[k][3]) != fenster:
					continue
				slots[k][2] = blocker
				belegt[k] = true
				gesetzt = true
				break
			if gesetzt:
				break
		nr += 1
	var out: Array = []
	for e in slots:
		out.append([e[0], e[1], e[2]])
	return out


static func _mensch(i: int) -> Dictionary:
	var anliegen: Dictionary = ANLIEGEN[i % ANLIEGEN.size()]
	if i < PASSEND.size():
		anliegen = ANLIEGEN[int(PASSEND[i][0])]
	var heim := heim_key(i)
	var arbeit := _naechster_arbeitsplatz(heim, i)
	return {
		"id": "mensch_%d" % i,
		"name": "%s %s" % [_vorname(i), _nachname(i)],
		"alter": 22 + (i * 7) % 38,
		"beruf": str(BERUFE[i % BERUFE.size()]),
		"traum": str(anliegen["traum"]),
		"problem": str(anliegen["problem"]),
		"tags": (anliegen["tags"] as Array).duplicate(),
		"ursachen": ursachen_von(i),
		"probleme": probleme_von(i),
		"mission": true,
		"heim": heim,
		"farbe": Color.from_hsv(fmod(0.02 + float(i) * 0.191, 1.0), 0.5, 0.8),
		"routine": _tagesablauf(i, heim, arbeit),
	}


## Wer wo wohnt, arbeitet in der Nähe. Sonst laufen alle quer durch den Bezirk
## und kommen nie an.
static func _naechster_arbeitsplatz(heim: String, i: int) -> String:
	if not PLACES.has(heim):
		return str(ARBEIT[i % ARBEIT.size()])
	var von := Orte.center(PLACES, heim)
	var beste := INF
	var ziel := str(ARBEIT[i % ARBEIT.size()])
	for a in ARBEIT:
		if not PLACES.has(a):
			continue
		var d := Orte.center(PLACES, str(a)).distance_to(von)
		if d < beste:
			beste = d
			ziel = str(a)
	return ziel


static func _vorname(i: int) -> String:
	return str(VORNAMEN[i % VORNAMEN.size()])


static func _nachname(i: int) -> String:
	return str(NACHNAMEN[(i / VORNAMEN.size() + i) % NACHNAMEN.size()])


static func by_id(id: String) -> Dictionary:
	for h in LIST:
		if h["id"] == id:
			return h
	return {}