142 lines
4.2 KiB
GDScript
142 lines
4.2 KiB
GDScript
class_name Orte
|
|
## Gemeinsame Geometrie für beide Welten: Orte, Türen, Wege, Tätigkeiten.
|
|
|
|
static var DIR_VEC: Dictionary = {
|
|
"back": Vector3(0, 0, 1),
|
|
"forward": Vector3(0, 0, -1),
|
|
"left": Vector3(-1, 0, 0),
|
|
"right": Vector3(1, 0, 0),
|
|
"none": Vector3(0, 0, 0),
|
|
}
|
|
|
|
static var ACTIVITY_TEXT: Dictionary = {
|
|
# Erde
|
|
"schlaeft": "schläft",
|
|
"morgenroutine": "Morgenroutine",
|
|
"arbeitet": "arbeitet",
|
|
"pause": "macht Pause",
|
|
"essen": "isst",
|
|
"gruebelt": "grübelt",
|
|
"ruht": "ruht sich aus",
|
|
"angespannt": "ist angespannt",
|
|
"abendroutine": "Abendroutine",
|
|
"aufraeumen": "räumt auf",
|
|
"wartet": "wartet",
|
|
"muede": "ist müde",
|
|
"unterwegs": "geht spazieren",
|
|
"zoegert": "zögert",
|
|
# Traumwelt
|
|
"webt": "webt Traumfäden",
|
|
"sammelt": "sammelt Erinnerungen",
|
|
"sortiert": "sortiert, was verloren ging",
|
|
"beobachtet": "schaut zur Erde hinunter",
|
|
"wacht": "hält Wache am Tor",
|
|
"singt": "singt",
|
|
"wandert": "wandert über die Insel",
|
|
"traeumt": "träumt",
|
|
}
|
|
|
|
|
|
## Blocker tragen ihren Namen im Ursachen-Katalog, alles andere hier.
|
|
static func text(a: String) -> String:
|
|
if Ursachen.ist_blocker(a):
|
|
return str(Ursachen.BLOCKER[a]["name"])
|
|
return str(ACTIVITY_TEXT.get(a, a))
|
|
|
|
|
|
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
|
|
|
|
|
|
## 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:
|
|
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)
|
|
var p := c + d * (halb_d - 1.6) + quer * (halb_q - 1.4) - quer * (3.0 if e % 2 == 1 else 0.0)
|
|
p.y = hoehe(e)
|
|
return p
|
|
|
|
|
|
## 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)
|
|
|
|
|
|
## 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
|
|
|
|
|
|
static func center(places: Dictionary, key: String) -> Vector3:
|
|
var p: Array = places[key]["pos"]
|
|
return Vector3(p[0], 0.0, p[1])
|
|
|
|
|
|
## Punkt direkt vor der Türlücke, außerhalb des Gebäudes.
|
|
static func door(places: Dictionary, key: String) -> Vector3:
|
|
var pl: Dictionary = places[key]
|
|
var c := center(places, key)
|
|
var d: Vector3 = DIR_VEC[pl["dir"]]
|
|
if d == Vector3.ZERO:
|
|
return c
|
|
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
|