update

scripts/orte.gd

@@ -48,220 +48,6 @@ static func kennt(a: String) -> bool:
 	return ACTIVITY_TEXT.has(a) or Ursachen.ist_blocker(a)
 
 
-const ETAGE := 3.0                 # Höhe eines Stockwerks
-
-
-static func etagen(places: Dictionary, key: String) -> int:
-	return maxi(1, int(places[key].get("etagen", 1)))
-
-
-static func hoehe(e: int) -> float:
-	return float(e) * ETAGE
-
-
-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"]]
-	var size: Array = pl["size"]
-	var quer_ist := absf(d.z) > 0.0
-	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)
-	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
-	if halb_n * 2.0 - TREPPE_TIEFE > 0.2:
-		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]
-	var c := center(places, key)
-	var d: Vector3 = DIR_VEC[pl["dir"]]
-	var size: Array = pl["size"]
-	var halb: float = (float(size[1]) if absf(d.z) > 0.0 else float(size[0])) * 0.5
-	return c + d * (halb - 1.2)
-
-
-## Ort, in dessen Grundriss der Punkt liegt -- oder "".
-static func ort_bei(places: Dictionary, p: Vector3) -> String:
-	for key in places:
-		var s: Array = places[key]["size"]
-		if float(s[0]) <= 0.0:
-			continue
-		var c := center(places, key)
-		if absf(p.x - c.x) <= float(s[0]) * 0.5 and absf(p.z - c.z) <= float(s[1]) * 0.5:
-			return key
-	return ""
-
-
-## Weg für einen Körper von einem freien Punkt zu einem Menschen: aus dem
-## eigenen Haus heraus, über das Netz, durch seine Tür und in seine Etage.
-static func route_zu(places: Dictionary, netz: Netz, von: Vector3, nach: Vector3,
-		nach_ort: String, nach_etage: int) -> Array:
-	var pts: Array = []
-	var start := von
-	var von_ort := ort_bei(places, von)
-	if von_ort != "" and gebaeude(places, von_ort):
-		var e := int(round(von.y / ETAGE))
-		if e > 0:
-			pts.append(treppe(places, von_ort, e))
-			pts.append_array(treppen_weg(places, von_ort, e, 0))
-		pts.append(innen_tuer(places, von_ort))
-		start = door(places, von_ort)
-		pts.append(start)
-	var drin := nach_ort != "" and gebaeude(places, nach_ort)
-	var ende := door(places, nach_ort) if drin else nach
-	if netz != null:
-		var a: int = int(netz.andocken(start)["knoten"])
-		var b: int = int(netz.andocken(ende)["knoten"])
-		for idx in netz.pfad(a, b):
-			pts.append(netz.knoten[idx])
-	if drin:
-		pts.append(door(places, nach_ort))
-		pts.append(innen_tuer(places, nach_ort))
-		if nach_etage > 0:
-			pts.append(treppe(places, nach_ort, 0))
-			pts.append_array(treppen_weg(places, nach_ort, 0, nach_etage))
-	var ziel := nach
-	if drin:
-		ziel.y = hoehe(nach_etage)
-	pts.append(ziel)
-	return pts
-
-
-## 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:
 	var p: Array = places[key]["pos"]
 	return Vector3(p[0], 0.0, p[1])
@@ -277,31 +63,3 @@ static func door(places: Dictionary, key: String) -> Vector3:
 	var size: Array = pl["size"]
 	var half: float = size[1] * 0.5 if absf(d.z) > 0.0 else size[0] * 0.5
 	return c + d * (half + 2.5)
-
-
-## Route von Ort a nach Ort b. Gibt es ein Wegenetz, wird darauf gelaufen --
-## sonst über den freien Platz in der Mitte.
-static func route(places: Dictionary, a: String, b: String, offset: Vector3,
-		netz: Netz = null, anker: Dictionary = {}) -> Array:
-	var pts: Array = []
-	if a == b:
-		return pts
-	if netz != null and anker.has(a) and anker.has(b):
-		var weg := netz.pfad(int(anker[a]), int(anker[b]))
-		if not weg.is_empty():
-			for idx in weg:
-				var k: Vector3 = netz.knoten[idx]
-				if pts.is_empty() or pts[pts.size() - 1].distance_to(k) > 0.6:
-					pts.append(k)
-			pts.append(center(places, b) + offset)
-			return pts
-	var da := door(places, a)
-	var db := door(places, b)
-	pts.append(da)
-	if da.length() > 17.0:
-		pts.append(da.normalized() * 15.0)
-	if db.length() > 17.0:
-		pts.append(db.normalized() * 15.0)
-	pts.append(db)
-	pts.append(center(places, b) + offset)
-	return pts