diff --git a/OLD.diskussion b/OLD.diskussion
index 75d27de..356cade 100644
--- a/OLD.diskussion
+++ b/OLD.diskussion
@@ -131186,3 +131186,128 @@
 
 
 
+Re^8: Oefter Ort schicken per GMCP (Mundron, 13. Sep 2020, 07:45:03):
+~#! rn=Zesstra rt=1599942544 rg=diskussion
+~#! tid=1598808105
+Die Option:
+schau (sehend): MG sendet Raum-ID per gmcp
+schau (blind): MG sendet Leerstring als Raum-ID per gmcp
+
+waere doch eigentlich analog zur dem, was man als Spieler ohne gmcp auch
+wahrnimmt, naemlich eine Raumbeschreibung oder eben die Meldung, dass man
+nichts sieht. Daher waere das meiner Meinung nach eine Verbesserung, da bisher
+die Werte in gmcp bei Erblindung unveraendert blieben. Zumindest sehe ich da
+auch keine Mehrinformation fuer gmcp-Nutzer als vorher. Wuerde ich also sehr
+begruessen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Oefter Ort schicken per GMCP (Smurf, 13. Sep 2020, 09:11:20):
+~#! rn=Zesstra rt=1599942544 rg=diskussion
+~#! tid=1598808105
+Ich meinte natrlich *nicht* dass die "sichtbaren" GMCP-Daten mitgeschickt
+werden, wenn man nix sieht.
+Sondern erst dann, wenn ausserdem die Fackel an ist.
+(Oder welche Grnde auch immer es gibt dass es nicht mehr dunkel ist, zB
+Entblindung.)
+Das waere fuer GMCP-Clients ein echter Mehrwert, ohne ihn zu bevorteilen,
+weil er dasselbe machen muss (und dieselben infos bekommt, nur halt anders)
+wie ein Spieler mit Telnet.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Oefter Ort schicken per GMCP (Zesstra, 13. Sep 2020, 10:42:48):
+~#! rn=Mundron rt=1599975903 rg=diskussion
+~#! tid=1598808105
+Ich bin etwas verwirrt, was Dein Wunsch ist.
+
+Es gibt eine GMCP-Rauminfo, welche eine ID, die Kurzbeschreibung, die
+geographische Region und die sichtbaren Ausgaenge enthaelt.
+
+Wenn man nun nichts sieht, sieht man nichts davon mehr und demzufolge sollte
+auch per GMCP nichts davon kommen. Nach meinem Verstaendis steht es gerade
+nicht zur Diskussion, die anderen Bestandteile der Meldung auch zu senden,
+wenn man nix sehen kann.
+Ich verstehe Deinen Wunsch nun so, dass nur die ID in der Meldung ein
+Leerstring sein soll und der Rest wie gehabt und damit werde ich nicht
+sonderlich warm.
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Oefter Ort schicken per GMCP (Nondrum, 13. Sep 2020, 10:51:16):
+~#! rn=Zesstra rt=1599986568 rg=diskussion
+~#! tid=1598808105
+Ich bin gerade auch etwas verwirrt, wer nun gemeint ist. Also eine Option
+waere:
+1) Wenn man sich sehend bewegt, alles wie gehabt.
+2) wenn man sich blind bewegt, default-string als Raum-ID / Kurzbeschreibung,
+Region
+3) Wenn man "schau" eingibt und sieht: gmcp schickt die Daten erneut.
+4) Wenn man "schaut" eingibt und blind ist: gmcp schickt default-string als
+Raum-ID/Kurzbeschreibung/Region.
+ 
+Was der default-string ist, ist eigentlich egal. Es kann etwas sein, was
+ausdrueckt, dass man nicht sieht, in was fuer einem Raum man sich befindet
+oder es koennte auch ein Leerstring sein, waeren beides gut. 
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Oefter Ort schicken per GMCP (Zaphob, 13. Sep 2020, 11:17:50):
+~#! rn=Nondrum rt=1599987076 rg=diskussion
+~#! tid=1598808105
+Ja, das waere ein Loesungsansatz, Mundron.
+
+Vielleicht beschreibe ich nochmal das Problem gegen Verwirrung:
+
+Man bewegt sich "sehend":
+a) Man sieht Text des neuen Raums.
+b) Man sieht gmcp des neuen Raums.
+
+Man bewegt sich hingegen "blind":
+c) Man sieht Text "Finsternis."
+d) Man erhaelt *keine* gmcp-Daten (auch keine leeren, sondern nichts. gmcp
+wirkt also weiter so, als haette man sich *nicht* bewegt)
+
+Also d) soll sich aendern.
+
+Man tippt "blind" erneut "schau":
+e) Man sieht Text "Finsternis."
+f) Man erhaelt *keine* gmcp-Daten (auch keine leeren, sondern nichts. gmcp
+wirkt also weiter so, als haette man sich *nicht* bewegt)
+
+Man ent-blindet und tippt "schau":
+g) Man sieht Text des neuen Raums.
+h) Man erhaelt *keine* gmcp-Daten (auch keine leeren, sondern nichts. gmcp
+wirkt also weiter so, als haette man sich *nicht* bewegt)
+
+H sollte vermutlich wie B werden. Meinetwegen darf auch F verbesser werden.
+
+Der Workaround bei H ist derzeit nur nochmal bewegen, aber geht nicht immer
+
+Hoffe, das hilft.
+Gruesse,
+Zap*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Oefter Ort schicken per GMCP (Smurf, 13. Sep 2020, 11:34:31):
+~#! rn=Zaphob rt=1599988670 rg=diskussion
+~#! tid=1598808105
+Bingo, danke, genau so meinte ich das.
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index 651f76e..77dae62 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
diff --git a/OLD.treffen b/OLD.treffen
index c649800..35f4ba1 100644
--- a/OLD.treffen
+++ b/OLD.treffen
@@ -109445,3 +109445,94 @@
 
 
 
