diff --git a/OLD.entwicklung b/OLD.entwicklung
index 98aac02..243725a 100644
--- a/OLD.entwicklung
+++ b/OLD.entwicklung
@@ -130054,3 +130054,55 @@
 
 
 
+Re^16: Untersuchen von Dingen (Arson,  7. Dez 2018, 17:10:39):
+~#! rn=Arson rt=1544198624 rg=entwicklung
+~#! tid=1542578028
+Gibt es eine Moeglichkeit, zu differenzieren, ob ein Detail oder ein Objekt im
+Raum untersucht werden soll?
+bzw. ist dies gewuenscht oder wurde mit den neusten Entwicklungen schon
+umgesetzt?
+Beispielsweise steht irgendwo in der Raumbeschreibung: "auf einem der
+Regalbretter steht eine Flasche."
+Gleichzeitig liegt im Raum ein Objekt namens "Flasche"
+In diesen Faellen habe ich es bisher nur geschafft, das Detail aus der
+Raumbeschreibung zu untersuchen.
+
+arson
+
+-----------------------------------------------------------------------------
+
+
+
+Re^17: Untersuchen von Dingen (Zesstra,  7. Dez 2018, 17:16:54):
+~#! rn=Arson rt=1544199039 rg=entwicklung
+~#! tid=1542578028
+Man kann das nicht festlegen, dass man nur Details oder nur Objekte finden
+will. Also weder frueher noch jetzt.
+In Deinem Beispiel muss aber eigentlich immer das Objekt "Flasche" gefunden
+werden, nicht das Detail im Raum. Das wird von einigen Magiern auch gezielt
+genutzt, daher ist ne Aenderung nicht ganz einfach.
+Es wuerde aber mit einer Neuentwicklung gehen, die ich seit einiger Zeit in
+Entwicklung habe. Das geht dann aber nicht automagisch, sondern muss gezielt
+im Raum so genutzt werden. Dann koennte man naemlich im Raum ein Objekt
+(regal) definieren, was ein Detail "Flasche" (oder sogar nen echtes Objekt)
+hat und es dann mittels "unt flasche auf regel" untersuchen.
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
+Re^18: Untersuchen von Dingen (Arson,  7. Dez 2018, 17:29:26):
+~#! rn=Zesstra rt=1544199414 rg=entwicklung
+~#! tid=1542578028
+Ja, habe es gerade nochmal reproduziert. Es wird die Objektbeschreibung
+ausgegeben.
+Ich war der Meinung, dass ich vesrays Leiche letztens aufgrund dieses Umstands
+nicht untersuchen konnte. muss ich bei Gelegenheit noch mal testen.
+
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index 2feee20..c33b30b 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
diff --git a/OLD.schmarrn b/OLD.schmarrn
index e064d5e..904cf0c 100644
--- a/OLD.schmarrn
+++ b/OLD.schmarrn
@@ -409798,3 +409798,14 @@
 
 
 
+Re^3: Defekte Links in der Doku (Zook, 30. Dez 2018, 19:20:33):
+~#! rn=Zaphob rt=1546193262 rg=webdev
+~#! tid=1546052657
+Meine Feile heisst "rm".
+
+Zook
+
+-----------------------------------------------------------------------------
+
+
+
