update

scripts/orte.gd

@@ -59,9 +59,13 @@ static func hoehe(e: int) -> float:
 	return float(e) * ETAGE
 
 
-## Treppenhaus: die Ecke neben der Tür. Die Podeste wechseln je Etage die
-## Seite, so läuft die Treppe im Zickzack an der Türwand hoch.
-static func treppe(places: Dictionary, key: String, e: int) -> Vector3:
+const TREPPE_LAUF := 6.0           # Abstand der Wendepodeste entlang der Wand
+const TREPPE_TIEFE := 4.4          # Streifen an der Treppenwand: zwei Läufe nebeneinander
+const PODEST := 0.9                # halbe Podestlänge
+
+## Rahmen des Treppenhauses: an der längeren Wand, die nicht die Türwand ist.
+## n zeigt von der Mitte zur Treppenwand, a läuft an ihr entlang.
+static func treppen_rahmen(places: Dictionary, key: String) -> Dictionary:
 	var pl: Dictionary = places[key]
 	var c := center(places, key)
 	var d: Vector3 = DIR_VEC[pl["dir"]]
@@ -70,11 +74,98 @@ static func treppe(places: Dictionary, key: String, e: int) -> Vector3:
 	var halb_d: float = (float(size[1]) if quer_ist else float(size[0])) * 0.5
 	var halb_q: float = (float(size[0]) if quer_ist else float(size[1])) * 0.5
 	var quer := Vector3(-d.z, 0, d.x)
-	var p := c + d * (halb_d - 1.6) + quer * (halb_q - 1.4) - quer * (3.0 if e % 2 == 1 else 0.0)
+	if halb_q >= halb_d:
+		return {"c": c, "n": -d, "a": quer, "halb_n": halb_d, "halb_a": halb_q}
+	return {"c": c, "n": -quer, "a": -d, "halb_n": halb_q, "halb_a": halb_d}
+
+
+static func _lauf(r: Dictionary) -> float:
+	return minf(TREPPE_LAUF, float(r["halb_a"]) * 2.0 - 2.8)
+
+
+static func _podest_a(r: Dictionary, e: int) -> float:
+	var p0: float = float(r["halb_a"]) - 1.4
+	return p0 if e % 2 == 0 else p0 - _lauf(r)
+
+
+## Wendepodest der Etage e: zwei Läufe liegen nebeneinander, das Podest
+## verbindet sie. Der obere Lauf ist so nie die Decke des unteren.
+static func treppe(places: Dictionary, key: String, e: int) -> Vector3:
+	var r := treppen_rahmen(places, key)
+	var p: Vector3 = r["c"] + r["n"] * (float(r["halb_n"]) - TREPPE_TIEFE * 0.5) \
+		+ r["a"] * _podest_a(r, e)
 	p.y = hoehe(e)
 	return p
 
 
