diff --git a/OLD.diskussion b/OLD.diskussion
index e1f5fa2..19a36cf 100644
--- a/OLD.diskussion
+++ b/OLD.diskussion
@@ -130077,3 +130077,18 @@
 
 
 
+Re: Finden von NPC (Vardion,  6. Dez 2018, 20:19:28):
+~#! rn=Zesstra rt=1543778211 rg=diskussion
+~#! tid=1543778211
+Wie hat sich denn der Speicherverbrauch der im Mud vorhandenen Objekte relativ
+zur Entwicklung des vorhandenen Speichers in Servern entwickelt? Ich wurde
+jetzt ganz naiv erwarten dass man inzwischen alle jemals geschriebenen Objekte
+gleichzeitig im Speicher halten kann und das Ganze hundertfach. Liege ich da
+so falsch? Immerhin erwaehnst du ja etwas von "Ueberschreiten einer Grenze".
+
+Vardion
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.entwicklung b/OLD.entwicklung
index 8472bef..98aac02 100644
--- a/OLD.entwicklung
+++ b/OLD.entwicklung
@@ -129915,3 +129915,142 @@
 
 
 
+Re^8: Untersuchen von Dingen (Zesstra,  5. Dez 2018, 22:31:35):
+~#! rn=Zesstra rt=1544041614 rg=entwicklung
+~#! tid=1542578028
+Mal zwei Fragen fuer ein Meinungsbild:
+1) Moechtet ihr lieber diese Meldungen "Dein Blick wendet sich ..." u.ae.
+immer haben, wenn das passiert oder nur im (Fehler-)Falle, dass gar nix
+gefunden wird, angezeigt bekommen? (Nachteil waere: wenn was gefunden wird,
+erkennt man nicht, ob das nun am Referenzobjekt, im Raum oder in euch gefunden
+wurde.)
+2) Moechtet ihr diese Meldungen wie bisher nur fuer das normale Untersuchen
+(anschauen) oder auch fuer lesen, tasten, riechen, schmecken? Die Meldungen
+machen es einfacher zu erkennen, was wo gesucht wird, aber es scrollt
+natuerlich mehr, insb. bei den Sachen, die selten beschrieben sind.
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Untersuchen von Dingen (Deaddy,  5. Dez 2018, 22:50:01):
+~#! rn=Zesstra rt=1544045495 rg=entwicklung
+~#! tid=1542578028
+Ich faende es schoen, wenn man, analog zu ultrakurz, kurz und lang bei den
+Raumbeschreibungen, auch die Verbositaet von Untersuche einstellen koennte.
+Die kleinste Stufe so wie es vorher war, die naechste Stufe zeigt lediglich
+noch einmal das gesuchte Wort an und die dritte das volle Programm, so wie
+gerade.
+
+Bei den anderen Sinnen finde ich es nicht ganz so wichtig, einzig beim Lesen
+ist das doch manchmal etwas hakelig, aber ich glaube das liegt meist an
+schlechten Implementationen in den jeweiligen Gegenstaenden, also vermutlich
+wuerde es dort gar nicht helfen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Untersuchen von Dingen (Mundron,  6. Dez 2018, 11:05:26):
+~#! rn=Deaddy rt=1544046601 rg=entwicklung
+~#! tid=1542578028
+Ich finde Deaddys Vorschlag sehr gut, dass man sich einstellen kann, wie viel
+man angezeigt bekommt und wuerde mich darueber auch sehr freuen. Wobei ich das
+bei den anderen aktionen, wie lesen, tasten etc nicht sicher bin ob es wichtig
+ist.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Untersuchen von Dingen (Deaddy,  6. Dez 2018, 11:07:46):
+~#! rn=Mundron rt=1544090726 rg=entwicklung
+~#! tid=1542578028
+Mein Vorschlag ist leider zu komplex umzusetzen, auch wenn er natuerlich der
+beste ist.
+
+Persoenlich finde ich es mit den neuen Formulierungen gut, aber ich bin auch
+scrollimmun, da sollte jemand anders was zu sagen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Untersuchen von Dingen (Zesstra,  6. Dez 2018, 16:18:36):
+~#! rn=Deaddy rt=1544090866 rg=entwicklung
+~#! tid=1542578028
+Also, nicht grundsaetzlich zu komplex, aber mir zur Zeit zuviel, weil ich
+soviel Zeit und Lust fuer das Untersuche nicht habe. Ich habe mich in den
+letzten Wochen bestimmt jenseits von 20h damit befasst und irgendwann ist auch
+mal schluss, weil Pensum gedeckt fuer 2-3 jahre. Aber vielleicht mags ja
+spaeter jemand anders aufgreifen.
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Untersuchen von Dingen (Zaphob,  6. Dez 2018, 19:21:02):
+~#! rn=Zesstra rt=1544109516 rg=entwicklung
+~#! tid=1542578028
+Dafuer wuerde ich auch plaedieren.
+Das Untersuchen ist eben mit die zentralste Spielmechanik und eine der ersten
+Sachen, die neue Spieler im Tutorial so auf die Nase gedrueckt bekommen. Dort
+scrollt es zudem sowieso schon stark ueberdurchschnittlich. Deswegen schon mal
+danke fuer den korrigierten Entwurf jetzt, der die probierte Reihenfolge
+wiedergibt und auch das untersuchte Objekt benennt.  
+
+Zap*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Untersuchen von Dingen (Zesstra,  6. Dez 2018, 22:08:32):
+~#! rn=Zaphob rt=1544120462 rg=entwicklung
+~#! tid=1542578028
+Also der Status zur Zeit ist:
+
+Bei unt(ersuche) und lies wird angezeigt, wo man nach dem angebenen Ding
+sucht.
+Bei den anderen Sinnen nicht.
+
+# unt seil in mir
+Du siehst ein ganz normales Seil. ...
+# unt wolle (gleich wie: unt wolle an seil [in mir])
+Diese Wolle ist ...
+# unt blafasel
+Sowas siehst Du an/in einem Seil nicht. Du schaust Dich um.
+Sowas siehst Du hier nicht. Du schaust Dich an.
+'Blafasel' siehst Du auch da nicht! 
+# unt kratzer an muenze in boerse in mir
+Das Konterfei ist schon ganz schoen zerkratzt.
+
+Wird endgueltig nichts gefunden, wird bei untersuche (und lies) mit angeben,
+wonach man gesucht hat.
+
+# unt foobar
+'Foobar' siehst Du auch da nicht!
+
+nicht vorhandene Details an gefundenen Objekten:
+# unt foobar an seil
+'Foobar' siehst Du da nicht!
+# unt nichtda an muenze in boerse in mir
+'Nichtda' siehst Du da nicht!
+
+Details an nicht gefundenen Objekten:
+# unt foobar an nichtda
+Sowas siehst Du hier nicht. Du schaust Dich an.
+'Foobar an nichtda' siehst Du auch da nicht!
+# unt kratzer an muenze in boersedd in mir
+'Kratzer an muenze in boersedd' siehst Du da nicht!
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.hardsoftware b/OLD.hardsoftware
index e761114..661cd5f 100644
--- a/OLD.hardsoftware
+++ b/OLD.hardsoftware
@@ -76845,3 +76845,38 @@
 
 
 
