diff --git a/OLD.entwicklung b/OLD.entwicklung
index 0082cc2..5dc942c 100644
--- a/OLD.entwicklung
+++ b/OLD.entwicklung
@@ -128925,3 +128925,93 @@
 
 
 
+Re: Re: Vorschlag fuer Fremdenfuehrer (Notstrom, 18. Aug 2016, 22:56:09):
+~#! rn=Zesstra rt=1471382037 rg=entwicklung
+~#! tid=1471209765
+Huhu,
+
+den Vorschlag finde ich gut. Ich werde aber in naechster Zukunft aufgrund
+beruflicher Verschlechterung vermutlich recht wenig Zeit dafuer haben.
+Vielleicht kann man ja Bugfix' Wegekundigen als Code-Grundlage auch fuer
+andere Wege verwenden?
+
+Notstrom.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Vorschlag fuer Fremdenfuehrer (Loom, 19. Aug 2016, 02:01:09):
+~#! rn=Notstrom rt=1471553769 rg=entwicklung
+~#! tid=1471209765
+Hi,
+ich finde die Idee auch nicht schlecht. Eventuell tuts ja als Basis auch der
+Code von Humis Prinzen, der klappert im Moment ja auch schon eine Reihe von
+Voelkern ab und labern kann er auch. :)
+
+Gruesse Loom
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Vorschlag fuer Fremdenfuehrer (Humni, 19. Aug 2016, 02:12:39):
+~#! rn=Loom rt=1471564869 rg=entwicklung
+~#! tid=1471209765
+Naja, so ein NPC muesste ja mehr koennen. Der Prinz laeuft einen festen Weg
+ab, aber so ein NPC muesste ja auf Spieler reagieren und dann diesen Weg
+laufen. Andererseits haben wir eine Infrastruktur, die Wege im MG mit Zielen
+ermoeglicht (jedenfalls ohne Schiffe und Portale - letztere koennten die NPCs
+vermutlich, aber der kleine Spieler hat ja nix davon).
+
+Kann man mal drueber nachdenken. Im Silberland gabs sowas auch. Der NPC heisst
+bezeichnenderweise Navi ;-)
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Vorschlag fuer Fremdenfuehrer (Loom, 19. Aug 2016, 11:06:37):
+~#! rn=Humni rt=1471565559 rg=entwicklung
+~#! tid=1471209765
+Andererseits haben wir ja doch noch eine relativ hohe Spieleranzahl hier,
+denkbar waere ja auch, dass Spieler anderen Spielern als Fremdenfuehrer helfen
+und dafuer mit einer Auszeichnung oder sowas belohnt werden, wenn sie diese zu
+bestimmten Orten fuehren. Das wuerde das Gemeinschaftsgefuehl neuerer Spieler
+foerdern und gleich Kontakt zu den Spielern aufbauen. :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Vorschlag fuer Fremdenfuehrer (Bugfix, 19. Aug 2016, 11:16:06):
+~#! rn=Loom rt=1471597597 rg=entwicklung
+~#! tid=1471209765
+Das Problem, dass dafeur staendig Spieler mit entsprechender Erfahrung nicht
+nur eingelogt, sondern auch aktiv sein muessen mal aussen vor ... Ich
+befuerchte, dass das anfangs gut funktioniert und dann ganz schnell nicht
+mehr, weil die Leute nach dreimal mit anfaengern von Katzmandu zur Hochebene
+laufen einfach keinen Bock mehr haben, kostet ja ggf. schon Zeit, je nach dem,
+wie gut der Spieler schon mit dem MG zurecht kommt und wie lang der Weg grad
+ist.
+
+Bugfix
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Vorschlag fuer Fremdenfuehrer (Loom, 19. Aug 2016, 11:28:56):
+~#! rn=Bugfix rt=1471598166 rg=entwicklung
+~#! tid=1471209765
+Naja Spieler rennen auch x-mal zum Drom :) Muss halt der Anreiz entsprechend
+gross sein. Aber stimmt schon, wuerde vermutlich auf Dauer nicht
+funktionieren, wird vermutlich das selbe uebel wie die Ausbildung bei den
+Kaempfern werden.
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index d15c30c..cbb68ac 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