+Re: Stati in Bochum am 20.9.20 (Humni, 20. Sep 2020, 10:16:33):
+~#! rn=Humni rt=1600456226 rg=treffen.bekanntmachungen
+~#! tid=1600456226
+Hallo ihr,
+
+ich habe seit heute morgen leichte Halsschmerzen, bin ein wenig verschnupft
+und heiser. Das ist nicht Corona-typisch (kein trockener Husten, kein Fieber),
+aber ich werde das dennoch lieber mal heute beobachten, bevor ich mich ins
+Getuemmel, sprich, einen Stati, stuerze.
+
+Was der Rest macht, weiss ich nicht, ich bin heute jedenfalls leider nicht
+dabei.
+
+Und ja, das aergert mich massiv, weil das eine der wenigen Aktionen seit
+Wochen ist. Aber ich muss da die Prioritaeten richtig setzen ...
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Stati in Bochum am 20.9.20 (Zaphob, 20. Sep 2020, 10:43:38):
+~#! rn=Humni rt=1600589793 rg=treffen
+~#! tid=1600456226
+Oje gute Besserung! Dennoch danke fuers Anleiern.
+Also ich werde (mit 2-3 Personen) dort sein. 
+Hoffentlich nicht alleine..! :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Stati in Bochum am 20.9.20 (Arathorn, 20. Sep 2020, 10:47:50):
+~#! rn=Zaphob rt=1600591418 rg=treffen
+~#! tid=1600456226
+Nunja... :-) Das Problem ist: Dunst ist auch verschnieft und hustet ein bissl,
+wuerde daher tendenziell auch nicht kommen - das ist natuerlich ein
+limitierender Faktor fuer meine Motivation, mich gleich aus dem Haus zu
+bewegen. ;-)
+
+Arathorn.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Stati in Bochum am 20.9.20 (Masul, 20. Sep 2020, 11:10:02):
+~#! rn=Arathorn rt=1600591670 rg=treffen
+~#! tid=1600456226
+Also ich werde da sein. Mit einer Person. Bin gespannt auf den 2-3fachen
+Zaphob.
+
+Masul
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Stati in Bochum am 20.9.20 (Zaphob, 20. Sep 2020, 11:19:39):
+~#! rn=Arathorn rt=1600591670 rg=treffen
+~#! tid=1600456226
+Hmm, wenn das so ist, ziehe ich meine Anreise nun doch zurueck.
+Immerhin weiss ich nun von niemandem mehr, der auch dort waere.
+Zudem startet es in unter einer Stunde, also draengt die Zeit.
+Ich muss mit den kleinen Kindern einfach etwas laenger planen.
+Die umgedrehte Entscheidung ist aber nur halb so schlimm, denn:
+Ein mathematisch begabtes Alter Ego fand zwischenzeitlich heraus:
+Den umdrehbaren Tag koennen wir noch eine Weile monatlich feiern!
+Vielleicht halten wir die naechsten Termine direkt schon mal fest?
+In der Hoffnung, dass zumindest manche davon nicht erkaeltet ausfallen!
+
+PS: Oh, Masul, das hat sich nun ueberschnitten :( Ein andres Mal gern!
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Stati in Bochum am 20.9.20 (Masul, 20. Sep 2020, 11:40:10):
+~#! rn=Zaphob rt=1600593579 rg=treffen
+~#! tid=1600456226
+Also, dann soll's heute wohl nicht sein. Gute Besserung an Humni und Dunst.
+Die nächsten Termine wären dann: 20-10-20, 20-11-20, 20-12-20, 21-01-21,
+21-02-21, 21-03-21, 21-04-21, ...
+
+Masul.
+
+-----------------------------------------------------------------------------
+
+
+