+Probleme mit Notebook-Netzteil (Amaryllis, 13. Dez 2018, 22:07:34):
+Hi,
+
+vllt. ist hier einer, der sich mit Elektrik auskennt und mir sagen kann, woran
+es bei folgendem Problem hapert.
+
+Ich nutze schon seit Monaten ein Noname-Netzteil fuer mein Notebook, weil das
+originale diverse Kabelbrueche aufweist nach den ganzen Jahren der mobilen
+Nutzung.
+Das neue Netzteil ist eines, das sowohl von der Ausgangsspannung als auch der
+gelieferten Leistung das bringt, was das alte auch hatte.
+
+Nun tritt seit einigen Tagen (nicht immer) folgendes auf:
+Der Stecker, der ins Notebook geht, wird irre heiss (das Metall des Steckers
+laesst sich gar nicht mehr anfassen!). Seltsamerweise wird das Notebook
+trotzden (!) geladen, es scheint kein Kurzschluss zu sein - bislang weder
+Sicherung rausgeflogen, noch Netzteil oder Notebook irgendwie kaputt gegangen.
+Das Problem ist leider _nicht_ reproduzierbar, was ich am Aetzendsten finde.
+Mal tritt es auf, dann habe ich wieder tagelang Ruhe, dann passiert es wieder.
+Eine Frage beim Hardware-Hersteller meines Vertrauens brachte nur die
+Vermutung, dass das Netzteil auf das Notebook einfach nicht passt bzw. nicht
+die erforderiche Leistung braechte. Kann aber irgendwie auch nicht sein, da
+ich es ja schon laenger problemlos nutzte und es von SPannung, Stromstaerke
+etc. fuer mein Notebook locker ausgelegt ist.
+
+Hat da einer eine Idee, was da schieflaufen koennte? Ggf. ein Kriechstrom
+o.ae.? Ich komme hier derzeit leider nicht weiter...
+
+DAnke,
+Ama
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index f30e29f..2feee20 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