+## Ein Lauf: [Anfang auf Etage f, Ende auf Etage f + 1].
+static func treppen_lauf(places: Dictionary, key: String, f: int) -> Array:
+	var r := treppen_rahmen(places, key)
+	var tiefe: float = float(r["halb_n"]) - (1.4 if f % 2 == 0 else 3.0)
+	var richtung := -1.0 if f % 2 == 0 else 1.0
+	var von: Vector3 = r["c"] + r["n"] * tiefe + r["a"] * (_podest_a(r, f) + richtung * PODEST)
+	var bis: Vector3 = r["c"] + r["n"] * tiefe + r["a"] * (_podest_a(r, f + 1) - richtung * PODEST)
+	von.y = hoehe(f)
+	bis.y = hoehe(f + 1)
+	return [von, bis]
+
+
+## Wegpunkte durchs Treppenhaus von Etage a nach Etage b, ohne a selbst:
+## Laufanfang, Laufende, Podest -- je Etage.
+static func treppen_weg(places: Dictionary, key: String, a: int, b: int) -> Array:
+	var out: Array = []
+	if b > a:
+		for f in range(a, b):
+			var l := treppen_lauf(places, key, f)
+			out.append(l[0])
+			out.append(l[1])
+			out.append(treppe(places, key, f + 1))
+	else:
+		for f in range(a - 1, b - 1, -1):
+			var l := treppen_lauf(places, key, f)
+			out.append(l[1])
+			out.append(l[0])
+			out.append(treppe(places, key, f))
+	return out
+
+
+## Deckenplatten einer oberen Etage: alles außer dem Treppenloch.
+## Liefert [[mitte, groesse_xz], ...] ohne Höhe.
+static func treppen_decke(places: Dictionary, key: String) -> Array:
+	var r := treppen_rahmen(places, key)
+	var c: Vector3 = r["c"]
+	var n: Vector3 = r["n"]
+	var a: Vector3 = r["a"]
+	var halb_n := float(r["halb_n"])
+	var halb_a := float(r["halb_a"])
+	var out: Array = []
+	# Hauptplatte: alles außer dem Streifen an der Treppenwand
+	out.append([c - n * (TREPPE_TIEFE * 0.5), _xz(a, halb_a * 2.0, halb_n * 2.0 - TREPPE_TIEFE)])
+	# Rest des Streifens jenseits des Lochs
+	var ende: float = _podest_a(r, 1) - PODEST
+	var rest := ende + halb_a
+	if rest > 0.3:
+		out.append([c + n * (halb_n - TREPPE_TIEFE * 0.5) + a * ((ende - halb_a) * 0.5),
+			_xz(a, rest, TREPPE_TIEFE)])
+	return out
+
+
+## Kastenmaß in Weltachsen: laenge_a entlang a, laenge_n quer dazu.
+static func _xz(a: Vector3, laenge_a: float, laenge_n: float) -> Vector2:
+	return Vector2(laenge_a, laenge_n) if absf(a.x) > 0.0 else Vector2(laenge_n, laenge_a)
+
+
+## Rückt einen Punkt aus dem Treppenstreifen heraus (für Möbel).
+static func frei_von_treppe(places: Dictionary, key: String, pos: Vector3, halb: float) -> Vector3:
+	var r := treppen_rahmen(places, key)
+	var n: Vector3 = r["n"]
+	var pn: float = (pos - r["c"]).dot(n)
+	var grenze: float = float(r["halb_n"]) - TREPPE_TIEFE - halb - 0.2
+	if pn > grenze:
+		pos -= n * (pn - grenze)
+	return pos
+
+
 ## Punkt gleich hinter der Tür, im Haus.
 static func innen_tuer(places: Dictionary, key: String) -> Vector3:
 	var pl: Dictionary = places[key]
@@ -85,15 +176,42 @@ static func innen_tuer(places: Dictionary, key: String) -> Vector3:
 	return c + d * (halb - 1.2)
 
 
-## Wegpunkte durchs Treppenhaus von Etage a nach Etage b, ohne a selbst.
-static func treppen_weg(places: Dictionary, key: String, a: int, b: int) -> Array:
-	var out: Array = []
-	var schritt := 1 if b > a else -1
-	var e := a
-	while e != b:
-		e += schritt
-		out.append(treppe(places, key, e))
-	return out
+## Ein Ort ist ein Gebäude, wenn er Grundriss und Tür hat.
+static func gebaeude(places: Dictionary, key: String) -> bool:
+	return places.has(key) and float(places[key]["size"][0]) > 0.0 \
+		and DIR_VEC[places[key]["dir"]] != Vector3.ZERO
+
+
+## Route mit allem, was ein Körper braucht: aus der Etage runter, gerade durch
+## die Tür, über das Netz, durch die nächste Tür und die Treppe hinauf.
+## `etagen` sagt, in welcher Etage der Mensch an welchem Ort ist.
+static func route_voll(places: Dictionary, a: String, b: String, offset: Vector3,
+		etagen: Dictionary, netz: Netz = null, anker: Dictionary = {},
+		war_unterwegs: bool = false) -> Array:
+	var pts := route(places, a, b, offset, netz, anker)
+	if pts.is_empty():
+		return pts
+	if gebaeude(places, a) and not war_unterwegs:
+		var e_von := int(etagen.get(a, 0))
+		var runter: Array = []
+		if e_von > 0:
+			runter.append(treppe(places, a, e_von))
+			runter.append_array(treppen_weg(places, a, e_von, 0))
+		runter.append(innen_tuer(places, a))
+		runter.append(door(places, a))
+		runter.append_array(pts)
+		pts = runter
+	if gebaeude(places, b):
+		var e_nach := int(etagen.get(b, 0))
+		var ziel: Vector3 = pts.pop_back()
+		pts.append(door(places, b))
+		pts.append(innen_tuer(places, b))
+		if e_nach > 0:
+			pts.append(treppe(places, b, 0))
+			pts.append_array(treppen_weg(places, b, 0, e_nach))
+			ziel.y = hoehe(e_nach)
+		pts.append(ziel)
+	return pts
 
 
 static func center(places: Dictionary, key: String) -> Vector3: