WWW (Wald der Wonnewichte) entdeckt! (Ark, 19. Aug 2005, 11:48:00):
Aufgeregt wuselten kleine Gestalten umher. Ich konnte mich gerade noch
zuegeln, bevor mein Fuss einen von ihnen versehentlich erwischte. Doch
keiner schien mich zu beachten, alle sahen so aus, als wuerden sie im
Wald, den ich betreten hatte, etwas suchen. Kopfschuettelnd ging ich
weiter, immer einem Weg folgend, den kleine Fuesse geschaffen hatten.

Immerhin, ausser den winzigen Wichten gab es noch ein paar andere Leute,
die sich im friedlichen Wald niedergelassen hatten. Nur eine Stelle war
etwas seltsam, doch der wird man sich wohl spaeter widmen muessen.
Schliesslich betrat ich einen kleinen dunklen Platz mitten im Wald, der
sofort meine Aufmerksamkeit besass. Ein wichtig wirkender Wicht werkelte
an einem Stuhl aus Holz herum, der direkt aus dem Waldboden zu wachsen
schien. Zwei weitere Wichte sahen ihm gelangweilt dabei zu, schraken
jedoch sofort auf, als sie mich bemerkten. Auch der dritte Wicht, der
eine schlichte Art von Krone auf seinem Haupt trug, sah zu mir hinueber
und laechelte.

'Ah, endlich jemand, der uns helfen kann', begruesste er mich.
'Sicher bist Du intelligent genug, um uns ein wenig zur Hand zu gehen.'
Aber sicher war ich das ... nur stellte sich nach ein wenig Palaver
heraus, dass ich dafuer vielleicht doch nicht so geeignet war. Aber ich
versprach, fuer Hilfe zu sorgen, denn die Wonnewichte - so der Name der
putzigen Gesellen - wuerden dieses Problem immer wieder haben.

Nachdem ich den Koenig - und es war wirklich einer - ueberzeugt hatte,
zueckte dieser seinen unsichtbaren Zauberstab und rief damit ein paar
grosse Insekten herbei, denen er eine hastig hingekritzelte Botschaft
um die haarigen Beine band, mit denen die gefluegelten Boten am Himmel
entschwanden. Froh, diese mutierten Bienen los zu sein, fragte ich den
Wicht, was das nun sollte.

Er grinste: 'Wir sind ein kleines Volk, zufrieden damit, nicht in die
weite Welt hinausziehen zu muessen ... obwohl es schon solche Waghalsigen
bei uns gegeben hat. Doch unser Problem liegt hier, nicht draussen in der
Welt. So habe ich denn unsere Freunde in die Heimat der Rassen geschickt,
auf dass sie junge Heldinnen und Recken herbeibringen. Ich denke, dass
Eure ruhmreichsten Abenteurer wenig Zeit haben, doch den unerfahreneren
unter Euren Voelkern wird ein Ausflug in unseren schoenen Wald sicher
gefallen.'

Dies gefiel mir, deshalb empfahl ich ihm, fuer die Tapferen unter Euch
noch ein wenig fuer Anreiz zu sorgen, was er mir auch prompt versprach.
Einer seiner Waechter war sogar so eifrig, auch noch etwas beizusteuern,
da er ein ganz persoenliches Interesse hatte.

Froher Stimmung machte ich mich wieder auf den Rueckweg, wohl wissend,
dass das Umherirren der Wichte vielleicht bald beendet waere, wenn sich
Helfer aller Rassen in den Wonnewichtwald begeben wuerden, um dem Koenig
zu helfen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



d.anfaenger (Ark, 19. Aug 2005, 14:29:27):
Das Gebiet ist das erste einer - hoffentlich - wachsenden Zahl. Die Region ist
geistig auf der letzten Zusammenkunft der EMs geboren worden. Wer Interesse
hat, hier mitzuwirken, sei herzlich willkommen. Der eigentliche Ort
zukuenftiger Gebiete ist wahlfrei und sollte mit den RMs abgesprochen werden,
in deren Regionen das Gebiet eigentlich liegen wird. Es soll ein klares Ziel
sein, Anfaengern hier erste einfache Schritte im MG zu erlauben, nachdem sie
sich technisch hier zurechtgefunden haben.
Da ich zunaechst mal den RM Posten uebernommen habe, wuerde ich mich
natuerlich ueber Mails ueber dieses erste Gebiet freuen, auch wenn keine
automatische Mail bei euch ankommt wie bei den Quests. So, und nun viel Spass.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Dank (Ark, 19. Aug 2005, 17:33:35):
Fast haette ich vergessen: die Belohnungen stammen nicht aus meiner Feder,
sondern von Miril und Kiria, bei denen koennt ihr euch dann ggf. auch bedanken
:-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Unliebsame Gaeste (Anacrion, 15. Jan 2006, 07:39:34):
Hmm.

Ich hab eben Wurzels Grossmaul bei den Wonnewichten gesehen.

Irgendwie kann es das nicht sein. Waere es nicht sinnvoll, die bekannten
LaufNPCs (Maul, Wandler, ???) daran zu hindern, d.anfaenger-Gebiete zu
betreten?

Anac*

-----------------------------------------------------------------------------



Re: Unliebsame Gaeste (Miril, 15. Jan 2006, 10:50:22):
~#! rn=Anacrion rt=1137307174 rg=d.anfaenger
~#! tid=1137307174
Das Grossmaul kriegt nun Angst, sobald es einen solchen Raum sieht.

Miril

-----------------------------------------------------------------------------



Neues aus dem WWW (Ark, 20. Mar 2006, 00:10:40):
Der Wicht grinste breit. Endlich hatte sein Koenig ihn erhoert. Lange
zog er heimlich durch die Lande, um sich andere Rassen aus der Naehe zu
betrachten. Unbemerkt von allen anderen Kreaturen schlich er sich bei
den Elfen, Orks, ja, sogar bei den weit entfernt wohnenden Felinen des
Dschungels ein. Eine solche Reise hatte er noch nie unternommen ... und
wird sie wohl sein Leben lang nicht mehr unternehmen. Um andere daran
teilhaben zu lassen, wollte er denen, die den Wichten sehr wohlgesonnen
sind, helfen, die grossen Entfernungen leichter zu ueberbruecken.
Dabei dachte er natuerlich vornehmlich an die, die klein und schwach
sind wie er selbst, vielleicht verschmaeht, verachtet und unbeachtet
von der grossen weiten Welt da draussen. Ja, denen muss besonders dabei
geholfen werden, sich schnell zurechtzufinden.
Und so bedingte er sich von seinem Koenig die Erlaubnis, das Geheimnis
der Bienen weitergeben zu duerfen. Und so war es nun geschehen. Nun
musste er nur noch warten, bis die wieder zu ihm kamen, die freundlich
den Wichten geholfen hatten ...


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



... (Ark, 20. Mar 2006, 00:12:12):
Die Bienen finden jetzt auch den Weg zu anderen Zielen, wenn man herausfindet,
wie man sie dazu bringt. Eine kleine Miniquest ist auch herausgesprungen, die
man auch mit hoeheren Stufen machen kann. Sie ist rebootfest. Und nun, wie
immer viel Spass.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



... unglaublich! (Ark,  4. Apr 2006, 00:44:59):
Klackend stakst die Spinne auf Dich zu. Du erhebst Deine Haende, sie haelt
inne. Verlegen laechelnd siehst Du sie an:
'Tja, also, weisst Du, eigentlich hast Du mich ganz schoen reingelegt.'
Ein aufgeregtes Klappern der kleinen Zangen ist die Antwort des Fieslings, als
wuesste er, was da auf ihn zukommt. Der Hass spiegelt sich in den
chitinbegrenzten glaenzenden Augen wieder, die Hoellen der Unterwelt scheinen
sich auf einmal zu oeffnen. Ruhig murmelst Du die magischen Worte der
Abwertung:
'Float, float, mein Freund ... willkommen in der Welt der Sterblichen.'
Dann ist es vollbracht, die Spinne wirkt zwar immer noch gefaehrlich, doch
]ihre Aura wirkt seltsam schwaecher, als koenne man sie nun besser treffen ...
Zufrieden wendest Du Dich ab, Dein Werk ist vollbracht, doch haette es nicht
gleich so sein sollen? Schuldbewusst wirfst Du Dir die Kapuze ueber den Kopf
und verschwindest aus dem dunklen Forst. Ein wuetendes Zischen verabschiedet
Dich, Du hoffst, dass die Veraenderung niemandem aufgefallen ist.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Honigmischen (Ark, 12. Apr 2006, 00:42:25):
Das sollte jetzt besser gehen und auch bei mehreren Zutaten zum gewuenschten
Erfolg fuehren. Dank dem Klammergriff :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Kleiner Fehler ... (Ark,  4. Mai 2006, 19:20:49):
Bei einer Korrektur der kleinen Aufgabe mit den Urspruengen der Rassen musste
ich leider denen die Aufgabe loeschen, die sie sich schon geholt hatten. Also
nicht boese sein, einfach nochmal zum Wicht gehen. Danke fuer das
Verstaendnis.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Kleiner Fehler ... (Ark,  4. Mai 2006, 19:22:01):
~#! rn=Ark rt=1146763249 rg=d.anfaenger
~#! tid=1146763249
Aeh, das heisst natuerlich nur die, die die Aufgabe begonnen, aber noch nicht
abgeschlossen haben. Wer sie hat, hat sie :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Kosten-Meldung fuer Anfaenger (Kessa, 18. Sep 2006, 15:26:33):
Heute hat mich ein Anfaenger gefragt, ob man die Kosten fuers Erhoehen auch
abfragen kann, ohne jedesmal die Seher-Bedingungen mitgeliefert zu bekommen,
die ja mit Lvl 1 noch nicht so sehr interessieren. Gibt es da eine
Moeglichkeit? Wenn nicht, wuerde ich vorschlagen, das einzurichten.

Kessa

-----------------------------------------------------------------------------



Re: Kosten-Meldung fuer Anfaenger (Gloinson, 18. Sep 2006, 15:32:52):
~#! rn=Kessa rt=1158585993 rg=d.anfaenger
~#! tid=1158585993
Kann man. Aber besser mehr Informationen als weniger, sonst beschwert sich der
naechste Anfaenger, er koenne seinen Fortschritt nicht schnell und auf einen
Blick sehen - zu Recht, faende ich.

<- kein EM, also nur IMHO


-----------------------------------------------------------------------------



Re: Re: Kosten-Meldung fuer Anfaenger (Kessa, 18. Sep 2006, 15:33:42):
~#! rn=Gloinson rt=1158586372 rg=d.anfaenger
~#! tid=1158585993
Klar. Ich meinte auch nur als Alternative, nicht als einzige Moeglichkeit.

-----------------------------------------------------------------------------



Re^3: Kosten-Meldung fuer Anfaenger (Gloinson, 18. Sep 2006, 15:39:20):
~#! rn=Kessa rt=1158586422 rg=d.anfaenger
~#! tid=1158585993
Naja, ganz bloed, aber die Alternative existiert ja: tf + gag

Sicher, man kann einen Schalter fuer den fortgeschritten Nutzer einbauen. Muss
nur ein Dingens abstempel. E-Vieh :)


-----------------------------------------------------------------------------



Re^4: Kosten-Meldung fuer Anfaenger (Sharia, 18. Sep 2006, 15:50:50):
~#! rn=Gloinson rt=1158586760 rg=d.anfaenger
~#! tid=1158585993
verstehe Gloinsons Argument nicht ganz

Den Fortschritt erkennt man ja gar nicht bei der Anzeige .. aber diesen ewigen
Sermon der nen ganzen oder halben Bildschirm vollscrollt was insgesamt alles
gemacht sein muss kann man ja vielleicht so einrichten dass man das ab level
10 oder so erst sieht...

-----------------------------------------------------------------------------



Re^5: Kosten-Meldung fuer Anfaenger (Gloinson, 18. Sep 2006, 16:11:29):
~#! rn=Sharia rt=1158587450 rg=d.anfaenger
~#! tid=1158585993
Oder 11? Oder 9? :)

Ich halte es fuer besser, einen Parameter zu erlauben um mit dem die
Seherkostenanzeige auszuschalten. Auf den wird am Ende der Seherkosten
hingewiesen:
"Mit 'kosten kurz' kannst du die Anzeige der Seherbedingungen unterdruecken."


-----------------------------------------------------------------------------



Re^6: Kosten-Meldung fuer Anfaenger (Orktoeter, 18. Sep 2006, 16:37:24):
~#! rn=Gloinson rt=1158588689 rg=d.anfaenger
~#! tid=1158585993
Ich wuerds eher anders herum machen: Nur das anzeigen was der kleine Spieler
wirklich braucht und unten einen Hinweis: mit "kosten lang" bekommst du
zusaetzlich angezeigt, was noch bis zum Seherstatus fehlt.

OrkT, auch 0,2 Eurocent in den Ring werfend.

-----------------------------------------------------------------------------



Re^7: Kosten-Meldung fuer Anfaenger (Kessa, 18. Sep 2006, 16:38:45):
~#! rn=Orktoeter rt=1158590244 rg=d.anfaenger
~#! tid=1158585993
Ich wuerde es dem Spieler selber ueberlassen, ob er das zuviel findet, so wie
es in Gloinsons Vorschlag gegeben ist.

-----------------------------------------------------------------------------



Re^8: Kosten-Meldung fuer Anfaenger (Rumata, 18. Sep 2006, 17:02:22):
~#! rn=Kessa rt=1158590325 rg=d.anfaenger
~#! tid=1158585993
Wie waere es mit "kosten kurz" und "kosten lang" und den default vom
Level abhaengig machen?

Rum**

-----------------------------------------------------------------------------



Re^9: Kosten-Meldung fuer Anfaenger (Boing, 18. Sep 2006, 17:07:54):
~#! rn=Rumata rt=1158591742 rg=d.anfaenger
~#! tid=1158585993
Ich wuerde es einfach so lassen wie es ist ...
  Boing

-----------------------------------------------------------------------------



Re^10: Kosten-Meldung fuer Anfaenger (Fibor, 18. Sep 2006, 17:30:57):
~#! rn=Boing rt=1158592074 rg=d.anfaenger
~#! tid=1158585993
Ich wuerde mich sehr freuen, wenn man den Seher-Scroll abstellen koennte.

Fibor

-----------------------------------------------------------------------------



Re^11: Kosten-Meldung fuer Anfaenger (Anthea, 18. Sep 2006, 17:34:01):
~#! rn=Fibor rt=1158593457 rg=d.anfaenger
~#! tid=1158585993
Gibt es doch schon: "Ebenen aus" :)

-----------------------------------------------------------------------------



Re^12: Kosten-Meldung fuer Anfaenger (Croft, 18. Sep 2006, 17:37:33):
~#! rn=Anthea rt=1158593641 rg=d.anfaenger
~#! tid=1158585993
Du weisst schon, dass du Fibor gerade missverstehst, Anthea?

Croft

-----------------------------------------------------------------------------



Re^13: Kosten-Meldung fuer Anfaenger (Zook, 18. Sep 2006, 17:57:22):
~#! rn=Croft rt=1158593853 rg=d.anfaenger
~#! tid=1158585993
kosten [kurz] 
klingt vernuenftig.
zook.

-----------------------------------------------------------------------------



Re^14: Kosten-Meldung fuer Anfaenger (Zook, 18. Sep 2006, 18:04:33):
~#! rn=Zook rt=1158595042 rg=d.anfaenger
~#! tid=1158585993
eingebaut. funzt bisher in der abenteurer-gilde ;) andere gilden moegen
die jeweiligen gm gerne selbst neuladen ;) zook.

-----------------------------------------------------------------------------



Re^6: Kosten-Meldung fuer Anfaenger (Ark, 18. Sep 2006, 20:57:18):
~#! rn=Gloinson rt=1158588689 rg=d.anfaenger
~#! tid=1158585993
Wir unterhalten uns aber nicht bald ueber Gildenangaben wie "schaetz kurz",
"schaetz ultrakurz", "schaetz alles ausser Kampftritt, Schildstoss und Finte"?
Fuer das, was ihr wollt, gibt es ein more mit 2 Zeilen ;)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^7: Kosten-Meldung fuer Anfaenger (Kessa, 18. Sep 2006, 21:02:53):
~#! rn=Ark rt=1158605838 rg=d.anfaenger
~#! tid=1158585993
Naja, fuer Anfaenger ist es schon was besonderes, zu sehen, wie sie ihre
ersten Fortschritte machen. Es scheint ja auch prima zu klappen, dass sie die
Syntax ueberhaupt kennen. (Ich glaube, ich habe selber erst als Seher den
Befehl 'kosten' gefunden.) Ich finde es sehr nachvollziehbar, wenn sie das
dann oft machen wollen und dann das sehen wollen, was sie auch interessiert.
Spells u. dgl. sind gaaaar kein Argument, die kann man eh schon gesondert
abfragen.

Kessa, eine Lanze brechend

-----------------------------------------------------------------------------



Re^8: Kosten-Meldung fuer Anfaenger (Zook, 18. Sep 2006, 21:54:51):
~#! rn=Kessa rt=1158606173 rg=d.anfaenger
~#! tid=1158585993
is ja nun eh schon eingebaut. :) zook.

-----------------------------------------------------------------------------



Re^9: Kosten-Meldung fuer Anfaenger (Maharet, 18. Sep 2006, 22:01:57):
~#! rn=Zook rt=1158609291 rg=d.anfaenger
~#! tid=1158585993
Neues-Leser wissen das ;)

-----------------------------------------------------------------------------



Heiler fuer Anfaenger? (Kessa, 25. Sep 2006, 23:19:41):
Wenn neue Spieler sich vergiften oder, wie heute geschehen, sich mit einem
Schnupfen anstecken, kann das recht irritierend und nervend sein (auch fuer
die Cicerones, die sich bemuehen, bei den allerersten Schritten zu helfen und
ihre Zeit nicht unbedingt noch damit verbringen wollen, noch den langen Weg
nach Katzmandu vor- und zurueck mitzulaufen). Wie waere es, wenn es an einer
zentraleren Stelle einen Heiler fuer die kleineren Malessen gaebe, wie leichte
Vergiftung, leichte Krankheit und Verfroschung? Z.B. im Elfendorf oder in Port
Vain?

Gruss, Kessa und (i.A.) Janne

-----------------------------------------------------------------------------



Re: Heiler fuer Anfaenger? (Ark, 25. Sep 2006, 23:46:26):
~#! rn=Kessa rt=1159219181 rg=d.anfaenger
~#! tid=1159219181
Hm, bevor jetzt ueberall Heiler hochpoppen ... anfaengerfreundlich gut und
schoen, aber muessen wir jedem noch den Mund abputzen? Das soll nicht so
abfaellig sein, wie es klingt, aber mir fiel kein anderer Vergleich ein. Vom
Schnupfen stirbt man nicht, kleines Gift ueberlebt man zur Not. Und einer wird
nicht reichen, wenn man das will, stellt man einen in den Dschungel (wozu gibt
es den Felinenheiler dann noch?), in die Unterwelt, in den Wald ... und wo
immer man als Anfaenger noch damit auftauchen koennte.
Ehrlich gesagt ... dagegen. Dafuer, dass man hingefuehrt wird. Und mal ehrlich
... hat uns das "angenervt" damals? Ich mag keinen so konditionieren, dass
eine Loesung fuer alles in der Nachbarschaft liegt. Sterben gehoert hier dazu,
das ist schon manchmal irritierend, aber so schlimm auch nicht.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Heiler fuer Anfaenger? (Seleven, 25. Sep 2006, 23:47:56):
~#! rn=Kessa rt=1159219181 rg=d.anfaenger
~#! tid=1159219181
Ich waere stark dafuer - wuerde auch einen schreiben, wenn kein anderer sich
findet. Was soll er denn alles koennen? Vorschlaege fuer einen Ort?
Seleven.

-----------------------------------------------------------------------------



Re: Re: Heiler fuer Anfaenger? (Kessa, 25. Sep 2006, 23:55:52):
~#! rn=Ark rt=1159220786 rg=d.anfaenger
~#! tid=1159219181
Nicht ueberall. Nur einen, in der Naehe der einschlaegigen Anfaengergebiete
Hochebene und Wichtelwald. Es geht ja nicht ums Sterben, sondern um
ungestoertes Anleiten ohne unnoetigen Zeitaufwand (es gibt recht viele
Anfaenger zur Zeit, und ich verbring manchmal schon mehrere Stunden am Tag
damit). Der koennte von mir aus auch Spielern ab Lvl 5 oder so die Hilfe
verweigern, wenn es keine Goldrand-Tablett-Loesung fuer alle sein soll.

Und der Schnupfen heute war ansteckend, den hatten nicht nur die
telnetbewehrten Anfaenger sondern auch der Cicerone, damit erklaert es sich
einfach nicht so gut.

-----------------------------------------------------------------------------



Re: Re: Heiler fuer Anfaenger? (Ark, 25. Sep 2006, 23:55:54):
~#! rn=Ark rt=1159220786 rg=d.anfaenger
~#! tid=1159219181
Eins hab ich noch vergessen: mehr Heiler laesst die Kleriker auf kleiner Stufe
gaehnen. Auch wenn keiner da sein sollte, es ist durchaus positiv im Sinne von
Multi (..UD), wenn nicht alles durch NPC gemacht wird, sondern durch
Gildeninteraktion (auch wenn das fuer einige jetzt erschreckend klingt :-) ).
Ansonsten wirf die Kleris aufs Keulenabstellgleis.
Und wenn jetzt einer mit dem Argument kommt, das waer heut eh schon nicht so,
dann schlag ich i^H^H^H^H^H^H^H^H^H bestaetigt er das, was ich gesagt habe :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Re: Heiler fuer Anfaenger? (Seleven, 25. Sep 2006, 23:56:34):
~#! rn=Ark rt=1159220786 rg=d.anfaenger
~#! tid=1159219181
Schon, aber wenigstens auf den ersten Leveln. Ein NPC, der auch sagt wohin man
gehen kann. Und einer muesste reichen - Pfad Port Vain -> Elfendorf,
Abzweigung zur HE. Das ist zwischen Ebene, Wald und Gebirge. Im Dschungel
sollte man zum Heiler in Katzmandu, ein Anfaenger in der Unterwelt hat Pech
gehabt - ueberlegt er, ob dunkle Hoehlen vielleicht nicht so toll sind.
Ist vielleicht ein wenig zu viel Aufwand, aber der Anfaenger fuehlt sich nicht
ganz hilflos.

-----------------------------------------------------------------------------



Re^3: Heiler fuer Anfaenger? (Ark, 26. Sep 2006, 00:00:32):
~#! rn=Seleven rt=1159221394 rg=d.anfaenger
~#! tid=1159219181
Ok, aber die Gegenden, die ihr genannt habt, sind fuer obige Gefahren
eigentlich nicht praedestiniert, oder? Generell bin ich immer noch nicht
ueberzeugt :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^4: Heiler fuer Anfaenger? (Kessa, 26. Sep 2006, 00:02:53):
~#! rn=Ark rt=1159221632 rg=d.anfaenger
~#! tid=1159219181
Es ist aber doch passiert :) und Vergiftungen (k.A., woher) und Verfroschen
kamen schon oefter vor (der Kuss-Frosch sitzt immerhin direkt vorm Imbiss).

-----------------------------------------------------------------------------



Re^5: Heiler fuer Anfaenger? (Gnome, 26. Sep 2006, 00:06:07):
~#! rn=Kessa rt=1159221773 rg=d.anfaenger
~#! tid=1159219181
wie waere es, das, wenn ueberhaupt, in den sandtiger einzubauen?
den kennt jeder, er liegt zentral und ein neuer npc mit neuer geschichte
und neuem raum muesste auch nicht her.

gnOme

-----------------------------------------------------------------------------



Re^6: Heiler fuer Anfaenger? (Kessa, 26. Sep 2006, 00:07:19):
~#! rn=Gnome rt=1159221967 rg=d.anfaenger
~#! tid=1159219181
Das waere doch mal ne nette Idee.

-----------------------------------------------------------------------------



Re^7: Heiler fuer Anfaenger? (Humni, 26. Sep 2006, 00:07:47):
~#! rn=Kessa rt=1159222039 rg=d.anfaenger
~#! tid=1159219181
Das ist euch lieber als ein weiterer, stupsender Heiler? ;-)

Humni

-----------------------------------------------------------------------------



Re^8: Heiler fuer Anfaenger? (Gnome, 26. Sep 2006, 00:09:53):
~#! rn=Humni rt=1159222067 rg=d.anfaenger
~#! tid=1159219181
was fuer ein sinn haette denn ein staendig toter heiler? ;)

-----------------------------------------------------------------------------



Re^5: Heiler fuer Anfaenger? (Ark, 26. Sep 2006, 00:10:35):
~#! rn=Kessa rt=1159221773 rg=d.anfaenger
~#! tid=1159219181
Ich ueberlege grade, was die armen Anfaenger damals gemacht haben ... und
denke, nicht alles war so schlimm damals, als dass man es sofort mit einer
Gegenmassnahme bekaempfen muss. Wie gesagt, ich sehe den Sinn nicht so ganz,
ausser, dass man Anfaengern noch fixer mal sagen kann, geh 2x o, da steht er
schon. Schoener waere es, wenn man die Zeit faende, selbst hinzugehen und zu
helfen (wie es frueher geschah, hoerthoert). Das soll nun keine Anschuldigung
sein, dass es nicht passiert, aber wenn man da ist, laesst sich so vieles
erklaeren, dass man genauso gut mal nen Spaziergang nach Nibelheim oder
Katzmandu unternehmen kann.
Mal eine Stunde Anfaengerbetreuung und ein paar ZTs mitsuchen, plaudern ... so
naiv stell ich mir das zumindest vor.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^6: Heiler fuer Anfaenger? (Esme, 26. Sep 2006, 00:14:53):
~#! rn=Ark rt=1159222235 rg=d.anfaenger
~#! tid=1159219181
Ich moechte mich Ark da anschliessen.
Abgesehen davon kann man auch Anfaengern ein bisschen Eigenstaendigkeit 
zugestehen.
Wenn ich mich ausserdem an meine Anfaenge erinnere, dann hat eben auch
der Nervenkitzel, das es tatsaechlich mal eine Vergiftung oder aehnliches
gibt, dazu beigetragen mich zu fesseln.

Esme

-----------------------------------------------------------------------------



Re^6: Heiler fuer Anfaenger? (Kessa, 26. Sep 2006, 00:15:29):
~#! rn=Ark rt=1159222235 rg=d.anfaenger
~#! tid=1159219181
Vielleicht gingen damals auch einfach viele wieder und es fiel nur nicht so
auf, weil es eh so viele Spieler gab. Jetzt haben wir Cicerones, um das
moeglichst aufzufangen. Die Anfaenger nehmen das auch gern an und lassen sich
meist recht intensiv begleiten. Ich faende es einfach hilfreich, wenn man
dabei anfangs in einem Gebiet bleiben koennte. Nibelheim ist auch nicht gerade
das zugaenglichste Gebiet, da wuerde man einiges an eigener Forscherei
vorwegnehmen.

-----------------------------------------------------------------------------



Re^6: Heiler fuer Anfaenger? (Grimmborn, 26. Sep 2006, 00:17:45):
~#! rn=Ark rt=1159222235 rg=d.anfaenger
~#! tid=1159219181
> Ich ueberlege grade, was die armen Anfaenger damals gemacht haben ... und
> denke, nicht alles war so schlimm damals

Ah, dann lass Dir bei Gelegenheit mal ein paar Stories ueber eine
Schnupfenepidemie Anno '94 erzaehlen. :-) 

GdA

-----------------------------------------------------------------------------



Re^7: Heiler fuer Anfaenger? (Janne, 26. Sep 2006, 00:36:20):
~#! rn=Grimmborn rt=1159222665 rg=d.anfaenger
~#! tid=1159219181


Also, ich bin ganz klar fuer einen Heiler in dem bereits genannten Gebiet. Ich
habe eben zwei Anfaengern, die noch gar keine Ahnung hatten, das MG erklaert,
bzw. damit begonnen. Leider brachte einer davon aus dem Elfendorf einen
Schnupfen mit, wo er offensichtlich - von wem auch immer - angesteckt wurde
(insgesamt litt er 50 Minuten darunter). Nun standen wir zu dritt  da und
haben uns gegenseitig angeniest, was zu einem enormen Scroll fuehrte. 
Mich hat es schon fast beeindruckt, dass die beiden nicht sofort das Handtuch
geschmissen haben. Jedenfalls war die Vorstellung, mit den beiden im
Schlepptau ins Hospital oder nach Katzmandu zu pilgern, nicht so wirklich
traumhaft. Hat lange genug gedauert, um so schon die Funktionen und Befehle zu
erklaeren, ohne dass ich noch auf grosse Wanderschaft musste, wo beide mir
abgedreht waeren bei dem Scroll und dem - fuer absolute Anfaenger -
verwirrenden Weg.

Den Tiger als Heilstelle fuer Level 1-2 Anfaenger zu nehmen, find ich eine
prima Idee. Und danach ist es dann kein Problem mehr, die ueblichen Heiler in
Anspruch zu nehmen.

Janne

-----------------------------------------------------------------------------



Re^8: Heiler fuer Anfaenger? (Alkohol, 26. Sep 2006, 10:08:23):
~#! rn=Janne rt=1159223780 rg=d.anfaenger
~#! tid=1159219181
Ich seh eigentlich nicht ganz ein, wieso wir kleinen Anfaengern alles so
einfach wie moeglich machen wollen. Ichhab das eigentlich damals als sehr
schoen empfunden, dass ich viele Dinge gerade von groesseren Spielern mit viel
Geduld gezeigt bekommen habe, die haben mir aber auch nicht alles gesagt,
sondern mich viele Sachen auch einfach suchen lassen. Ausserdem halte ich es
fuer ein schlechtes Signal. Die kleinen Spieler bekommen alles in kleinen
Bissen vorgekaut, aber irgendwann kommt der Schritt, dass sie fluegge werden
muessen. Wenn sie davon ueberfordert werden, hoeren sie dann auf zu spielen.
Daher finde ich es besser, wenn man in kleinen Schritten herangefuehrt wird
von Anfang an. Daher bin ich klar gegen einen heilenden Sandtiger fuer Level
1-2. Dann kommt das Geschrei der Level 3-Spieler, wieso der Sandtiger nicht
mehr tut.

Alki

-----------------------------------------------------------------------------



Re^9: Heiler fuer Anfaenger? (Miril, 26. Sep 2006, 10:26:40):
~#! rn=Alkohol rt=1159258103 rg=d.anfaenger
~#! tid=1159219181
Generell denke ich auch, dass so ein Heiler nicht noetig sein sollte. Es 
gibt hier gluecklicherweise noch Spieler und auch Kleriker, die in solchen
Faellen taetig werden koennen. Das hat in der aktuellen Situation gestern
ja auch rech flott geklappt, man muss halt nur mal nachfragen.

Miril

-----------------------------------------------------------------------------



Re^10: Heiler fuer Anfaenger? (Huraxprax, 26. Sep 2006, 14:56:07):
~#! rn=Miril rt=1159259200 rg=d.anfaenger
~#! tid=1159219181
Es gibt ja schon ein Krankenhaus das absolut zentral gelegen ist: die
Finsterwaldklinik. Nur macht sie beim Heilen nicht das was sie soll, und die
halbnackterankenschwester ist fuer Anfaenger eher eine Todesfalle.

-----------------------------------------------------------------------------



Re^9: Heiler fuer Anfaenger? (Kessa, 26. Sep 2006, 15:51:14):
~#! rn=Alkohol rt=1159258103 rg=d.anfaenger
~#! tid=1159219181
Ich antworte mal auf deinen stellvertretend fuer alle
Frueher-ging-alles-auch-ohne-sowas-prima-Artikel: Klar. Auch ohne Cicerones.
Wozu haben wir die eigentlich?

-----------------------------------------------------------------------------



Re^10: Heiler fuer Anfaenger? (Zesstra, 26. Sep 2006, 15:55:56):
~#! rn=Kessa rt=1159278674 rg=d.anfaenger
~#! tid=1159219181
Ich persoenlich verstehe nicht so ganz das Problem an einem Sandtiger, der bis
Level 2 heilt und darauf aufmerksam macht, wo man hingehen sollte, wenn man
krank ist, bzw. warum das so boese ist. Bei vielen Spielen steigt die
Komplexitaet des Spielgeschehens erst langsam an.
Ich seh auch keine Entwertung von Klerikern oder bestehenden Heilern. (Zumal
auf -klerus auch mal oefter gar keine Kleriker anwesend sind.)

Sind natuerlich nur meine 2 Cent zu dem Thema,
Zesstra

-----------------------------------------------------------------------------



Re^10: Heiler fuer Anfaenger? (Esme, 26. Sep 2006, 15:56:22):
~#! rn=Kessa rt=1159278674 rg=d.anfaenger
~#! tid=1159219181
Dazu, durch die Kennzeichnung von Anprechpartnern die Schwelle, jemanden um
Hilfe anzuhauen zu senken?
Das finde ich auch gut so, ebenso wie der inzwischen wesentlich freundlicheren
Ton auf den Ebenen.
Aber fuer mich das trotzdem kein Argument in den Sandtiger eine Heilstelle
fuer kleine Spieler
einzubauen.

Gruss, Esme

-----------------------------------------------------------------------------



Re^10: Heiler fuer Anfaenger? (Ark, 26. Sep 2006, 16:00:46):
~#! rn=Kessa rt=1159278674 rg=d.anfaenger
~#! tid=1159219181
Das ist aber genau das, was vermieden werden soll: wenige Cicerones da und
aktiv und auch sonst keine Helfer ... hm, dann muss das ein Raum/NPC/Objekt
uebernehmen. Und im Endeffekt hast Du auch spaeter bei mehr Spielern ein
(ueberspitzt dargestelltes) Verhalten ala "geh doch zum Sandtiger und lass uns
in Ruhe damit".
Steht ein NPC oder so mal da, wirst Du das Foermchen nur schlecht ohne
Geschrei wieder aus den Haenden der verwoehnten Spieler (heut hab ich es aber
mit ueberspitzten Darstellungen, oder? :-) ) herausbekommen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^11: Heiler fuer Anfaenger? (Seleven, 26. Sep 2006, 16:14:43):
~#! rn=Ark rt=1159279246 rg=d.anfaenger
~#! tid=1159219181
Anderer Vorschlag: Weg von einem festen Punkt, hin zu etwas Tragbarem (von
tragen wie mitnehmen). Wie waere es mit einem Erste-Hilfe-Set (1xGegengift,
2xErkaeltungstee und 1xAnti-Frosch-Pille) fuer Anfaenger? Man koennte das als
(Mini)Questbelohnung. Man kann ja beim Ueberreichen auf die gaengigen Heiler
hinweisen. Wenn der Anfaenger sich oefters vergiftet oder den Krosch zwei mal
knuddelt, kann man es immer noch unter doof abtun und ihn zum Heiler
schleppen. Natuerlich kann ich auch weiterhin demjenigen mitteilen, dass er
ruhig bleiben und aufs toeten verzichten soll - das mach ich meistens, wenn
ich gerade keine Zeit/Lust habe jemanden in den Dschungel zu verfrachten (der
will dann naemlich _sicher_ wiedr zurueck und hat keine Karte gemalt).

Seleven wirft noch 2 cent in die Buechse und fragt sich, was aus dem Geld
wird.

-----------------------------------------------------------------------------



Re^12: Heiler fuer Anfaenger? (Maharet, 26. Sep 2006, 16:22:51):
~#! rn=Seleven rt=1159280083 rg=d.anfaenger
~#! tid=1159219181
Vielleicht wartet man am besten mal ein paar Wochen ab, wie oft denn solche
Situationen auftauchen. Das mit dem komischen Schnupfen gestern war nun ein
extremer Sonderfall. Der Dschungelschnupfen ist ja nun wirklich harmlos, eine
einfache Vergiftung verklingt auch von allein - und um eine Vergiftung zu
heilen, braucht man nicht mal nen Kleri, das koennen die meisten groesseren
Spieler.
Interessanter waere doch herauszufinden, was die beiden fuer eine komische
Krankheit hatten.

Maha
n.

-----------------------------------------------------------------------------



Re^10: Heiler fuer Anfaenger? (Alkohol, 26. Sep 2006, 16:48:21):
~#! rn=Kessa rt=1159278674 rg=d.anfaenger
~#! tid=1159219181
ich hab gar nicht gesagt, frueher war alles besser. Ich habe vor allem gesagt,
wenn wir die Leute nicht fluegge werden lassen, dann sterben sie, wenn sie aus
dem Nest fallen, weil sie zu gross sind. Wir sollten ihnen helfen, fluegge zu
werden. Und es nicht versuchen zu verhindern.

Alki

-----------------------------------------------------------------------------



Re^11: Heiler fuer Anfaenger? (Kessa, 26. Sep 2006, 16:54:49):
~#! rn=Alkohol rt=1159282101 rg=d.anfaenger
~#! tid=1159219181
Was meinst du denn, was wir Cicerones tun, denkst du, _wir_ wollen die
Anfaenger auf ewig an uns ketten? :) Ein Punkt, den ich irgendwie nicht so
recht rueberzubringen scheine, ist, dass der Vorschlag auch fuer _uns_ eine
Erleichterung bringen koennte. Und wie schon wiederholt gesagt wurde, es geht
nur um die allerersten Schritte, Lvl 1-2 oder so. Nur bis wir mit der
Einfuehrung durch sind.

-----------------------------------------------------------------------------



Re^12: Heiler fuer Anfaenger? (Arathorn, 26. Sep 2006, 16:58:39):
~#! rn=Kessa rt=1159282489 rg=d.anfaenger
~#! tid=1159219181
Bei "Einfuehrung" springt mich spontan die Erinnerung an ein gewisses, schon
ewig angekuendigtes ingame-Tutorial an. Waere es nicht evtl. sinnvoll, dieses
mal nachhaltig anzuschieben, und dort auch gleich die Heil- und Entgifte-
Infos bzw. das von Seleven vorgeschlagene Erste-Hilfe-Kit einzubringen?

Gruss, Arathorn.

-----------------------------------------------------------------------------



Re^12: Heiler fuer Anfaenger? (Alkohol, 26. Sep 2006, 16:59:21):
~#! rn=Kessa rt=1159282489 rg=d.anfaenger
~#! tid=1159219181
nein, den Punkt hab ich noch nciht verstanden. Wenn es um Entgiftung geht,
waere es doch viel einfacher, den Spieler selber zu entgiften, als ihn zum
Sandtiger zuschicken. Und bevor man ihm erklaert hat, aehm, aber wenn du level
3 bist, geht das nicht mehr, hat man ihm erklaert, wo es einenHeiler gibt. Da
kann man ihm auch gleich erklaeren, da gibts ne nette Quest, die kannst du
machen. Die bringt Dir auch was in Richtung, dass der Sandtiger bald nicht
mehr geht. Und ich glaube Maharet hat recht. Es ist sehr sehr selten, dass
Spieler mit Level 1oder 2 ueberhaupt in die Verlegenheit kommen, den Heiler
wirklich zu brauchen.

Alki

-----------------------------------------------------------------------------



Re^13: Heiler fuer Anfaenger? (Kessa, 26. Sep 2006, 17:05:39):
~#! rn=Alkohol rt=1159282761 rg=d.anfaenger
~#! tid=1159219181
Alkohol: es kommt vielleicht oefter vor, als du denkst, wenn auch nicht so
extrem wie gestern. Einem Anfaenger waehrend der Einfuehrung 'erklaeren', wo
Katzmandu ist? Dann kannst du die Einfuehrung vergessen :)

Arathorn: Wenn das noch realistisch ist, nur zu gerne. Dann wuerden wir nicht
mehr bei Null anfangen ('Wie kann ich mich bewegen?') und haetten mehr Zeit
fuer anderes (wie nach Katzmandu zu dackeln). Das Web-Tutorial macht das ja,
einigen ist das allerdings so im Netz zu viel zu lesen und sie moechten direkt
hier anfangen. Fuer die waere das ideal.

-----------------------------------------------------------------------------



Re^14: Heiler fuer Anfaenger? (Alkohol, 26. Sep 2006, 17:12:58):
~#! rn=Kessa rt=1159283139 rg=d.anfaenger
~#! tid=1159219181
ok, und was sagst du, wenn ein Spieler dich fragt: Ich will Katzenjammer
machen, ich mag Katzen so gerne. Ist es dann auch zu schwer, ihm zu erklaeren,
wie man nach Katzmandu kommt? Und wo ist das Problem zu sagen, hm du hast dir
ne schwerwiegende Krankheit geholt (zB die Syphilis, die kann man sich auch
mit Level 1 schon holen *g* (einen em angrins *g*)), die ist nur schwer
heilbar, das kann nur eine Spezialklinik, da muessen wir jetzt hin. Fuer
gewisse Krankheiten faehrt man ja rl ziemlich weit. Du hast die Lacher auf
deiner Seite. Da kann man doch echt was raus machen, was die Leute witzig
finden und bei der Stange haelt.

ok, und was sagst du, wenn ein Spieler dich fragt: Ich will Katzenjammer
machen, ich mag Katzen so gerne. Ist es dann auch zu schwer, ihm zu erklaeren,
wie man nach Katzmandu kommt? Und wo ist das Problem zu sagen, hm du hast dir
ne schwerwiegende Krankheit geholt (zB die Syphilis, die kann man sich auch
mit Level 1 schon holen *g* (einen em angrins *g*)), die ist nur schwer
heilbar, das kann nur eine Spezialklinik, da muessen wir jetzt hin. Fuer
gewisse Krankheiten faehrt man ja rl ziemlich weit. Du hast die Lacher auf
deiner Seite. Da kann man doch echt was raus machen, was die Leute witzig
finden und bei der Stange haelt. 

Und ein bischen rumniesen, weil man im Regen stand, da seh ich nun wirklich
das Problem nicht. Wenn das ein Problem ist, sollte man dann lieber nicht das
Niesen abhaengen, weil es ja Spieler vertreibt?

Alki

-----------------------------------------------------------------------------



Re^15: Heiler fuer Anfaenger? (Alkohol, 26. Sep 2006, 17:13:14):
~#! rn=Alkohol rt=1159283578 rg=d.anfaenger
~#! tid=1159219181
ups, ich kann die mpa einfach nciht bedienen

-----------------------------------------------------------------------------



Re^16: Heiler fuer Anfaenger? (Alkohol, 26. Sep 2006, 17:18:18):
~#! rn=Alkohol rt=1159283594 rg=d.anfaenger
~#! tid=1159219181
was weiss der sandtiger eigentlich ueber die syphilis, kann der da
einschlaegig bekannte experten nennen, an die man sich vertrauensvoll wenden
kann?

Alki

-----------------------------------------------------------------------------



Re^15: Heiler fuer Anfaenger? (Kessa, 26. Sep 2006, 17:30:24):
~#! rn=Alkohol rt=1159283578 rg=d.anfaenger
~#! tid=1159219181
Wenn einer partout direkt nach Katzmandu will, bringe ich ihn natuerlich nach
Katzmandu. Allerdings bietet sich fuer den ersten Tag die Hochebene zumindest
fuer Nicht-Felinen eher an, schon wegen der Zaubertraenke, und das wollen dann
auch normalerweise alle.

-----------------------------------------------------------------------------



Re^16: Heiler fuer Anfaenger? (Anatol, 26. Sep 2006, 17:33:13):
~#! rn=Kessa rt=1159284624 rg=d.anfaenger
~#! tid=1159219181
Dabei bringt die Katzenjammer-Quest dem Anfaenger eine ganze Menge
Basiswissen zum Thema "Umgang mit der Umwelt" bei. Schoene Quest.

Anatol

-----------------------------------------------------------------------------



Re^17: Heiler fuer Anfaenger? (Kessa, 26. Sep 2006, 17:49:54):
~#! rn=Anatol rt=1159284793 rg=d.anfaenger
~#! tid=1159219181
Da gebe ich dir absolut recht. Bei den allerersten Schritten geht es
allerdings meist noch gar nicht ums Questen. Fast alle wollen anfangs wissen,
wie sie ihre Attribute erhoehen koennen. Daher gehe ich mit einem Neuen meist
erstmal zur Hochebene, setze ihn dabei aufs Kartographieren an, helfe ihm, das
Orakel zu finden (wobei er auch interagieren muss), erklaere ihm das mit den
Spruechen und suche ggf. mit ihm zusammen den ersten Zaubertrank. Daneben
werden noch Ebenen und Kommunikation erklaert. Wenn er dann soweit ist, die
erste Quest anzugehen, bin ich eigentlich vorerst mit ihm fertig und die
Ebenen und Schrat/Fee/Heiler/Wichtelkoenig uebernehmen.

-----------------------------------------------------------------------------



Re: Heiler fuer Anfaenger? (Gloinson, 28. Sep 2006, 17:49:35):
~#! rn=Kessa rt=1159219181 rg=d.anfaenger
~#! tid=1159219181
Es wurde ja schon ein paar Mal angedeutet, aber mal ganz deutlich gefragt: Wo
ist denn das Multi in MUD?

Ich hab mir mal die Muehe gemacht und bei knapp 5 Tage Uptime und einer
Anfrage von vor 3 Tagen den Klerikerkanal angesehen. Nichts.
Hier also mein sehr einfacher Vorschlag: man bringe den Ersties oder sich
selber als erstes ein "-kl Kann mich jemand kurieren, ich bin krank und kenn
mich hier nicht aus!" bei.

Jetzt kommt sicher gleich das tolle Argument: Aber da ist ja gar keiner da!
Das koennte vielleicht daran liegen, dass es das Konzept "Zweities" gibt (und
an unangenehmen Effekten fuer Kleriker, wenn sie mal einfach so irgendwo
ideln) und das "kwer" daher nicht der Weisheit letzter Schluss ist. War es
noch nie, in keiner Lage, fuer mich haben sich schon zu meinen Anfaengerzeiten
Leute mal umgeloggt um mir irgendwo herauszuhelfen:
Das Multi in MUD.

Nur: wer nicht fragt, bekommt auch kein 'M'. Der bekommt einen NPC-Heiler, ein
Anfaengerpflegekit und demnaechst einen weiteren Klerikerzweitie.


-----------------------------------------------------------------------------



Neuspieler-Tutorial (Ennox,  9. Okt 2006, 09:40:13):
Da uns zur Zeit soviele Anfaenger besuchen, habe ich den alten
Steinbeisser bekniet, sein Versprechen wahr zu machen, ihnen mit Rat
und Tat in einem Neuspieler-Tutorial zur Seite zu stehen.

Das Tutorial ist fuer alle zugaenglich, jeder, der frei von Feinden
ist und in seinem (Rassen-)Startraum "tutorial" eingibt, wird magisch
dorthin bewegt.

Ganz vielen Dank an Prinzessin, deren umfangreichen Arbeiten das
Tutorial ausmachen. Weiterhin an die fleissigen Tester, vor allem
Janne, Kaera, Xutelius, Zesstra und Tapsi.

Ich wuensche Euch allen viel Spass dabei, meldet fleissig Bugs, Ideen
und Typos (die NPCs loggen fehlende Infos mit).

Ennox, der schon gespannt ist, wie das ganze ankommt.

-----------------------------------------------------------------------------



Re: Neuspieler-Tutorial (Knurps,  9. Okt 2006, 15:49:51):
~#! rn=Ennox rt=1160379613 rg=d.anfaenger
~#! tid=1160379613
Wo ich das gerade im Tutorial sehe: 
Um Kaempfen zu koennen, brauchst Du zuerst einmal einen Gegner. Hier im
MorgenGrauen duerfen das KEINE Spieler sein. Also nur Spielcharaktere
(Monster, NPCs .. Non Player Characters).

Es hat mir noch niemand verstaendlich erklaeren koennen. Aber warum bekommen
Spieler nicht ein _query_no_attack { return this_region()!="Schattenwelt" &&
query_once_interactive(this_player()); } oder als nicht-tech-sprech: Warum
unterbindet man PKs nicht einfach mal technisch?

-----------------------------------------------------------------------------



Re: Re: Neuspieler-Tutorial (Boing,  9. Okt 2006, 16:10:08):
~#! rn=Knurps rt=1160401791 rg=d.anfaenger
~#! tid=1160379613
Weil es ein guter Idiotenfilter ist. D.h. Du erkennst die Volldeppen
bevor sie richtig Schaden anrichten koennen.
Ok, wahrscheinlich haben die Leute die nur nerven wollen eh nicht
genug Geduld um ernsthaft Schaden anzurichten. Aber das war zumindest
mal der Gedankengang fuer das Nichtunterbinden des Angriffs.
  Boing

-----------------------------------------------------------------------------



Re: Re: Neuspieler-Tutorial (Orktoeter,  9. Okt 2006, 23:49:43):
~#! rn=Knurps rt=1160401791 rg=d.anfaenger
~#! tid=1160379613
Es gibt Gebiete wie die Arena in denen es durchaus erlaubt (notwendig) ist,
andere Spieler anzugreifen (teilweise sogar zu toeten).

OrkT.

-----------------------------------------------------------------------------



Re^3: Neuspieler-Tutorial (Maharet,  9. Okt 2006, 23:50:33):
~#! rn=Orktoeter rt=1160430583 rg=d.anfaenger
~#! tid=1160379613
Das hatte Knurps doch bedacht und in seinem Beispiel abgefragt.

-----------------------------------------------------------------------------



Re^11: Heiler fuer Anfaenger? (Darklor, 10. Okt 2006, 22:48:24):
~#! rn=Zesstra rt=1159278956 rg=d.anfaenger
~#! tid=1159219181
Ich faend na wandernden Heiler, der auf den Pfaden der Anfaenger herumwandert
interessant, natuerlich metzelbar. Mit dem Hinweis, wenn man die Leiche
findet: Dies war einst ein grossartiger Heiler von einem fiesen Spieler
dahingemetzelt kommt fuer ihn jede Heilung zu spaet.

Darklor

-----------------------------------------------------------------------------



FP im Tutorial (Mesirii, 13. Okt 2006, 21:56:31):
Wie mir Rikus gerade verkuendete, lohnt sich das Forschen im Tutorial jetzt
fuer alle.
Mesi

-----------------------------------------------------------------------------



Re: FP im Tutorial (Orktoeter, 13. Okt 2006, 21:58:07):
~#! rn=Mesirii rt=1160769391 rg=d.anfaenger
~#! tid=1160769391
Und die ganzen Altcharactere die sich das irgendwann mal durchgelesen haben
muessen es sich entweder noch mal durchlesen oder sind (mal wieder), die
gear^W Benachteiligten.

-----------------------------------------------------------------------------



Re: Re: FP im Tutorial (Maharet, 13. Okt 2006, 22:02:49):
~#! rn=Orktoeter rt=1160769487 rg=d.anfaenger
~#! tid=1160769391
Wann haben denn diese Altcharaktere das gelesen?

-----------------------------------------------------------------------------



Re: Re: FP im Tutorial (Ark, 13. Okt 2006, 22:02:55):
~#! rn=Orktoeter rt=1160769487 rg=d.anfaenger
~#! tid=1160769391
Welche armen Altcharakter???? Das ist brandneu.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^3: FP im Tutorial (Orktoeter, 13. Okt 2006, 22:05:41):
~#! rn=Ark rt=1160769775 rg=d.anfaenger
~#! tid=1160769391
Okok.. ich habe es nicht genau genug gelesen.. dachte das Tutorial fuer die
diversen Hilfeseiten stuende...

Ziehe meine Kritik hiermit zurueck.

-----------------------------------------------------------------------------



Re: FP im Tutorial (Miril, 13. Okt 2006, 22:41:57):
~#! rn=Mesirii rt=1160769391 rg=d.anfaenger
~#! tid=1160769391
Mein armer Zweitie muss sich das jetzt nochmal angucken. Sowas aber auch.

Miril

-----------------------------------------------------------------------------



Re: Re: FP im Tutorial (Mesirii, 13. Okt 2006, 22:42:25):
~#! rn=Miril rt=1160772117 rg=d.anfaenger
~#! tid=1160769391
Rikus ist schuld, der war zu langsam :)
Mesi

-----------------------------------------------------------------------------



Re^3: FP im Tutorial (Ark, 13. Okt 2006, 22:50:51):
~#! rn=Mesirii rt=1160772145 rg=d.anfaenger
~#! tid=1160769391
Wenn, dann muss man mir in den ... Fuss treten. Ich hab das zu spaet gecheckt
und war voller Anschlusswahn. Mea culpa. Ab nun wieder das volle Programm.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Spinnenschwert (Ark, 15. Okt 2006, 13:48:29):
Die Schwerte der Seidenspinner kann man nun nur erweitern, wenn sie nicht
gezueckt sind. Ist leider noetig, da es sonst zu komischen Effekten kommt,
wenn man sie waehrend des Tragens erweitert, beim naechsten Mal aber wegen
mangelndem Geschicks nicht mehr zuecken kann.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Spinnenschwert (Ark, 15. Okt 2006, 13:50:41):
~#! rn=Ark rt=1160912909 rg=d.anfaenger
~#! tid=1160912909
Gilt natuerlich nur fuer neue Schwerter, bin ja nicht grausam ;-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Re: Spinnenschwert (Kellybundy, 15. Okt 2006, 20:19:25):
~#! rn=Ark rt=1160913041 rg=d.anfaenger
~#! tid=1160912909
Apropos, muss das sein, dass die newbies da getaubt UND geblindet werden?

-----------------------------------------------------------------------------



Re^3: Spinnenschwert (Ark, 15. Okt 2006, 21:34:37):
~#! rn=Kellybundy rt=1160936365 rg=d.anfaenger
~#! tid=1160912909
Das ist kein Newbieproblem. Das betrifft alle. Es klingt jetzt sehr
tendenziell, aber wenn man sich die Umstaende vorstellt (was wahrscheinlich
nicht jeder kennt, aber drueber redet...), dann kann man sagen, dass man da
bewusst ein Risiko eingeht. Wenn ich sowas schreibe, dann meine ich, was da
steht.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Re: FP im Tutorial (Muadib, 16. Okt 2006, 08:12:21):
~#! rn=Orktoeter rt=1160769487 rg=d.anfaenger
~#! tid=1160769391
du hast mein volles mitleid

-----------------------------------------------------------------------------



Re^3: FP im Tutorial (Rikus, 16. Okt 2006, 08:58:09):
~#! rn=Mesirii rt=1160772145 rg=d.anfaenger
~#! tid=1160769391
ich und schuldig? Neenee, das liegt eher an den relativ haeufigen Dienstreisen
die letzten Tage/Wochen :)

Rikus

-----------------------------------------------------------------------------



Test the Quest (Ark,  1. Nov 2006, 13:04:16):
Hi,

ich suche DICH, leidensfaehiger Tester fuer eine neue Quest. Du brauchst nicht
viel mitzubringen, nur einen kleinen Testie mit marginaler Ausruestung (wird
gerne gestellt) und (wichtig!) der Bereitschaft, fleissig mein Repfile zu
fuellen ... mit wichtigen Verbesserungen zum Wohle der Allgemeinheit.
Sprecht mich gerne an, ich brauche noch eine/n.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^3: Heiler fuer Anfaenger? (Key, 16. Nov 2006, 03:01:24):
~#! rn=Kessa rt=1159221352 rg=d.anfaenger
~#! tid=1159219181
-kl Hat grade jemand Zeit fuer mich? :)

Im Mud sollte kommuniziert werden und selbst ich habe schonmal auf die Hilfe
eines Klerikers zurueckgreifen muessen *seine Fackel taetschel* :)


Cu

-----------------------------------------------------------------------------



Re^4: Heiler fuer Anfaenger? (Kessa, 16. Nov 2006, 10:50:21):
~#! rn=Key rt=1163642484 rg=d.anfaenger
~#! tid=1159219181
Und ich hab selber nen Kleriker und kommuniziere ziemlich viel :) Darum ging
es uns nicht, sondern um ne Schonfrist fuer Anfaenger und Cicerone, in der man
grad das Allerwichtigste ohne solche Aktionen erklaeren kann. Aber das steht
ja schon alles da. Ich kann bloss die Klappe nicht halten. :)

-----------------------------------------------------------------------------



Re^5: Heiler fuer Anfaenger? (Ark, 16. Nov 2006, 11:20:59):
~#! rn=Kessa rt=1163670621 rg=d.anfaenger
~#! tid=1159219181
Ich kann auch meine Klappe nicht halten :-)
Im Wonnewichtwald ist auch deshalb eine nur fuer Anfaenger (<Stufe6) nutzbare
Heilstelle eingebaut ... die erklaert sich aber nach Entdeckung selbst.
Mam muff fie nur finden, daf ift aber imho nift fo fwer.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^6: Heiler fuer Anfaenger? (Kessa, 16. Nov 2006, 15:12:02):
~#! rn=Ark rt=1163672459 rg=d.anfaenger
~#! tid=1159219181
Cool. Iff muff wohl mal wieder forfen gehn.

-----------------------------------------------------------------------------



Wonnewichte in Not! (Ark,  3. Dez 2006, 20:09:22):


Aufzeichnungen des Volkes der Furien

Annum Nocturnum MXXIV, Smaragdmonat

Die Harpyien, unsere Erzfeinde, schicken schwarze Falken als Spione.
Wir schossen sie alle vom Himmel, doch unsere Windschwestern lassen
nicht locker. Ich schickte die Blitze Demengars in ihre Mitte, aber
ich bin nicht sicher, ob sie das lange beeindrucken wird.
Meine Feldherrin Siltara, sie diktiert unsere kargen Reihen sehr
effizient und mit grosser Disziplin.

Heute wagten sich die Harpyien aus dem Forst des Wyrmdhals heraus,
um einen grossen Angriff zu starten. Wir konnten sie gerade wieder
in den Wald zurueckschlagen.
Als ich durch die Reihen unserer toten und sterbenden Schwestern
schritt, fiel mir ein kleines Haeufchen auf, das sich am Boden vor
mir ruehrte. Ein Wimmern war zu hoeren, doch es gehoerte nicht zu
einer unserer tapferen Furien, sondern zu einer ... man stelle sich
dies nur vor ... kleinen halbwuechsigen Harpyie, von ihren grausamen
Schwestern in den Kriegsdienst gepresst und dann auf dem Schlachtfeld
verlassen.
Demengar bat mich, sie zu verschonen, und so befahl ich, dass man sie
in die Stoehnenden Hoehlen brachte.

Annum Lux MXXVI, Saphirmonat

Eine Vision des Inquisitors Demengar wies mich an, mehr Geduld mit
der kleinen Harpyie zu haben. Sie ist manchmal unbeherrschbar, wild
wie eine der unseren, aber voellig ohne Disziplin. Sie hoert auf
keinen Namen, viele gab ich ihr schon ... Viola, Marissa, Inajira,
doch sie ignoriert mich, ebenso trotzt sie Siltara ... und das will
einiges heissen.

Annum Lux MXXVI, Rubinmonat

Ob sich der wandernde Moench irrte ? Ich habe grosses Vertrauen in
Demengar und seine Macht, doch nun stehe ich an einem Scheideweg.
Die kleine Furie ... Harpyie, sie bringt mich noch zur Verzweiflung.
Was haben ihre Ziehschwestern ihr nur angetan, dass sie eine derart
ungehorsame Art an den Tag legt ? Ich werde im naechsten Monat den
Ritus des Blutes an ihr vollziehen, dann werden wir sehen, ob sie
einen Platz unter mir einnehmen kann.

Annum Lux MXXVI, Opalmonat

Es ist vollbracht. Die kleine Maid wird von allen Furien als eine
der ihren angesehen. Sie hat sich hervorragend gehalten, ungeruehrt
hat sie die gluehende Klinge betrachtet, die ihr Herz herausschnitt,
um es dem Inquisitor zur Begutachtung zu ueberreichen. Der gehoernte
Mond einer klaren Sternennacht war mein Zeuge, er sah sie tapfer dem
suessen Schmerz entgegensehen.
Als ich ihr den Lebensborn wieder einsetzte, ueberkam mich eine
wahrlich reine Freude, sie endlich auf unserer Seite zu wissen.

Annum Nocturnum MXXVII, Diamantmonat

Unglaublich ... Vanessa berichtete mir, dass Blutbote einen Wicht
in den Stoehnenden Hoehlen aufgegriffen hat, einen sogenannten
Wonnewicht. Der Name truegt, mich duenkt, der kleine Wirrkopf ist
auf der Suche nach Informationen ueber das Volk der Furien. Es mag
auch sein, dass die Harpyien mit den kleinen Schnuefflern unter
einer Decke stecken, sie unterjocht und zu ihrem Vorteil eingesetzt
haben. Das bedeutet Krieg !
Wir haben den Wicht weggesperrt ... irgendwann wird er reden.

Aylinia, Hexenmeisterin des Zorns



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Nachtrag (Ark,  3. Dez 2006, 20:09:52):
Noch ein paar Kommentare/Hinweise:

In der Quest muss gekaempft werden, und es gibt mindestens einen Punkt,
an dem der eine oder andere Hilfe benoetigen wird. Es wird darauf meist
hingewiesen, dennoch sage ich das nochmal, bevor jeder denkt "das muss
auch alleine gehen, sonst bugt es bestimmt".

Neben der Hauptquest gibt es auch noch 6 Miniquests samt einer Gildenquest
und einer Portalminiquest. So sollte immerhin noch viel zu tun sein,
"wenn's mal wieder laenger dauert" :-)

Am Anfang kann es vielleicht an der einen oder anderen Stelle laenger
dauern, wenn viele gleichzeitig questen und kaempfen. Keine Panik, das
entzerrt sich mit der Zeit, deshalb siehe auch den Hinweise auf andere
Betaetigungsmoeglichkeiten.

So, jetzt wuensche ich viel Spass.



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Beinahe vergessen: (Ark,  3. Dez 2006, 23:22:23):
Danke an die Tester Testknarz, McDie, Pippi und Orktest.
Die Quest sollte rebootfest sein. Wehe, das geht schief :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Nachtrag (Ark,  7. Dez 2006, 20:01:35):
~#! rn=Ark rt=1165172992 rg=d.anfaenger
~#! tid=1165172992
Ich hab mich verzaehlt, es sind insgesamt doch 7 Miniquests.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Und als ob es nicht schon genug waere ... (Ark, 18. Dez 2006, 00:34:39):
McDee wirbelt herein.
Miraka sagt: Wieder nur einen ertrunkenen ... ich hasse es.
McDee nickt.
McDee sagt: Ich glaube, da muesste es was dagegen geben.
Miraka lacht laut auf.
McDee sagt: Ich habe da etwas gefunden, die Knochen koennen uns den Weg
McDee sagt: zeigen. Vielleicht bisher uebersehen?
Miraka gruebelt.
Miraka sagt: Und wohin fuehrt uns das?
McDee zuckt mit den Schultern.
McDee sagt: Keine Ahnung, gerade entdeckt. Mal hin, ansehen?
Miraka nickt.
Miraka sagt: Wie ich ihn kenne, gibt es da wieder irgendeine miese kleine
Miraka sagt: Aufgabe. Aber das schaffen wir schon, ich kenne mich ja aus.
McDee wirbelt nach Suedosten.
Miraka macht einen gewaltigen Satz nach Suedosten.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Mehr mehr mehr ... alles und noch viel mehr ... (Ark, 26. Dez 2006, 18:50:57):
Wer sich fragt, warum nun mehr Punkte auf dem Konto sind ... einige NPC aus
den Stoehnenden Hoehlen und im Wyrmdhal sind nun mit einigen Extrapunkten
bedacht worden. Dank an Muadib.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Der Waechter der Nacht ... (Ark, 16. Jan 2007, 00:59:39):
... hat es sich in seiner Guete nicht nehmen lassen, auch mit den Knochen
seiner Generaele zu handeln. Freilich im bisher bekannten (fuer einen Gott
angemessen vorteilhaften) Verhaeltnis. Ein wahrlich teures Opfer!


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Der Waechter der Nacht ... (Kessa, 16. Jan 2007, 08:07:31):
~#! rn=Ark rt=1168905579 rg=d.anfaenger
~#! tid=1168905579
:intoniert ein erleichtertes Stossgebet.

-----------------------------------------------------------------------------



0->1 (Ark, 15. Mar 2007, 12:46:42):
Aus obigem Grund erscheint vielleicht jetzt ein NPC, der sich bisher deshalb
rar gemacht hat. Wo, verrate ich nicht, aber man wird ihm vielleicht in einer
groesseren Schlacht begegnen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Nichts Aufregendes ... (Ark, 18. Mar 2007, 20:22:15):
Neue Bewohner des Wyrmdhals sind gesichtet worden ... einige neue Items ...
keine neuen Miniquests ... vielleicht mal fuer die Zukunft interessant :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Am Tempel nichts Neues ... (Ark, 23. Apr 2007, 18:37:56):
In einem Anfall von guter Laune hat Hel die Zahlen vergroessert. Gross wurden
sie ... so gross, auf dass er sie alle sehen kann, seine klappernden Diener.
Doch zuernet er nicht, falls sich am Status Quo nichts aendert, nein, laecheln
wuerde der kopflose Moench, lautlos in sich hineinlachen.
Doch die, die seine Diener suchen, sie wuerden eines Besseren belehret.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



My bad, Sir! (Ark, 22. Jun 2007, 23:33:54):
Xutelius hat es geschafft ... ich fuehle mich doof :-)
Lange Rede, kurzer Sinn: beim Speichern der Generalsknochen klappt nicht alles
so wie gewollt. Einige Informationen habe ich nicht abgespeichert, so dass
sie, wenn ihr "ende" macht, oder gar der boese Crash/Reboot kommt, zwar noch
da sind, aber IDs verloren haben, die beim Verwenden aber notwendig sind.
Solltet ihr davon betroffen sein, so sagt mir Bescheid, falls es nicht klappen
sollte, ich richte das dann. Sorry fuer die Muehe und danke an Xutelius.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Das Haus des Nachtwaechters, Ebene1 (Ark,  8. Jul 2007, 14:00:52):

Mihail blickte den Boten ruhig an. Der Bruder der Bleichen Priesterschaft
kniete demuetig auf dem harten Felsboden, das Urteil des Fahlen Totenheilers
abwartend.
'Dies ist Nyus' letztes Wort, sagst Du ... ?'
Eilig richtete sich der Bleiche Priester auf:
'Herr, ein Affront gegenueber Eurem Einfluss, gewiss, dennoch empfahl mir
die Schlange mit der gespaltenen Zunge Euch auszurichten, dass er gewiss
kein neues Friedensangebot schicken wird.'
Mihail laechelte kalt. So oft schon hatte der Hohepriester der verhassten
Schuppengemeinschaft ein "letztes Angebot" geschickt. So oft schon verstrich
es ohne Folgen. Der Fahle Totenheiler war geneigt, es erneut zu ignorieren.
Bisher war er damit gut gefahren, der schuppige Priester lies als Zeichen
seines Unwillens jedesmal ein paar geringere Brueder aus der Priesterschaft
hinrichten, doch auf diese unbeholfenen, wehrlosen Geschoepfe konnte Mihail
sehr leicht verzichten.

Vielleicht war es an der Zeit, eine andere, kuehnere Taktik anzuwenden ...
Spaet abends, als er Hel seine abendlichen frommen Bitten darbrachte, da
klopfte es an der Tuer zu seinem bescheidenen Gemach.
Thorax stand vor der Tuer, vor Aufregung zitternd.
'Herr, verzeiht mein Eindringen, ich denke, ich habe es geschafft ... Ihr
muesst es Euch unverzueglich ansehen.'
Sein langjaehriger Gefaehrte atmete schnell und leicht, als haette etwas ihn
so befluegelt, dass er die duenne Luft weit ueber den Wolken atmen konnte.
'Mein Freund, beruhigt Euch, Ihr seid so ausser Atem, dass ich um Euch
fuerchten muesste, wuesste ich es nicht besser.'
Er laechelte ermutigend, so, wie er es immer tat, um eine kleine Glocke des
Vertrauens um sich und sein Gegenueber zu schaffen, aus der dieser genug
Zuversicht schoepfen konnten, um offen mit ihm zu reden.

Waehrend der Schlagende Herzmeister vor ihm durch die dunkleren Gaenge des
Knochentempels schritt, hoerte er interessiert den Ausfuehrungen von Thorax
zu. Offenbar hatte dieser endlich das gefunden, was Mihail ihm schon seit
Wochen aufgetragen hatte: den Geist, der als Herzzeitloser bekannt war, in
den schattigen Gefilden Hels aufzuspueren und ihn auf diese Ebene zu holen.
Gewiss wuerde er ueber genuegend Energie und Wissen verfuegen, um einen der
maechtigsten Verbuendeten zu beschwoeren, die Hel dienten.
Lange schon wartete Mihail darauf, dieses Geheimnis um diese Kreatur zu
lueften, doch stets war es ihm entglitten. Der Fahle Totenheiler hatte es
stets Zhettharo, seinem WORT, zugeschoben. Insgeheim vermutete Mihail, dass
das WORT ihn sabotierte. Ob Zhettharo seinen Platz einnehmen wollte, ob er
wartete, bis die Beschwoerung scheiterte ?

Nur langsam drang das unablaessige Geschwaetz von Thorax wieder in sein
Bewusstsein. Er riss sich zusammen und bemuehte sich um einen aufmerksamen
Eindruck.
'... war mir zuerst nicht bewusst, doch mein roter Mystiker brachte mich
auf die Idee, den Rhythmus des Sprechens zu beschleunigen, so dass es sich
mit der doppelten Herzfrequenz aeusserst fremdartig anhoerte. Nach einer
Weile erst stellte sich der erhoffte Erfolg ein, wir bemerkten, dass sich
das Zimmer verdunkelte, es wurde vollkommen still, und die Zeit schien
ebenfalls fast anzuhalten. Dann schloss sich der Zeitriss - um nichts
anderes handelte es sich naemlich - wieder, und wir sahen wieder klarer.
Der Herzzeitlose formte sich vor uns, wurde eins mit unseren Herzen,
durch deren Rhythmus er ploetzlich lebte.'
Sie waren an der Tuer zum Corum Arcanum angelangt, der Gebetsstaette vom
Schlagenden Herzmeister. Dieser legte seine verbrannte Hand auf die Klinke
der Tuer, oeffnete sie sachte und bedeutete seinem Herrn, ihm zu folgen.

Zunaechst sah Mihail ueberhaupt nichts ... der Raum war vollkommen in ein
waberndes Rot getaucht. Doch aus diesem pochenden Nebel, dessen Rhythmus
im Einklang mit seinem eigenen Herzschlagen war, formte sich allmaehlich
ein Gesicht, dann ein kompletter Koerper. Der Herzzeitlose war haesslich,
man konnte ihn nicht anders beschreiben. Die Tatsache, dass er friedlich
um sich blickte, war wohl nur dem Beschwoerungskreis des roten Mystikers
zu verdanken, der neben jenem kniete und unverstaendliches Zeug brabbelte.

Mihail nahm Kontakt zum Geist auf ... es bereitete ihm keine Muehe, denn
der Herzzeitlose hatte ihn wohl schon erwartet, wusste von seinem Kommen.
'Endlich erfuellt sich mein Schicksal ... was verlangt Ihr von mir, dem
getreuen Diener des Nachtwaechters ?'
Die Stimme klang trocken, fast raspelnd in seinem Kopf. Laechelnd wendete
er sich der roten Gestalt zu und antwortete in der Art der Diener Hels.
'Bring mir Wissen, bring mir Macht, bring mir Weisheit des Waechters der
Nacht. Herzzeitloser, die Bleiche Priesterschaft heisst Euch willkommen.
Lange wurde Euer Kommen vorhergesagt. Die Schuppengemeinschaft fuerchtete
den Tag Eurer Erscheinung, sie soll Grund genug dazu haben.'
Langsam drehte Mihail sich zu Thorax um. Als er das Nicken wahrnahm, da
wusste er, dass es nun kein Zurueck mehr gab.
'Herzzeitloser, der Fahle Totenheiler begehrt die Unterstuetzung von
Nesserpatus. Eure Faehigkeiten sollen es sein, die den Schwarzen Kaiser
der Schatten auf diese Welt holen muessen. Er kann gegen unseren Gegner
einen vernichtenden Schlag fuehren.'

Stille kehrte ein. Der Geist verharrte regungslos im Rhythmus wabernden
Rots. Schliesslich, als die Zeit anzuhalten drohte, hoerte Mihail wieder
die Stimme in seinem Kopf.
'Ihr seid sicher machtvoll genug, um gegen Hohepriester Nyus zu bestehen.'
Der oberste Hirte der Bleichen Priesterschaft laechelte, diesmal war es
ein zynisches Laecheln, welches dennoch von vielen seiner Subjekte sehr
gefuerchtet wurde.
'Nicht Nyus' Kopf will ich ... sondern den von Wyrmmutter Nyshiina.'

Ein kurzes Zischen erklang neben ihm. Thorax sog hoerbar die Luft ein.
"Armer Tropf", dachte Mihail. Ein Visionaer wuerde niemals mehr aus dem
Schlagenden Herzmeister werden, doch er hatte andere Vorzuege, auf die
Mihail nicht verzichten mochte.
Nach einer Weile ruehrte sich der Geist wieder. Kurz bevor er im rot
wallenden Pulsieren des Gemachs zu verschwinden drohte, hoerte Mihail
noch ein Wispern in seinem Kopf: 'Es sei ...'



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Anmerkungen (Ark,  8. Jul 2007, 14:01:11):

So, nach einem guten halben Jahr ist jetzt der erste Teil geschafft.

Vielen Dank geht zunaechst an die braven Tester:
"Kessa, die mit dem Bug tanzt"
"McDie, schiefgegangen vieles gewiss war"
Ennox und Amynthor, sowie Gabylon

Sechs Miniquests und eine Kaempfergildenquest sind dabei herausgekommen,
meine bescheidene Einschaetzung ist, PG5+, also ab Spielerstufe 5 recht
gut machbar ... so man liest und alles beherzigt :-)

Sollten sich irgendwann viiieeel spaeter einige NPC nicht mehr ganz so
verhalten wie zuvor, gar aggressiv sind, dann koennte es daran liegen,
dass man ihrer Gruppierung Unrecht angetan hat. Dies liegt nicht in der
Gesinnung begruendet, Besuchen des Duesterwalds oder Laeuterung werden
auch nichts daran aendern. Vielmehr sollte man sich solcher Taten berufen
koennen, die die eine oder die andere Gruppierung milder stimmen.
Das bedeutet nicht unbedingt, dass man jedweden niedermetzeln muss :-)

Das Gefasel von eben klingt martialisch und schlimm, befindet sich aber
eher in den tieferen Ebenen.

Viel Spass.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Anmerkungen (Ark,  8. Jul 2007, 23:37:30):
~#! rn=Ark rt=1183896071 rg=d.anfaenger
~#! tid=1183896071
Ok, nach ein paar Nachfragen noch diese Info: das, um was es geht, liegt im
Questgebiet von "Furienkrieg" ... etwas Forschen dorthin wird sich nicht
umgehen lassen, wenn man die Quest nicht gemacht hat :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Zeugs... (Deidre, 13. Jul 2007, 23:44:38):
Da sich die Kneipe von Umjak mittlerweile zu einem recht beliebten Treffpunkt
von ueberwiegend aktiven Sehern entwickelt hat, faellt dort jede Menge
eingesammelter Kram an, der in Paketen auf Interessenten wartet.

Wer also moechte, kann gerne mal vorbeischauen, ob fuer ihn/sie etwas
Interessantes zur Benutzung dabei ist. Zum Verkauf beim Haendler sind die
Sachen allerdings nicht gedacht;-)

In diesem Sinne
Deidre (den Ueberblick verlierend)

-----------------------------------------------------------------------------



Sternenregen (Ark, 10. Aug 2007, 01:27:10):

Neugierig stiess das gefaecherte Haupt der allmaechtigen Wyrmmutter herab:
'Und Du bissst sssicherrr, dasss Zzzymhirrrod wiederrrgekehrrrt issst ?'
Ohne aufzublicken, voellig ruhig und verzueckt, nickte ihr Hohepriester.
Lange hatte Nyus dem Lieblingskind Nyshiinas nachgespuert, bemuehte die
Auguren der Schuppengemeinschaft, die Wahrsager, die blinden Priester,
beschwor Geister seiner Ahnen, sprach mit den Toten und den Ungeborenen,
ging unheilige Buendnisse ein und kontaktierte sogar einen verhassten
Seelenpriester Hels.
Schliesslich fand er Spuren des maechtigen Sternenwyrms ... und verfolgte
diese hartnaeckig ueber Jahrzehnte hinweg. Erfreut schaute er auf und
begegnete den schwarzen Seen, den grossen, unergruendlichen Augen seiner
Wyrmmutter:
'Verehrte Nyshiina, es ist, wie ihr sagtet, Zymhirod kehrte von einer sehr
langen Reise endlich zurueck. Die Gelehrten prophezeiten, dass er die
Sterne mitbringen wuerde ... und so ist es wahrhaftig.'
Nun erhob sich der Hohepriester. Was er noch zu berichten hatte, wuerde
Nyshiina nicht gefallen, das wusste er.
'Grosse Mutter, wir sind aber auch Zeuge einer weiteren Verwandlung
geworden. Zymhirod Sternenwyrm dient nun einem Feind, dem dunklen Gott
Senguran.'
Zischend fuhr der maechtige Kopf der Wyrmmutter zurueck.
'Derrr Hassssssende ... dasss issst furrrchtbarrr. Nyusss, werrrterr
Sssohn, bissst Du Dirrr sssicherrr ?'
Erneut kniete der Hohepriester der Schuppengemeinschaft nieder.
'Leider ja, es ist unzweifelhaft so. Was befiehlt uns unsere Wyrmmutter ?
Unser gefallene Sohn haelt sich bereits im Wyrmdhal auf, doch da er die
Ebenenwanderung beherrscht, koennt Ihr ihn noch nicht sehen. Hat er den
ehrenhaften Tod der Wyrmer verdient ?'
Eine lange Pause trat ein ... schliesslich schlossen sich die Augen der
Wyrmmutter Nyshiina, nur ein schwaches Rumpeln verliess noch den Koerper
des riesigen Wyrms aller Wyrmer:
'Nein, lasssssst ihn leben. Ich hoffe noch, dassssss errr wiederrr zzzu
unsss zzzurrrueckkehrrrt. Und nun verlasssssst mich wiederrr, ich huelle
mich in Trrrauerrr.'


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Sternenregen (Ark, 14. Aug 2007, 11:30:17):
~#! rn=Ark rt=1186702030 rg=d.anfaenger
~#! tid=1186702030
Dank Rikus gibt's dafuer nun auch fett Stupsregen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Knochen ... mal wieder, diesmal in Truhen (Ark, 24. Sep 2007, 14:44:46):
Da gibt es noch eine kleine Altlast bei den Autoload Knochen. Sollten die in
der magischen Holztruhe liegen und aelter als Mitte 2007 sein, koennte es
sein, dass sie sich mit einem Firzg nicht mehr rausnehmen lassen. Das habe ich
behoben ... mit dem Resultat, dass der Knochen sich selbst zerstoert. Boeser
Ark? Nicht doch, ich ersetze ihn gerne, diesmal dann komplett konfiguriert.
Wer mehr als einen reklamiert, bei dem kann was nicht stimmen, denn die Truhe
akzeptiert immer nur einen, also kommt nicht auf dumme Gedanken :-)
Ich hoffe, danach ist das Thema dann durch ... und Arki hat was dazugelernt
:-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Knochen ... mal wieder, diesmal in Truhen (Ark, 24. Sep 2007, 22:23:45):
~#! rn=Ark rt=1190637886 rg=d.anfaenger
~#! tid=1190637886
Wie der letzte Reboot zeigte, hab ich dumm geschwaetzt. Aus ... ah ...
technischen Gruenden, auf die ich hier nicht naeher eingehe, ist es zunaechst
so, dass gewisse Knochen nicht in beliebiger Menge einen Crash/Reboot
ueberstehen. Gleiches trifft fuer Sternenscherben zu. An einer endgueltigen
Loesung wird gearbeitet, wie die aussieht, darueber wird an gleicher Stelle
noch berichtet. Bis dahin gilt: ein(e) Knochen/Scherbe im Inventar und eine(r)
in der magischen Holztruhe (so vorhanden) ueberlebt eine derartige
Katastrophe. Da wir aber hoffentlich einer langen Uptime entgegenblicken, wird
dies vielleicht nicht so wild sein.
Wer das nicht versteht, was ich hier braebel, der erleidet auch keinen slimmen
slimmen Nachteil :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Knochen und Scherben ... (Ark, 15. Okt 2007, 00:07:55):
... sind manchmal aergerlicher als gedacht. Bisher war es entgegen
grossspuriger Ankuendigungen eines nicht naeher genannt werden wollenden
Magiers nicht so, dass diese Objekte allesamt einen Reboot ueberstehen
konnten. Nur ein Objekt dieser Art konnte dies tun. Das gleiche gilt fuer die
mittlerweile existierende Autoloadertruhe.
Obiger Magier aber gruebelte und dachte nach und dachte nach und gruebelte. Er
besprach sich mit einem anderen Kollegen, dem weisen Oberpriester M'Sharr von
der Schuppengemeinschaft. Als er ein geeignetes Sammelobjekt ersonnen hatte,
gab er es dem Oberpriester, auf dass er tapfere Abenteurer belohne.
Und so geschah es. Recken, die bereits dem Priester geholfen haben, koennen
ihn einfach nach der Belohnung fragen, um sie zu erhalten.
Vielleicht reagieren die bestehenden Knochen und Scherben noch ein wenig
seltsam mit dem Objekt, wenn man sie das erste Mal hineinsteckt, aber das gibt
sich dann :-)

Hiermit hat das staendige Clonen von abhanden gekommende Items auch ein Ende
fuer den armen, geplagten Magier. Nicht existierende Bugs natuerlich
ausgenommen *hust*


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Miniquesttagebuch (Ark, 16. Nov 2007, 15:23:29):
Hi, ich will die im Umlauf befindlichen Buecher nicht einfach destructen wegen
eines kleinen Fehlers. "lies" ohne Argument bugt. Der Bug ist behoben, wer ein
neues Buch will, sollte das alte entsorgen (mach ich auf Anfrage gern) und
sich ein neues holen. Die Eintraege bleiben erhalten.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Schatulle ... alle Jahre wieder (Ark,  6. Jan 2008, 12:53:40):
Und weil der Magier nicht mit Mappings umgehen kann und schusselig ist, sollte
man alle Scherben und Knochen aus der Schatulle nehmen, diese entsorgen und
sich eine neue besorgen. Inhalte werden nicht ersetzt nach dieser
Ankuendigung. Dieser Bug betrifft nur einige wenige Scherben (wenn ueberhaupt)
in gewissen Konstellationen.
Mea culpa. Creo Hirn.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Testspieler gesucht (Ark, 13. Mar 2008, 15:01:17):
Ich suche fuer demnaechst 1-2 Tester, die ein kleines Gebietchen testen
sollen. Kenntnis der ersten Knochentempelebene vorteilhaft, aber keine
Bedingung. Voraussetzung: Zeit, Geduld *hust*, Fleiss (der Mist muss
natuerlich verstaendlich abgesetzt werden :-) ). Belohnung: Einzeiler mit
Erwaehnung des Namens in einer Ankuendigungsmail.
Interessenten per Mail an mich ... bitte Verstaendnis, wenn ich erstmal nicht
alle beruecksichtigen kann (falls ueberhaupt so viele da sind :) ), aber mit
serieller Abarbeitung des Repfiles komme ich gerade so zurecht :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Tiefer in den Tempel hinein ... (Ark, 16. Jul 2008, 15:23:02):
~#! rn=Ark rt=1216214572 rg=d.anfaenger
~#! tid=1216214572
Die Ewigen Schatten und die Zucht der Wyrmer sind nunmehr zugaenglich,
4 kleine Aufgaben warten auf euch. Falls das Tagebuch des Knochentempels
die Aufgaben nicht anzeigen will, einfach vernichten und neues holen.
Kann sein, dass die Killstupse dort unten sich erst ein wenig spaeter
punktetechnisch bemerkbar machen.

Viel Spass.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Re: Tiefer in den Tempel hinein ... (Ark, 16. Jul 2008, 16:38:35):
~#! rn=Ark rt=1216214582 rg=d.anfaenger
~#! tid=1216214572
Eh ich es vergesse, riesiges Dankeschoen an Del und Cutter fuers Testen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Tiefer in den Tempel hinein ... (Ark, 16. Jul 2008, 19:31:51):
Der Schaedel der verkrueppelten Seele hob sich hoffnungsfroh, als das
vertraute Droehnen erklang. Wie immer schwang das maechtige Gitter zur
Seite und liess den Blick des Schmieds in die Dunkelheit der Schatten
schweifen. Durchdringen konnte er sie nicht, doch da war etwas, was ihm
Unbehagen bereitete. Waere er nicht laengst tot, er wuerde vor Angst
davonlaufen ... doch dies war in seiner unendlichen Zelle nicht ratsam.
Auf einmal wurde es eisig kalt im Raum, kaelter, als es die Einsamkeit
der Schatten je sein konnte, deutlich spuerte er den Frost, der durch
seine Knochen kroch, er schnuerte seinen vertrockneten Hals vollends zu.
Eine Wesenheit schwebte naeher, etwas Boeses, Pulsierendes, das die Zeit
stillstehen liess. Blutrot waberte der Geist auf ihn zu, eine unscharfe
Huelle mit einer unheimlichen plastischen Fratze, an der die triefenden
Faenge das wohl abstossenste Merkmal des Lebens darstellten.
Nachtschwarze Augen musterten den Zwergenschmied:
'Willst Du immer noch nicht reden, Welpe ?'
Schaudernd betrachtete Xhuluk seine zitternden Knochenhaende. Es war
nicht leicht, die Kraft aufzubringen, dem Geist zu antworten, denn so
gross war dessen Macht, dass er Blut und Zeit zum Stillstand bringen
konnte. Ihm folgte eine seelenlose Huelle, zweifellos die unglueckliche
Seele, die er an zahllosen Tagen verhoert und gequaelt hatte, bis aus
dem Koerper ein inhaltsloses Gefaess wurde.
'Schau nur gut hin, mein Gebieter ist weit weniger geduldig als ich.
Ich fordere Dich zum letzten Mal auf, mir den Hammer zu geben. Wisse,
dass ich nicht zweimal fragen werde.'
Drohend weiteten sich die Augen des vampirischen Geists, der allseits
als der "Herzzeitlose" von den Priestern Hels gefuerchtet wurde.
Xhuluk Splitterschild wusste, dass er verloren hatte. Auch die letzte
Hoffnung wurde ihm nun genommen. Anfangs versuchte es Mihail mit
Nachsicht und geheuchelter Freundschaft. Xhuluk durchschaute das jedoch
sofort. Es folgten Drohungen, Erpressung und Folter. Xhuluk duldete
es mit der stoischen Ruhe, die ihn bereits durch so manche Pruefung
des Fahlen Totenheilers gefuehrt hatte. Eines Tages wuerde er Rache
nehmen ... eines Tages ...
Doch der Tag ... der Tag der Abrechnung, den er so oft in seiner
einsamen Phantasie durchlebt hatte, er entzog sich dem Zwerg, immer
weiter verschwand er aus der Vorstellungskraft, bis sein Licht im
trueber werdenden Verstand des Schmieds erlosch. Das letzte Privileg,
seine Schmiede, die der oberste Diener Hels hier im Knochentempel
fuer ihn errichten liess, sie wurde ihm genommen, weil seine Weigerung,
den Seelenpriestern zu dienen, Mihail zu immer grausameren Strafen
reizte.
Und so kam es, dass er nur noch den Herzzeitlosen zu ihm schickte,
wohl wissend, wie seine Seele nach dem koerperlichen Leben auf die
abscheuliche Groteske reagieren wuerde. Das pulsierende Blut, welches
durch die wabernde Huelle schoss, erinnerte ihn an seinen Herzschlag,
als sein Koerper mehr war als das Gebilde aus Knochen und Hautfetzen,
die seine Seele nun beherbergten.
Xhuluk griff an seinen Hals ... unter der faltigen Haut fuehlte er
die duenne Kette, die ein mitleidiger Magier einst unter ihr verbarg.
Mit einem Ruck riss er sich den Hals auf und brachte den Anhaenger zum
Vorschein, nach dem der Herzzeitlose trachtete.
'Hier ist er ... und nun lasst Lennai ihre Reise antreten.'
Der Koerper des Zwergs zuckte unkontrolliert, als die geisterhafte
Hand des Herzzeitlosen gierig nach der Kette griffen. Stumm hielt der
Schmied dem Schmerz stand, jeder Widerstand wurden vom Geist grausam
bestraft.
Ein kurzes Flimmern umgab den Geist, Xhuluk fuehlte, wie seine Glieder
taub wurden ... immer schwerer konnte er sie bewegen, bis die Zeit
stillzustehen schien und sein Herz aufhoerte zu schlagen.
Der Herzzeitlose murmelte unverstaendliche Worte ... hinter ihm sah
Xhuluk ploetzlich die Schatten zweier Seelenpriester wie aus dem
Nichts auftauchen. Der Geist uebergab beiden die Kette, an deren Ende
sein Hammer hing. Mit einigen Gesten entfernte einer der Priester die
Verzauberung, die auf der Kette lastete ... und hielt ploetzlich
seinen Schmiedehammer in der knochigen Hand.
Als die Priester in den Ewigen Schatten verschwanden, zog sich auch
der unheimliche Geist langsam aus seinem Gefaengnis zurueck.
'Meine Belohnung ...', murmelte Xhuluk muehsam, als sich seine Glieder
langsam wieder bewegen liessen.
Ein letztes Mal drehte sich der Herzzeitlose um, erfasste die Seele
des Schmieds mit unbarmherzigem Strahlen seiner roten Augen.
'Du wagst es ? Harre aus, und Du wirst belohnt. Sei geduldig, und die
Gnade ist Dein. Verhalte Dich gefuegig, und Dir wird nichts geschehen.'
Mit diesen Worten verschwand die Kaelte aus dem endlosen Gefaengnis,
und die Einsamkeit kehrte wieder ein.
Lennai, die arme Seele, die versucht hatte, ihn zu befreien, wurde von
den Priestern auf ihre letzte Reise geschickt. Sie verschwand in der
Transzendenten Passage, so wie es der Zwerg erhofft hatte.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Zymhirod ist wieder da ... (Ark, 20. Jul 2008, 09:47:37):
Mehr gibt es nicht zu sagen ... hoffentlich bleibt er da, der Schlingel.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Die Schatten ... (Ark, 21. Jul 2008, 21:06:22):
... sind von der Ebene der Kaefer auf ihre Heimatdimension zurueckgekehrt, sie
sind nun gnadenloser gegenueber ruecksichtslosen und schutzlosen
Stoerenfrieden.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Schatulle (Ark, 24. Jul 2008, 17:50:25):
An dieser Stelle sei nochmals erwaehnt, dass gewisse Knochen und
Sternenstuecke nur in der Schatulle ihre Eigenschaften ueber einen
Crash/Reboot behalten. Das Unterbringen in der Autoloadertruhe ist aus
technischen Gruenden nicht sinnvoll ... auf Deutsch: gehd gabudd, dumm
gelaufen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Schatulle (Ark, 24. Jul 2008, 17:55:52):
~#! rn=Ark rt=1216914625 rg=d.anfaenger
~#! tid=1216914625
Selbiges gilt naturellement fuer die Inkompatibilitaet von Schatulle und
Autoloadertruhe :-) Do not insert.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Testspieler gesucht (Ark,  7. Jan 2009, 14:23:29):
Hi, ich suche noch einen Testspieler, der einen kleinen Gebietsabschnitt (9
Raeume) testen mag. MG Kenntnis sehr hilfreich. Wer mag und Zeit hat, bitte
bei mir melden.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Reisende Anfaenger ... (Ark, 25. Feb 2009, 14:07:37):
... (und andere) duerfen jetzt mit der Biene auch zu den Goblins reisen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Der Gottlose (Ark,  1. Mar 2009, 15:16:09):

Zu einer Zeit, da Grimmfang noch eine kleine Siedlung Elender war, als
sich das erste Heer der Schwarzen Legion Nuhmahs auf dem Ambossplateau
niederliess und die ersten Wyrmer im Talkessel der zukuenftigen Stadt
gesichtet wurden, da begab es sich, dass ein Diener der Armee der
Vernichtung bei Nuhmah, dem Heerfuehrer, in Ungnade fiel und verstossen
wurde. Lange zog der Vampyr umher, gejagt von Schergen des dunklen
Herrschers. Schliesslich erreichte er einen stillen Ort inmitten eines
Waeldchens unweit der kleinen Siedlung Grimmfang. Ein heiliger Mann
lagerte dort zur Nacht und lud den mueden Wanderer ein, mit ihm um das
Feuer zu sitzen und gemeinsam zu essen und zu beten. Dankbar nahm der
Vampyr an.
Doch aus Dankbarkeit wurde Verwirrung, und aus Verwirrung wurde Zorn,
denn der heilige Mann war ein Priester des kopflosen Moenchs, und er
versuchte unentwegt, die finstere Seele seines Gastes zu bekehren,
wollte sie zur Seelenreise ueberzeugen, damit sie sich reinige und
dem Waechter der Nacht zur trostreichen Suehne uebereignet werden
koenne. Dieses hartnaeckige Predigen und Belehren des Priesters missfiel
dem Vampyr sehr, schliesslich stritt er sich laut mit dem Diener Hels
und verletzte ihn so stark, dass dieser auf dem Boden der Lichtung sein
Leben aushauchte.
Der volle Mond schien auf den Leichnam des Knochensammlers, der Vampyr
kniete keuchend neben diesem. Und als erste Wolken den Himmelskoerper
zu verdecken drohten, als auch auf der Erde ein schattiger Mantel die
Tat des Dieners von Nuhmah zu verbergen drohte, da hoerte der Vampyr
seine Feinde im Wald. Noch immer geschwaecht, ueberfiel ihn Angst, ja,
Panik sogar. Obwohl die Diener Nuhmahs den Tod nicht fuerchteten, so
erwiesen sie ihren Gegnern doch Respekt und Ehre. Ausgestossene aber
wurden verfolgt und versklavt. Dies fuerchtete der Vampyr mehr als den
Tod durch seinen Herrn.
So rief er in seiner Not den Gott des Toten zu seinen Fuessen an, bat
um Vergebung und versprach Suehne und ewige Treue. Hel schenkte ihm
Beachtung und fuehrte ihn auf geheimen Pfaden weg von der Lichtung.
Kaum gerettet, wollte der Vampyr seine Versprechen vergessen, weigerte
sich gar, die Reise der Seelen anzutreten.
Dies veraergerte den Waechter der Nacht, und er schickte ein Avatar, um
die Versprechen des Geretteten einzufordern. Der Widerstand des Vampyrs
war schwach, doch dass er sich wehrte, erzuernte das Avatar Hels sehr.
In seiner Wut quaelte es den Koerper und die Seele des Vampyrs derart,
dass sie sich beide veraenderten. Sie wurden blutruenstiger ... und
schwaerzer. Danach wurde der Vampyr gefuegiger, doch sein Koerper ward
fuer immer veraendert. Durch die Seelenreise zerriss das Gefaess, das
den Geist formte. Und so ward aus dem einstigen Gefolgsmann Nuhmahs
ein schreckliches Geschoepf der Rache und der Qual. Hel aber diente
der Geist noch, ein Schatten seiner selbst, der nie vergisst und nicht
verzeiht.
Lange Zeit verstrich, in der der Geist im Schattenreich umherzog, ohne
Aufgabe und ohne Ziel. Dann, eines Tages, erforschte ein roter Mystiker
Hels alte Formeln der Anrufung und beschwor den vampirischen Schemen,
den man in den Geschichten als den 'Herzzeitlosen' beschrieb.
Von da an diente der Vampyr dem Fahlen Totenheiler Mihail, dieser aber
entliess den Geist auch nicht, als er seine Schuld getilgt hatte.
Und so sucht der Herzzeitlose noch immer den Knochentempel heim, er
schuetzt das Knochenallerheiligste und ist des Totenheilers treuester
Diener.



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Danke (Ark,  1. Mar 2009, 15:16:39):
Das Portal der Seelen hat sich geoeffnet, recht viele Aufgaben warten
in eher wenig Raeumen. Stufe wuerde ich mal annehmen 20+, sehr forsch-
und raetsel, weniger metzellastig (mit einer letzten Ausnahme, fuer
die dann auch nicht mehr Stufe 20+, sondern Seher gilt :-)).
Fuer die Aufnahme ins Tagebuch empfehle ich, das alte zu entsorgen und
sich ein neues Buch zu besorgen.

Dank an Cutter und Knarz fuer unermuedliches Testen.

Wuensche viel Spass.



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Am Abgrund ... (Ark, 21. Feb 2010, 14:36:15):

Zitternd blickte die junge Furie ins Tal hinaus. Wann wuerde er nur
wiederkommen ? Kalte Schneeflocken fielen vom Himmel herab und kuessten
schmerzhaft ihre nackte Haut. Mit klappernden Zaehnen beobachtete
sie den wolkenverhangenen, unheildraeuenden Himmel, in dem das fahle
Auge des vollen Mondes ab und zu mitleidig auf die frostige Erde schaute.
Ihre Freundinnen hatten sich schon lange in die Hoehlen der Furien
zurueckgezogen, weil sie die Kaelte nicht vertrugen. Sie aber wollte ihn
unbedingt wiedersehen, den gewaltigen Wyrm, der Nacht fuer Nacht ueber
dem weissen Wald des Tals kreiste, bevor er nach wenigen Stunden jedesmal
am Himmel verschwand.
'Es ist keine boese Kreatur', so dachte die Furie, 'er fliegt, ist nicht
 so wie die anderen Wyrmer, die Kriechechsen.'
Vor den Wyrmern im Wald hatten die Furien grossen Respekt, ja, viele
fuerchteten die maechtigen Echsen sogar.

Ploetzlich verdunkelte sich der Himmel, der Mond verschwand wie hinter
einer riesigen Decke, das Geraeusch sich naehernder Schwingenschlaege
liess die Furie aufschrecken. Mit angstgeweiteten Augen blickte sie nach
oben, sah den maechtigen Schatten, der immer groesser wurde, weil die
Kreatur, zu der er gehoerte, immer naeher kam.
Unfaehig, sich zu ruehren, verharrte die Furie neben dem Eingang zur
Hoehle. Sie hoffte bibbernd und betend, nicht entdeckt zu werden und
schloss die Augen.
Mit einem Rumpeln der bebenden Erde unter ihr hoerten die fauchenden
Schlaege der ueberdimensionalen Schwingen auf, einzig der Geruch, der
sich neben ihr breitmachte, sagte der Furie, dass sich die Gefahr naeher
denn je befand. Ein Schnauben liess sie ein Augenlid heben ...

'Schau an, ein Erdenkind.'
Die droehnende, grummelnde Stimme des grossen Wyrms liess die Furie
zusammenzucken. Sie oeffnete langsam erst ein Auge ... dann beide.
Vor ihr stand - lag - der groesste und majestaetischste Wyrm, den sie
je gesehen hatte. Silberne Schuppen warfen ein fahles Mondlicht zurueck,
wo immer die Strahlen des Gestirns den Wyrm trafen, nahmen die Schuppen
das Licht in sich auf und gluehten schwach vor sich hin. Sobald sich
die gewaltige Echse bewegte, glitzerte die harte Wyrmhaut geheimnisvoll.
'Was hast Du denn hier draussen zu suchen ? Es ist kalt, Deine nackte
 Haut friert doch.'

Der Kopf des Wyrms schoss vor, die schwarz glaenzenden Augen beaeugten
sie aus unangenehmer Naehe.
'Ah, die edle Tochter der Oberin bist Du. Deine Freundinnen haben mir
 schon oefter nachgespuert. Jetzt stehst Du hier alleine, nicht wahr ?'
Amuesiert schnaubte der Wyrm, ein hustendes Grollen hub er an ... war es
etwa ein Lachen ?
'Habe keine Angst vor mir, denn ich habe keinen Streit mit den Furien.
 Etwas anderes ist es, was ich jagen muss. Und dafuer muss ich durch der
 Furien Hoehlenkomplex, denn dort hat sich das Boese verkrochen.
 Wyrmmutter Selyianah hatte es gefunden und bekaempft, und Wyrmmutter
 Nyshiina erkannte erneut, dass es nicht ruhen wird. Ich werde dafuer
 sorgen, dass es sich wieder dorthin verkriecht, wo nur der Siechende
 herrscht.'

Mit diesen Worten robbte der maechtige Wyrm an der kleinen, zitternden
Furie vorbei in die Stoehnenden Hoehlen. Nach einer Weile wurde es wieder
still, nur noch der Wind war zu hoeren, der die immer leiser werdenden
Kratzgeraeusche des Wyrms uebertoente.
Schliesslich fasste sich die Furie ein Herz und lief dem Wyrm nach,
immer entlang des warmen Hoehlengangs in die Tiefe des Berges hinein.
Seine Spuren waren deutlich am Boden zu sehen, aber erstaunlicherweise
nicht an den Waenden. So gross, wie er war, haette er Probleme haben
muessen, durch den Gang zu kriechen, aber er war nicht mehr zu sehen.
Schliesslich fuehrten sie die Spuren an die dunkle Hoehle heran, die
sie - wie alle Furien - nicht betreten durfte. Bangen Blicks sah sie
sich um, die Hoehlen waren wie ausgestorben in der Nacht.
Was machte der Wyrm dort in der dunklen Hoehle nur ? Kein Laut entkam
der Finsternis vor ihr, aber er musste sich dorthin gewaelzt haben.
Schliesslich fasste sie einen heldenhaften Entschluss, den sie bis zum
heutigen Tage nicht verstand ... sie trat in die Finsternis der Hoehle.

Schlagartig pochte ihr Herz voller Angst ... trotz ihrer angeborenen
Launenhaftigkeit, die allen Furien eigen ist, erschrak sie doch im
Angesicht des Zorns, der ihr entgegenschlug. Schatten tanzten vor ihr
herum, kleine Schatten, grosse Schatten ... und ein gigantischer, vor
Schmerz zuckender Schatten mit riesigen Schwingen.
'Der Zackenwyrm', schoss es ihr durch den Kopf, 'der Wyrm, der mich
 kennt, er kaempft gegen ... was ?'
Hilflos stand sie herum, was sollte sie auch tun, wenn man nicht weiss,
wie man seinen eigenen Schatten bekaempfen soll.

Auf einmal stiess der Wyrm einen donnernden Schrei aus, als er mit der
Pranke etwas schlug, was fuer die kleine Furie nicht sichtbar war.
Die Schwingen des Wyrms entfalteten sich voll, wie wild begannen sie
zu schlagen, als wolle er fortfliegen, und dann ... war der Wyrm auf
einmal verschwunden. Es wurde still in der Hoehle. Die Schatten
beruhigten sich ploetzlich, es ward ein wenig heller, und ihre so
grosse Angst begann zu schwinden. Ganz hinten in der Hoehle, da wurde
sie einer seltsamen Schwelle gewahr, die in die Finsternis fuehrte.
Langsam ging sie darauf zu, bis sie vor einem gaehnenden Abgrund stand.
Ob sie einen Blick darauf riskieren sollte ?

Eine fluesternde Stimme riss sie wieder in die Realitaet zurueck:
'Da bist Du ja ... komm da raus, lass uns wieder verschwinden.'
Die Furie blickte zum Hoehleneingang ... da standen sie, ihre beiden
tapferen Freundinnen Siltara und Vanessa. Langsam trat sie vom Abgrund
zurueck, die Schwelle begann sofort, sich zusammenzuziehen, bis von
ihr fast nichts mehr zurueckblieb.
Versonnen starrte sie darauf:
'Ich glaube nicht, dass wir noch einmal hierher zurueckkommen sollten.'

Vanessa laechelte und blickte die bleiche Siltara an, die sie seltsam
anstarrte:
'Natuerlich nicht, die Mutter Oberin wuerde uns allen den Hintern
 versohlen, Dir besonders, das weisst Du. Und nun komm schon, Aylinia.'
Als die kleine Furienhexe die finstere Hoehle verliess, glaubte sie,
ein belustigtes Schnauben zu hoeren.



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Danke (Ark, 21. Feb 2010, 14:36:26):
Und damit ist Ebene 2 des Tempels vollstaendig.

Vier kleine/grosse Miniquests warten, zwei zum Forschen, eine zum Forschen
und Metzeln und eine vorwiegend zum Metzeln. Ab Level 20 wuerde ich sagen,
man muss schon einiges an Vorarbeit geleistet haben, um so weit vorzudringen.

Ich danke Leetah und Fettwurst fuer das Testen und wuensche viel Spass.

Um die neuen Quests niederzuschreiben, gilt wieder -> neues Buch holen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Danke (Ark, 21. Feb 2010, 15:04:23):
~#! rn=Ark rt=1266759386 rg=d.anfaenger
~#! tid=1266759386
Taten der Vergangenheit koennen einen einholen ... die beiden Fraktionen im
Tempel vergessen nichts. Falls man Probleme bei der einen oder anderen Stelle
bekommt, sollte man sich ggf. wieder etwas gefaelliger verhalten ... und sich
"auf die Seite" dessen schlagen, von dem man etwas will.
Gewalt hilft da haeufig, manchmal geht es auch ohne, aber meist nicht ohne
Schmerz :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Gesinnungen ... (Ark,  9. Mar 2010, 21:36:29):
Die beiden Fraktionen im Knochentempel sind sich ja nicht besonders gruen. Und
da das auch bei entsprechenden (Uebel-)Taten auch einmal sanktioniert wird,
kann man sich in der ersten Tempelebene einschaetzen lassen, wie schlimm es
denn um sich selbst bestellt ist. Ein hoher Geistlicher der
Schuppengemeinschaft und ein schwarzes Skelett geben hier (sehr grob nur!)
Auskunft.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Verflucht nochmal. (Ark,  4. Jun 2010, 16:25:12):
Die Flickerin schrie und jammerte, keifte und kratzte ... es half nichts, ihr
Fluchen wurde ein wenig schwaecher. Trotzdem kann es toedlich sein.
Die Untoten unter dem Wyrmdhal blieben stumm, doch auch sie konnten sich dem
Einfluss des Meisters nicht ganz entziehen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Daemonendaemmerung (Ark, 11. Okt 2010, 18:39:30):
Der schwarzberobte hagere Mann legte vorsichtig seine daemonisch anmutende
Maske auf den glaenzenden Obsidiantisch. Bedaechtig fuhr er mit angespitzten
Fingernaegeln ueber die Oberflaeche, das leise Kratzgeraeusch ignorierend,
immer auf die Kreise starrend, die er ganz genau mit seinen alten Haenden
beschrieb. Ruhig glitten die alten Augen ueber die Utensilien, die der Klerus
von Ch'ran Daemonicus seinen erfahrenen Priestern lehrte: da vermengten sich
die Kadaver von Sauwurzmaden mit dem Blut von Frostwuermern des Warok, es
trafen giftige rote Schwanzspitzen der Flammskorpione auf verfuehrerisch
glitzernde Pockenpilze aus Akhar Nth'tar, eintraechtig lagen Grimmenstein
und Warulfenbein nebeneinander in den Schalen aus stinkendem Schwefelpech.
All dies war noetig, um den groessten Daemon zu beschwoeren, der dem Kleriker
des Blutes der Unterwelt das bringen konnte, was ihm bis dahin verwehrt blieb:
das Blut der Brut.
Leise summend richtete der Priester von Ch'ran Daemonicus die Opfergaben so,
wie es dem daemonischen Sklaven, den er beschwoeren wollte, recht war. Er
durfte keinen Fehler machen, denn der Daemon war maechtig, der Vernichter der
Brut wurde er genannt, Mameloth. Der Scribant, den der Kleriker getoetet
hatte, verriet den Namen des daemonischen Wanderers nach nur wenig Qual.
Laechelnd erinnerte sich der Priester an das letzte Hecheln des wimmernden
Mannes, bevor dieser den Geist aufgab.
Im Ruecken des Klerikers zogen aus einem stinkenden Kelch feine Rauchschwaden
auf, die der Mann jedoch in seinem Eifer nicht bemerkte ...

Nach einer Weile richtete sich die Aufmerksamkeit des Eiferers auf den Boden
mit dem Pentagramm. Akribisch hatte er es an zwei Mondfinsternissen dort
gemalt, wo der maechtige Daemon sich ohne weiteres bewegen konnte, ohne die
Decke des Klerikerturmes zum Einsturz zu bringen. Viel war es nicht, aber er
sollte ihm ja dort dienen, wo er das Blut der Brut beschaffen konnte ... bei
den Heeren der Hoelle.
Immer wieder bewegten sich die Lippen in leisem Tanz, formten Worte, Silben,
Reime, die den Fremden einladen sollten, den Turm seines Beschwoerers, nein,
seines Meisters, Yagur, zu betreten und ihm zu dienen. Schliesslich richtete
sich der Mann auf und betrachtete zufrieden sein Werk genau.
'Es muss gelingen', so waren seine Gedanken ... und so begab er sich erneut
in Meditation, um die vorgesehene Zeit abzuwarten, damit die Beschwoerung
perfekt durchgefuehrt werden konnte.

Auf Yagurs Stirn bildeten sich Schweissperlen. Etwas stimmte nicht, Gesang,
Geruch und Gefuehl waren nicht synchron mit den Schwingungen des hoellischen
Tores, das sich langsam im Keller seines Turmes abzeichnete. Und haette er
sich umgedreht, dann waere Yagur auch der dunklen Gestalten gewahr geworden,
die sich im Schatten des Turmes in die Welt geschlichen hatten, um die
Anrufung ihres Erzfeindes Mameloth scheitern zu lassen. Rabenschwarze Klauen
legten sich um den Hals des Klerikers von Ch'ran Daemonicus und liessen ihn
roecheln. Hilflos musste er mit ansehen, wie sich die finsteren Diebe sich
daran weideten, dass das Portal fuer den Vernichter der Brut nicht perfekt
war. Und als der Daemon als maechtiger Schatten in dem Tor erschien, welches
fuer ihn geschmiedet wurde aus finsterster Daemonenmacht, da weinte Yagur,
denn er wusste nun, dass er scheitern wuerde.
Und Scheitern ist beim Beschwoeren von Daemonen wie Mameloth nicht erlaubt.



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Wem Dank gebuehrt ... (Ark, 11. Okt 2010, 18:39:55):
Vielen Dank fuer das Testen dieser 3-Spieler-Quest geht diesmal an
Del, Cutter und Pendulon, muehsame Geburt, aber es hat dann doch
noch geklappt :-)

Inspiriert wurde alles von Haendels "Dixit Dominus" (wer haette das
gedacht?), wen es interessiert, auf Wikipedia findet man einiges
(http://en.wikipedia.org/wiki/Dixit_Dominus_%28Handel%29), da geht
es auch zu dem ganzen Text.
Hoeren (mit Albumkritik):
http://magazin.klassik.com/reviews/reviews.cfm?task=record&RECID=4820&LANGUAGE
=1&CONTENT=eMusici
Wer sich generell fuer Haendel interessiert/interessieren will,
kann sich auf http://www.haendel.haendelhaus.de umtun.

In der Quest ist das alles ein bisschen weniger biblisch, aber
deshalb sagte ich ja, "inspiriert" :-)

Jetzt bleibt mir nur noch, euch viel Spass zu wuenschen und dabei
wenig Flueche auszustossen. 



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Dixit Daemonicus 1->5 (Ark, 11. Sep 2011, 02:06:08):
Ich habe das Level ein wenig angehoben, da sie doch nicht unbedingt fuer
absolute Newbies geeignet zu sein scheint.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Ein Mann des Waldes ... (Ark,  3. Okt 2011, 18:54:55):
... weiss nun doch ein wenig mehr ueber das Morgengrauen und seine Regionen
Bescheid. Seine Reisen waren doch nicht umsonst, auch wenn die Fuelle an
Informationen durchaus limitiert sind. Sie sollen zum Reisen anregen und nicht
Reisefuehrer sein :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Schwanenschwingen ... (Ark, 29. Dez 2011, 18:27:38):
... tun jetzt auch das, was sie schon angekuendigt haben, also nicht
ueberrascht sein, wenn das, was da vorbeiscrollt, auch wirklich eintritt. Dank
an das letzte Team, was (unfrei- aber willig) geholfen hat, dieses Feature
nutzbar zu machen *fg*


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Vorsicht, liebe Heldinnen und Helden! (Ark,  5. Okt 2012, 21:07:20):
]Wie mir zu Ohren gekommen ist, sind die Untoten unter dem Wyrmdhal jetzt ein
wenig besser geworden ... nur einige wenige wurden schlaffer, und nur ganz
wenige sind unveraendert haesslich. Dank der Schliessung eines Kratzers im
Tod-Grab-Gefueges ist das Unheil wieder hergestellt. Ein trauriger Tag ...
aber so war es urspruenglich geplant.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Tueren im Tutorial (Arathorn,  1. Nov 2012, 14:04:09):
Hallo zusammen,

nachdem gestern abend das Problem, dass sich die Tueren im Tutorial seltsam
verhalten koennen, weitere Kreise zog, habe ich mir das Ganze mal 
angesehen und mit Zesstras Unterstuetzung einen Fix bauen koennen, der
hoffentlich dafuer sorgt, dass es nicht wieder auftritt. 

Drueckt mal die Daumen, dass das damit Geschichte ist, und meldet Euch,
wenn die Tueren doch nochmal Schwierigkeiten machen sollten.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Unglueck im Elfendorf (Ark,  4. Nov 2012, 14:19:01):
Ohje, da ist wohl etwas Dummes passiert im Elfendorf ... und so benoetigt wer
Hilfe. Wer das ist? Schaut euch um, man wird sich gleich an euch wenden, wenn
man euch sieht :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Krieg und Frieden ... (Ark,  9. Nov 2012, 00:51:43):
Stumm starrten sich die zwei Kontrahenten an, der eine wuetend und
wild entschlossen, der andere ruhig und vollkommen ausgeglichen. Die
Stille war zum Zerreissen gespannt, beide Antipoden waren der Diskussion
muede, denn sie hatte sich, wie zu erwarten war, als fruchtlos erwiesen.

'Wenn das Euer letztes Wort ist, Druide, dann wuensche ich Euch viel
 Glueck in den naechsten Wochen, denn Ihr werdet es brauchen.'
Mihails Augen zuckten hin und her, als vermutete er, von Schergen des
Druiden ueberfallen zu werden, sobald er den Saal verlassen wuerde.

'Dieser Tempel gehoert der Schuppengemeinschaft, Ihr habt darueber nur
 ein schaendliches Knochenhaus gestuelpt und es mit Tod und Schatten
 gefuellt.'
Des Schreindruiden Miene verfinsterte sich weiter, als er fortfuhr:
'Ihr gehoert nicht hierher, versteht Ihr das nicht ? Die Wyrmmutter
 wird Euch und Eure unheilige Bande nie akzeptieren, es wird keinen
 Frieden geben. Und ich werde sicherlich nicht in Eurem Namen die
 Schuppengeborenen bitten, ihren jahrtausendealten Tempel aufzugeben.
 Je schneller Ihr das akzeptiert, umso frueher wird hier wieder Frieden
 herrschen. Geht fort und baut Euer groteskes Knochengemaeuer weit
 weg wieder von hier auf. Hel ist an diesem Ort nicht willkommen.'

Stille kehrte ein.

'Und dies ist also Eure Meinung ? Habt Ihr sie gut ueberdacht und die
 moeglichen Folgen gegeneinander abgewogen ? Seid Ihr sicher, dass
 sich durch Euer ungestuemes Auftreten die Interessen so einfach
 ausgleichen lassen ? Habt Ihr eine Ahnung, was die Weisen meines
 Volkes ... Eures Volkes ... vorhersagten ?
 "Und als die Echsen sich erhoben, verging die Menschlichkeit. Aber
  hoeret wohl, sie ruhte nur, denn verloeschen wird sie nicht, es sei
  denn, der Kopflose Moench will uns strafen. Einst wird die Zeit
  kommen, da der Heilsbringer kommen wird, ein Glaeubiger, so rein,
  dass die Echsen sich kruemmen muessen vor seinem starken Willen, der
  genaehrt ist von Glauben und Mut."
 Ich denke, dass Ihr diese Weissagung kennt, es ist die Prophezeiung
 Jemenia des Einsamen. Ihr koennt sie nicht leugnen, auch sie ist Teil
 Eures Daseins, denn Ihr habt eine Haut wie wir, und nicht wie SIE !'

Da lachte der Druide herzlich, waehrend der alte Mann zitternd vor Wut
seine Niederlage eingestehen musste. Zwei maechtige Gestalten aus
Basalt hielten ihn in einem unbarmherzigen Griff gefangen, er konnte
sich kaum ruehren.

'Mihail ... Ihr koennt mich nicht vertreiben. Mit mir zieht mein Gott
 hier ein, sicher habt Ihr von ihm gehoert. Und er gibt nicht nur mir
 Kraft, nein, er schenkt auch den Schuppengeborenen neue Hoffnung,
 denn eins hat er mit ihren Geistern und mythischen Geschoepfen gemein:
 die Abneigung gegen alles, was den Tod verehrt. Seht Euch hier um,
 koennt Ihr nicht erkennen, dass dieser Saal bereits von ihm, unserem
 Erdmeister, erfuellt ist ? Spuert Ihr ihn nicht, diesen Willen zu
 leben ? Selbst der scheinbar tumbe Stein glitzert heller im Schein
 des Fackellichts, die Erde ist dunkler, fruchtbarer, und viele Triebe
 wuerdet Ihr sehen, wie sie weit ueber uns einen kraeftigen Wald
 bilden. Ja, all das ist sichtbar ... wenn man sich nicht dem Tod so
 sinnlos hingibt. Doch nun genug geschwatzt ... hinfort mit Euch, ich
 denke, der Worte wurden nun genug gewechselt.'

Eine lange Schweigepause folgte, waehrend derer die Gesichtszuege des
Alten sich immer mehr in Wut verzerrten. Die Basaltgolems loesten den
harten Klammergriff, so dass sich der fahle Totenheiler wieder ein
wenig bewegen konnte.

'Also habt Ihr Euch fuer den Untergang entschieden. Gut, es sei, umso
 frueher werdet Ihr im Antlitz Hels Eures Irrtums bewusst. Ich gebe
 Euch Recht, denn es ist in der Tat sinnlos, fruchtbare Worte auf den
 sterbenden Koerper eines Narren zu vergiessen. Ich warte an der
 Schwelle der Transzendenten Passage auf Euch ... bald.'

Mit diesen Worten drehte sich der Alte um und verliess den Schrein von
Y'al Terram.



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Weiter geht's ... (Ark,  9. Nov 2012, 00:53:20):
Dies ist der vorletzte Teil des Tempels.
Und es ist kein friedlicher, vor allem
keiner mehr fuer kleine Anfaenger, denn
die Sitten sind rauer, die Worte haerter
und die Konsequenzen falschen Handelns
unbarmherziger denn je.
Vier kleine Quests warten auf unverzagte
Helden, eine weitere ist zwar erkennbar,
aber noch nicht spielbar, weil der letzte
Teil gluecklicherweise noch fehlt.
Wohlan, ihr Recken, besiegt den Vampyr,
den Herzzeitlosen, um das geheimnisvolle
Knochenallerheiligste zu betreten.
Besucht den Schrein Y'al Terrams, des
Erdmeisters. Und macht euch unsterblich,
indem ihr das Tagebuch des Avatars von
Hel weiter fleissig fuellt ...


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Weiter geht's ... (Ark, 17. Nov 2012, 02:36:51):
~#! rn=Ark rt=1352418800 rg=d.anfaenger
~#! tid=1352418800
Was ich noch vergessen hatte zu erwaehnen ... es gibt einen neuen
Pflanzenkrieger. Ihr stolpert vielleicht ueber eine Komponente dort unten, ein
alter Bekannter (?!) im Knochentempel kann euch darueber sicher mehr
erzaehlen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Ein duesterer Dunkelelf im Forst der Silberseide ... (Ark, 19. Nov 2012, 20:10:54):
... hat jetzt seine vielbeinigen Freunde endlich davon ueberzeugen koennen,
sich ein wenig dem Teamgedanken unterzuordnen und rudimentaer taktischer
vorzugehen. Warum erst jetzt? Weil sein Schoepfer zu daemlich war, das richtig
umzusetzen. Und so wurde das Boese in die Welt hinausgetragen, wo es reiche
Fruechte brachte.
Das Gute ist: alles andere bleibt beim Alten :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Arrogante Erzmagier (Oham,  7. Jan 2013, 23:34:13):
Na super, danke Humni!

Ich dachte, das ist es jetzt. "rohrhoere" bringt Dich hervor, das haette
ich mir auch gleich denken koennen. Das ist das Allerletzte, wie ueblich
bei Dir.

Du baust wieder ein Gebiet, Du kuendigst NIX in der MPA an, Du schliesst
es einfach an. Danke, Herr Erzmagier, wieder mal nicht noetig, uns
"niederes Volk" zu benachrichtigen.

Und dann geht man da rein, dann stehen da lauter Viecher drin, die alle echt
heftig sind. Eins schwieriger als das andere. Und wenn man dann mal denk,
oh toll, Ausruestung metzeln - dann faellt man um. Bumms. Einfach so.

Schweineviecher sind das.

Humni, ich finde, Du solltest mal versuchen, ein wenig fairer zu denken. Es
laeuft nicht jeder mit einem Max-Tanjian als Hauptzweitie rum.  Nicht jeder
hat die Zeit, die ganzen Dinge anzugucken und jedes Ruestungsdetail genau
durchzuschauen, ob es ja noch einen Punkt mehr bringt irgendwo...

Ich hab so jedenfalls keine Lust mehr hier zu spielen.

Oham

-----------------------------------------------------------------------------



Re: Arrogante Erzmagier (Humni,  7. Jan 2013, 23:36:59):
~#! rn=Oham rt=1357598053 rg=d.anfaenger
~#! tid=1357598053
Weichei.

Was anderes faellt mir da wirklich nicht mehr ein.

Das ist halt kein Simpelgebiet. Es ist schwieriger als die Hochebene. Aber mal
echt, Du bist ein Takal'Mor. Ein OFFIZIER!

Du solltest sowas auch schaffen koennen. Aber nein, hier wieder reinkommen,
trage tarnhelm der zauberer und rumjammern.

Nennst Dich Avatar und machst dann derartigen Unsinn und schimpfst hier rum.

Ja, es ist schwieriger als die Hochebene. Aber mal im Ernst: Wie willst Du
jemals in die schwierigeren Gebiete wie die Schreckensspitze kommen, wenn Du
nichtmal die Wurzelgraeber schaffst?

Geh sterben. Oder, damit der Herr Avatar das auch versteht:
THOU HAST LOST AN EIGHT.

Und der Rest mag sich einfach mal westlich vom Elfendorf umschauen. Nein,
nicht bei den Goblins. Aber schon grob die Richtung.

Vielleicht habt ihr ja Zweities, die was taugen, oder tut das selbst.

Humni

-----------------------------------------------------------------------------



Re: Re: Arrogante Erzmagier (Humni,  8. Jan 2013, 18:44:15):
~#! rn=Humni rt=1357598219 rg=d.anfaenger
~#! tid=1357598053
Da ich gerade gefragt wurde:

* Fehlende Plaketteneintraege sollten bald folgen.
* Eine gewisse Person, die schon erwaehnt wird, ist noch nicht erreichbar,
aber ich denke, lange dauert das nicht mehr.

Soweit in Kuerze.

Humni

-----------------------------------------------------------------------------



Re: Re: Arrogante Erzmagier (Muadib,  8. Jan 2013, 18:44:49):
~#! rn=Humni rt=1357598219 rg=d.anfaenger
~#! tid=1357598053
Mach den armen Kerl doch nicht so fertig.
Er meint es nur gut.
Humni muss doch weinen wenn Du so boese bist, er ist doch schliesslich ein
ganz lieber, weichherziger und empfindlicher Plueschdrache.

-----------------------------------------------------------------------------



Re^3: Arrogante Erzmagier (Malie,  8. Jan 2013, 18:45:28):
~#! rn=Muadib rt=1357667089 rg=d.anfaenger
~#! tid=1357598053
nein, der wollte mich fressen:)))))))) als ich gestorben bin;)

-----------------------------------------------------------------------------



Neuigkeiten... (Humni, 11. Jan 2013, 23:08:28):
Da einige Leute mich auf Ideen gebracht haben...

Holzscheite erneut identifizieren koennte nun eine neue Information bringen.
Nicht wichtig, aber ich dachte nur, es ist fair, das anzukuendigen, da einige
die schon angschaut haben.

Humni

-----------------------------------------------------------------------------



Re^3: Arrogante Erzmagier (Oham, 12. Feb 2013, 21:04:47):
~#! rn=Humni rt=1357667055 rg=d.anfaenger
~#! tid=1357598053
"Fehlende Plaketteneintraege sollten bald folgen." Jaja. Das kann jeder sagen.
Kuemmer Dich mal!
Ja, ich weiss, ich hab keine Plakette, aber die ist ja auch wirklich sauschwer
zu kriegen. Du machst mal wieder nur Gebiete fuer andere Spieler, die schon
eine Plakette haben. Und das in d.anfaenger. Super, Humni!

"Eine gewisse Person..." - super. Na, ganz toll. Wer ist denn "eine gewisse
Person"? kannst Du da nicht konkreter werden?

Und ueberhaupt, wieso faellt man bei Dir direkt runter, wenn man Kisten
anhebt?

Dein neues Gebiet ist zum Kotzen. Ich uebergebe mich jetzt hier oeffentlich
auf einen moeglichst wertvollen Teppich in Deiner Drachenhoehle, und klaue
danach Dein Bier.

Oham der Avatar

-----------------------------------------------------------------------------



Re^4: Arrogante Erzmagier (Humni, 12. Feb 2013, 21:07:05):
~#! rn=Oham rt=1360699487 rg=d.anfaenger
~#! tid=1357598053
*seufz*

Ja, toll, Oham. Schau weiter unter Kisten.

Und besorg Dir endlich eien Plakette. Wieso hast Du eigentlich keine? Ach so,
ich weiss. Da braucht man etwas fuer, was Du nicht hast - Freunde. Hehe.

Und wenn Du nicht weisst, wer "die gewisse Person" ist, hast Du halt ein
Problem, nicht ich. Du kannst nicht metzeln, Du kannst nicht forschen, Du
kannst nur rumjammern. Geh zaubern.

Und der Rest kann ja mal gucken, wo Oham abgeblieben ist. Irgendwo weiter
unten... 

Humni

-----------------------------------------------------------------------------



Zum Furienkrieg ... (Ark,  2. Mar 2013, 12:18:52):
Falls sich wer wundert, wenn er neuerdings (ab jetzt) keine Pfeife mehr
bekommt ... mea culpa, ich dachte, ich haette schon vor laengerer Zeit
ausgebaut, dass man die Quest starten kann, ohne zumindest einen Wicht
gerettet zu haben ... war aber nicht.
Aber nun. Ich vermute mal, das haette man eh nicht weiter bemerkt, weil immer
der Fall, aber falls sich wer wundert, hier steht's :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^5: Arrogante Erzmagier (Humni, 23. Apr 2013, 18:59:14):
~#! rn=Humni rt=1360699625 rg=d.anfaenger
~#! tid=1357598053
Auf Vorschlag einer Spielerin kann man nun vor dem Tauchen in einem See
einatmen. Hinweis ist im Raum, aber da den ja einige sicher schon abgeforscht
haben, hier die Info.

Humni

-----------------------------------------------------------------------------



Boeses Fluestern, verfluchte Worte, verruchte Taten, verfluchte Vergangenheit (Ark, 11. Okt 2013, 23:40:47):
Als ich der Gaertnerin im Elfendorf wieder einmal begegnet bin, erschien sie
erheitert und froh ... und dennoch spuerte ich, dass etwas nicht stimmen kann.
Ihr Sohn, dem ich einst half, wie mag es ihm seitdem ergangen sein? Ein
eisiger Hauch streifte mich und liess mich schaudern. Die Kaelte kommt, und
sie stroemt aus alter, vergessener Erde ... aber dies muessen andere
ergruenden, ich bin zu alt, verbraucht, vergessen ...


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Wyrmer Ueberbleibsel (Ark, 13. Okt 2013, 13:02:52):
Hi, die Schuppen und pflanzlichen Ueberreste der Wyrmer im Tal sind jetzt auch
mit der Faehigkeit ausgestattet worden, ihren ausgewaehlten Moerder zu
erkennen, wenn diese(r) mit feigen Methoden wie Toga, Wurfstern, Daemon, etc.
den armen Wyrm getoetet hat.
Hinweis fuer Magier: alles, was in get_killer_object drinsteht :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Neues im Tutorial (Arathorn, 16. Aug 2014, 01:08:39):
Hallo zusammen,

ich habe gerade eine Aenderung fuer das Tutorial eingespielt, die den 
Beginn hoffentlich etwas vereinfacht. Neue Spieler starten nun nicht mehr
direkt beim Steinbeisser, sondern bei seinem "Nachbarn", der in einer Huette
ein paar Raeume entfernt im Wald wohnt. Von dort muss ein leichter Botengang
erledigt werden: ein Paeckchen ist von der Huette zum Steinbeisser zu bringen.

Der Gedanke dahinter ist, dass die Spieler nach der Charakter-Erschaffungs-
sequenz direkt etwas sehr einfaches zu tun bekommen und ein bisschen 
herumlaufen koennen. Zudem wird auf diese Weise der Scroll der ersten 
Sequenz, der spieltechnisch ja nur Gimmick ist, vom Scroll des ersten
Steinbeisservotrags getrennt, der fuers Fortkommen wichtig ist.

Falls also in naechster Zeit ungewohnte Fragen zum Tutorial gestellt werden:
das liegt vermutlich an der Aenderung.

Ich bitte um fleissiges Daumendruecken, dass das den gewuenschten Effekt hat
und die Spieler etwas laenger bei der Stange bleiben und dass vielleicht
mehr als bisher Geschmack am Mudden finden.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Daemliche Wichte ... (Ark, 23. Jan 2015, 20:30:55):
Zu doof, um selbst bei den Texten in der Fraternitas nicht uebereinander zu
stolpern. Also, jetzt ist rundlich nicht mehr ... sonstwo und sonstwo nicht
mehr rundlich :-) Die Schreiber stoehnen erleichtert auf.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Wurzelgraeber und Effekte (Humni,  1. Jul 2015, 13:08:37):
Huhu,

bei den Wurzelgraebern haben sich einige der Heilstellen etwas ... veraendert.
Sie sind jetzt so, wie sie immer gedacht waren, das bisherige Verhalten war
nicht intendiert.

Vermutlich merkt das eh niemand, aber ich dachte mir, ich schreib das einfach
mal.

Humni

-----------------------------------------------------------------------------



De Templum Os Hel (Ark,  3. Sep 2015, 00:25:55):
Zitternd blaetterst Du in Deinem schwarzen Buechlein mit den gueldenen
Lettern. Bald ist es vollbracht. Doch bis dahin wird noch einiges an Gefahren
- grossen, legendaeren Gefahren, die sich mit Glueck in Legenden verwandeln
werden - zu ueberstehen sein. Was dann ?
Die Kunde zieht schon durch die Lande, Spekulanten und Kaufleute suchen schon
nach Moeglichkeiten, sich an Deinen Taten mit gutem Gold zu bereichern ... und
so ist es nicht verwunderlich, dass ein findiger Moebelmaker sich von seinem
Meister Ike A. Pax losgesagt hatte und nun in Wilhelmsburg auf Dich wartet, um
Deinen kuenftigen Ruhm mit einem edlen Meisterwerk zu verherrlichen. Herrlich
sind auch die Preise, die nichts mehr mit dem bescheidenen Handwerker Ike A.
zu tun haben ... aber ob Du sie Dir nicht doch einmal anschauen solltest?


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: De Templum Os Hel (Ark, 17. Sep 2015, 20:27:42):
~#! rn=Ark rt=1441232755 rg=d.anfaenger
~#! tid=1441232755
Ja, ich toll. Leider hab ich die Massnahme uebersehen, wie man das Lesepult
auch zum Verbleib nach Armaggeddon ueberredet. Dieses sollte nun behoben sein
... Test dann irgendwann mal :-) Bedauernswerte Geschaedigte koennen sich bei
mir melden, nachdem sie sich nochmals zu August begeben haben :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Fin! (Ark,  6. Okt 2015, 23:00:46):


Schwarz die Waende, dunkel der Saal. Selbst die Fackeln, gross und
maechtig, sie konnten den Wirbelbrynn nicht sehr deutlich von der
allmaechtigen Dunkelheit hervorheben, die das Finstere Heiligtum umgab.
Die hoch aufgeschossene Gestalt froestelte, als sie den Schattendom
betrat, selbst sie fuehlte sich hier niemals wohl.

Eine kichernde, schrille Stimme ertoente:
'Der Zugang sei Euch nicht verwehrt, ich freu mich, wenn Ihr uns
 beehrt. Der Meister kann Euch nicht empfangen, doch weiss ich, das
 ist Euch nicht entgangen.'

Der fahle Totenheiler fuhr herum, seine bleichen Knochen blitzten
kurz in der Dunkelheit auf, als er der unsteten Schattengestalt
gegenuebertrat, um diese schweigend zu mustern. Unbewusst fuhr er mit
seinen duerren Haenden ueber die Hieroglyphen seiner hellgrauen Roben.

Und so sprach er auch nach einer Weile der Stille ruhig auf den
wabernden Priester ein:
'Ich aber weiss, dass ich sehr wohl mit Deinem Meister sprechen kann.
 Und ich werde mit ihm sprechen ... oder willst Du, dass ich ihm sage,
 dass man ihn nicht gewarnt hat ? Hole sein Imago, ich habe etwas zu
 klaeren mit ihm.'

Und fuer einen Augenblick verharrte die zuckende Gestalt des grimmen
alten Nachtschattenpriesters. Kaelte stroemte aus dem immateriellen
Koerper, doch sie konnte Mihail nicht aengstigen oder verletzen.

Hysterisch kicherte der Priester:
'Mutig seid Ihr, klug nicht sonders, nun aber wird es sein ganz
 anders: Jetzt hole ich den Schattenkaiser, dann werden Eure Schreie
 leiser.'

Mit diesen Worten verblasste die Gestalt, Mihail stand alleine beim
Wirbelbrynn, dem einzigen Weg zurueck, hinaus aus dem Finsteren
Heiligtum.

Es wurde still ...

Die Finsternis huellte alles ein, auch ihn.

Dann, als die Stille sich neben die Dunkelheit gesellte und das, was
lebte, zu ersticken drohte, sah er etwas in der Schwaerze, eine kleine
Bewegung, ein Wallen, das die Schatten vertrieb, weil es noch dunkler,
kaelter und erbarmungsloser war. Und doch ... Mihail harrte aus, denn
er wollte unbedingt mit seinem fehlgeschlagenen Versuch sprechen,
herausfinden, ob sich mit der Wesenheit nicht doch noch irgendein Pakt
schliessen liess.
Und dann gleisste weisses Licht vor dem Totenheiler auf ... denn das
Abbild des Nesserpatus erschien ihm. Die grellen Augen ruhten auf dem
schwaechlich wirkenden Mihail, liessen ihn klein und unbedeutend wirken.

Doch im Bewusstsein der Ferne, in der sich der Kaiser tatsaechlich
aufhielt, blickte der Herr des Knochentempels auf und sprach:
'Seid mir gegruesst, Schattenfuerst. Lange ist es her, dass ich Euch um
 Rat fragte ... und Ihr mich abgewiesen habt. Und doch kann es immer
 noch sein, dass wir miteinander ... arbeiten koennen, arbeiten, um
 unserem gemeinsamen Herrn zu dienen. Ich bin mir sicher, dass Hel es
 nicht gefallen kann, dass wir uns so anfeinden. Und so biete ich Euch
 erneut eine Waffenruhe an, auf dass wir den Knochentempel von dem
 Gesindel befreien, das uns staendig bekriegt.'

Als das Licht verschwand, rieb sich der alte Totenheiler die Augen. Der
Schmerz des grellen Augenlichts aber blieb. Eine leise, einschmeichelnde
Stimme ertoente in den Schatten:
'Ah, Hels Bote auf Erden ... der Schemenmeister, der sich mit einigen
 Kreaturen und Getreuen des Herrn umgibt ... UND IHN BETRUEGT !'

Die Stimme veraenderte sich, bis sie schliesslich in einem wuetenden
Schrei endete. Der Schattenkaiser war sichtlich wuetend, und er tobte
weiter.

Nach einer Weile der Stille in den Schatten erhob sich wieder die ruhige
Stimme des Fuersten:
'Habt keine Angst, ich werde Euch nichts tun. Aber seid gewarnt: Ihr tut
 nichts, was Hel gefaellt, Ihr und Eure Spiessgesellen seid vom Pfad des
 Herrn abgekommen ... und es sieht nicht so aus, als wuerdet Ihr diesen
 wiederfinden. Es bleibt dabei, ich werde Euch nicht helfen. Aikka wird
 es nicht gelingen, mich zu beschwoeren, es liegt ganz alleine an Euch,
 mich wieder freizulassen. Aber dazu seid Ihr zu feige, ich spuere es,
 und so sage ich ehrlich, dass Euch nur noch die Transzendente Passage
 zur Suehne offensteht. Hel wartet auf Euch und alle Gefolgsleute. So
 kehrt von Eurem Weg ab. Mein Priester wird Euch sicher nicht helfen,
 dessen seid gewiss. Nun will ich mich wieder zurueckziehen und schlafen.'

Die Schwaerze verliess die Dunkelheit, und die Dunkelheit wich grauen
Schatten, die das Finstere Heiligtum bevoelkerten. Und dazwischen sah
Mihail auch seinen eigenen, von den erneut aufflackernden Fackeln im
Schattendom herbeigerufen. Die roten Augen des flimmernden Priesters
erschienen ihm wieder. Taeuschte er sich, oder troff aus der Stimme des
Geistlichen Hohn ?

Dieser postierte sich vor dem Wirbelbrynn und sprach:
'Und war es gut, den Fuerst zu sprechen ? Erinnerte er Euch an all die
 Verbrechen ? Bald werde ich erloesen ihn von seinem Fron. Seine Rache
 wird sein Euer gerechter Lohn. Finden werde ich die, die ihn erloesen
 von seiner Pein, und Euch wird er holen in seinen finsteren Schrein.'

Mit diesen Worten verschwand der Priester in den dunklen Gaengen des
Finsteren Heiligtums. Zurueck liess er einen nachdenklichen, ja sogar
ein wenig furchtsamen Totenheiler.

Anderenorts aber beobachtete man diese Geschehnisse mit Sorge ...

'Wasss issst geschehen, Vebrrryn, warrrum wirrrd esss ssso kalt in meinem
 Nessst ? Haben die Bleichen Prrriesssterrr ihn wiederrr gerrrufen ?'
Unruhig wiegte der schlanke Kopf des gewaltigen Wyrms hin und her.

Der grauweisse dicke Gigant kroch langsam auf das seltsame grosse Gebilde
zu, das einem gigantischen Nest glich. Fast liebevoll fuhr seine dunkle
Zunge ueber den Kopf der Wyrmmutter:
'Oh Nyshiina, genauso ist es. Doch er hat die Priester Hels erneut sehr
 deutlich abgewiesen. Er wird uns nicht gefaehrlich werden.
 Das Gefaengnis seiner "Herren", das von Thorax ersonnen wurde, hat sich
 als sehr stabil erwiesen.'

Unruhig zuengelte die Wyrmmutter hin und her:
'Und doch sssorrrge ich mich sssehrrr, mein Sssohn. Denn esss werrrden
 anderrre sssein, die den Ssschattenfuerrrsssten holen, nicht die
 Prrriesssterrr von Hel. Und diesss mussss verrrhinderrrt werrrden,
 Vebrrryn.'

'Vielleicht muessen wir es gar nicht, oh verehrte Mutter.'
Die Stimme ertoente aus dem Norden, und sie wurde gefolgt von einem
stahlblauen Wyrm, der majestaetisch heranschwebte und sich elegant im
Nest niederliess.

Seine klare Stimme vernahmen alle Soehne und Toechter der Wyrmmutter,
als er anhub zu erklaeren:
'Es existieren Sterbliche, die die Kraft, die Ausdauer, den Willen und
 den Mut haben, auch jemandem wie Nesserpatus entgegenzutreten. Wenn
 sie es schaffen, ihn zu verbannen, dann werden wir zumindest von ihm
 nicht mehr behelligt. Teste sie, Mutter, Du wirst erkennen, dass ich
 die Wahrheit spreche.'

Nyshiina blickte ihren Sohn erst erstaunt, dann mit sichtlichem Stolz an:
'Ich wusssste nicht, dassss Du ssso ein Ssstrrratege und Kennerrr von
 diesssen Wesssen bissst, Thayfundarrr. Aberrr wenn esss ssso issst, wie
 Du sssagssst, dann hat diesss grosssse Bedeutung fuerrr unsss. Ich bin
 gewillt, diessse Wesssen, die sssich in unssserrren Tempel wagen, auf
 die Prrrobe zzzu ssstellen. Und ja, sssie werrrden sssich sssehrrr
 anssstrrrengen muessssen, denn esss wirrrd nicht leicht sssein.'

Und so wurde das letzte Kapitel der Tempelgeschichte aufgeschlagen, in
dessen Verlauf sich das Schicksal der Priester Hels und der Priester der
Schuppengemeinschaft entscheiden sollte.



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Comprehensio (Ark,  6. Okt 2015, 23:01:01):

Numeri Templum
--------------


Spatium: 129

Corpus: 429

Res: 177

Dictum: 14

Initium: 12/11/2006

Exitus: 06/10/2015



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Danke! (Ark,  6. Okt 2015, 23:23:32):
An dieser Stelle will ich mich noch brav bedanken an allen, die dieses
laengliche Projekt mitgetestet, mitkritisiert, mitabgenommen und mitgespielt
haben. Fuer den letzten Teil insbesondere Arathorn, der mir mal wieder ein
paar Neuerungen an Funktionalitaet verpasst hat, die ich in meinem Braustuebl
nicht ganz verinnerlicht hatte :-)
Und natuerlich an der Kundschaft, die ebenfalls mitmeckert und
Verbesserungen/Korrekturen hinterlassen hat, an denen ich auch merke, dass da
viel Zeit draufging. Danke fuer die Geduld.
Viel Spass :-)



              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Wurzelgraeber unterwegs? (Arathorn, 10. Mai 2016, 20:37:46):
Hallo zusammen,

mir wird gerade berichtet, dass die Chefin der Wurzelgraeber kuerzlich 
ausserhalb des Stollensystems ihres Clans gesehen wurde. Sie soll gar
auf Tamibar gewesen sein, in der Naehe des alten Flugzeugs, und hat dort
wohl etwas mitgehen lassen, denn sie wurde auch gesehen, wie sie heimlich
wieder in ihre Behausung zurueckkehrte, und zwar mit einem merkwuerdigen
Lederding in der Hand, das sie vorher nicht hatte.

Ich kann mir da gerade keinen rechten Reim drauf machen, aber vielleicht
findet sich ja der ein oder andere Abenteurer, der der Sache mal auf
den Grund gehen mag.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Verwechslung (nicht) ausgeschlossen? (Ark, 21. Mai 2016, 01:13:48):
Ok, dank unserer aufmerksamen Spieler (war nur einer :-)) ist es mir gelungen,
die Beschreibungen, die die Eibe offenbart, bezueglich zweier gewisser Wichte
richtigzustellen. Die sehen sich zwar nicht mal aehnlich, aber man kann sie
dennoch verwechseln. Nun sollte das, was man als Hinweis bekommt, auch mit der
Realitaet uebereinstimmen. Wer beide schon "erledigt" hatte, wird nichts
bemerken, es fiel nur auf, wenn man einem von beiden geholfen hatte, aber
seltsamerweise eine unpassende Beschreibung mitgeteilt bekommen hat. Der Baum
war schuld! ... Leider nicht, nur ich :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



In Sachen Knochen ... (Ark, 27. Nov 2017, 13:57:01):
Habe gerade eine Altlast beseitigt, die urspruenglich genutzte Loesung fuer
die Anerkennung der "persoenlichen" Knochen im Wyrmdhal wurde durch eine
aktuelle, einfachere Loesung ersetzt. Das fuehrt dazu, dass nun auch Kills von
Begleit NPC wie Daemon, Einhorn, Nashorn ... angerechnet werden. Die alte
Loesung dafuer funktionierte schon mehr als 3 Jahre nicht mehr.
Das verleitet mich nun noch zu einer Bemerkung, dass richtige Spieler halt
Gilden ohne Begleitservice waehlen :-)
Falls ich wider Erwarten doch als Vertreter der Luegenpresse fungieren sollte,
bitte ich demuetigst um Anzeige.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Bloede Magier immer - besonders Humni! (Oham, 24. Dez 2017, 20:46:26):
Ich hasse es.

Du machst nur Scheisse, Humni.

Da geht man irgendwo hin, faellt in ein Loch, und dann ist alles heiss.

Ich denk noch, was mach ich hier ... das ist doch alles wieder so ein
typisches Humni-Gebiet. Alles heiss, Viecher, die sich in der Lava suhlen.
Mal im Ernst, auf den Scheiss kannst auch nur Du kommen!

Und dann so ein Gegner. Rauke oder Krautsalat oder sowas. Ich meine, Du gibst
dem so einen Namen, und dann ist das so ein Hammerviech! Ich hau einmal mit
Saeure drauf, und der macht mich platt!

Deine Gebiete werden immer absurder. Lass den Scheiss doch einfach, gib
Deine Posten auf und versuch mal, wie ein Spieler zu denken!

Oham der Avatar

-----------------------------------------------------------------------------



Re: Bloede Magier immer - besonders Humni! (Humni, 24. Dez 2017, 20:47:23):
~#! rn=Oham rt=1514144786 rg=d.anfaenger
~#! tid=1514144786
Hallo ihr,

zunaechst muss ich ganz vielen Leuten danken.

* Rhovan und insbesondere Saray fuer viel, viel eifriges Testen.
* Ark kann ich gar nicht genug danken. Ich habe ihm da eine Sache vor einer
  Woche vor die Fuesse gekippt. Und er hat sie damit verbracht, dies alles
  durchzugucken, die Miniquests genehmigt ...
* Miril hat dann noch schnell die FPs eingetragen.

Preiset Ark! Und das meine ich ernst.

So. Eigentlich wollte ich jetzt schreiben, was es da alles gibt, aber dieser
Weichei-Kaempfer hat ... ach egal. Hoer auf zu jammern, werd General und
hoer endlich auf, den Kodex nur auswendig aufzusagen - lebe ihn.

So. Damit brennt nun auch die 4. Kerze, und das sogar noch rechtzeitig.

Viel Spass. Bugs und Typos und ... ach, alles - setzt es ab, ich kuemmer
mich die Tage drum.

Und wenn ihr irgendwo meint, ihr findet was nicht und euer Kumpel X hat das
gefunden: Ja, kann sein.

Humni

-----------------------------------------------------------------------------



Re: Re: Bloede Magier immer - besonders Humni! (Humni, 24. Dez 2017, 20:48:08):
~#! rn=Humni rt=1514144843 rg=d.anfaenger
~#! tid=1514144786
Ach ja - das ist ...


DIE VIERTE KERZE.

So.

Damit brennt der Adventskranz.

Humni

-----------------------------------------------------------------------------



Re^3: Bloede Magier immer - besonders Humni! (Ark, 26. Dez 2017, 17:53:55):
~#! rn=Humni rt=1514144888 rg=d.anfaenger
~#! tid=1514144786
Aber eher in Manier 'BURN baby, BURN!'


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Generalsknochen (Arathorn, 29. Jan 2020, 22:21:48):
Hallo zusammen,

solltet ihr in der Situation sein, bei Reboot/Crash/Ende mehrere der besagten
Generalsknochen aus dem Wyrmdhal bei euch zu haben, aber keine Schatulle, um
sie darin zu lagern, so bleiben diese Knochen nun alle erhalten statt wie
bisher nur einer.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Re: Generalsknochen (Arathorn, 29. Jan 2020, 22:28:50):
~#! rn=Arathorn rt=1580332908 rg=d.anfaenger
~#! tid=1580332908
Ah, ein Hinweis noch: Das gilt fuer neu geholte Knochen. Alle, die noch in
der letzten Uptime ermetzelt wurden, muessten manuell ersetzt werden. 
Meldet euch dann einfach, das geht ganz schnell und tut ueberhaupt nicht 
weh. :-)

Arathorn.

-----------------------------------------------------------------------------



Re: Re: Generalsknochen (Arathorn, 29. Jan 2020, 22:58:09):
~#! rn=Arathorn rt=1580333330 rg=d.anfaenger
~#! tid=1580332908
Und noch ein zweiter Hinweis: wer eine Schatulle besitzt und eine Autoloader-
Truhe im Seherhaus, sollte bitte die Schatulle einmal dort deponieren und
wieder rausholen, denn bei der hat sich auch eine Kleinigkeit geaendert.

Wer keine Truhe hat, kann stattdessen Ende machen. Wer das, warum auch immer,
auch nicht kann oder mag, meldet sich bitte auch einfach. Auch das Ersetzen
der Schatulle tut nicht weh. ;-)

Arathorn.

-----------------------------------------------------------------------------



Re^3: Generalsknochen (Zaphob, 29. Jan 2020, 23:16:37):
~#! rn=Arathorn rt=1580335089 rg=d.anfaenger
~#! tid=1580332908
Autoload, Seherhaus, ist das denn hier die richtige Rubrik? :)

-----------------------------------------------------------------------------



Re^4: Generalsknochen (Arathorn, 29. Jan 2020, 23:36:47):
~#! rn=Zaphob rt=1580336197 rg=d.anfaenger
~#! tid=1580332908
Ja, weil Ende eben auch geht. :-)

-----------------------------------------------------------------------------



Plaene fuer die Region (Arathorn, 26. Aug 2023, 00:47:55):
Hallo zusammen,

nachdem ich nun die Region Anfaenger als RM uebernommen habe, wollte ich ganz
gerne einmal umreissen, wie meine Plaene fuer die Region aussehen. Einiges
wird etwas diffus bleiben muessen, aber die grobe Richtung sollte erkennbar
werden.


Allerdings wuerde ich euch zuvor gerne auf einen Exkurs mitnehmen und aus der
Erinnerung heraus umreissen, als was die Anfaengerregion einmal geplant war
und wie sie zu dem wurde, was sie heute ist.

Los geht's: Der urspruengliche Ansatz war, in einer neu zu schaffenden Region
ein Gesamtkonzept umzusetzen, das neuen Spielern auf verschiedene Arten und
Weisen den Einstieg erleichtert. Dazu sollte zum einen das Tutorial
gehoeren, aber auch weitere, noch zu erschaffende Gebiete, in denen
anfaengertaugliche Abenteuer, Miniquests und aehnliches zu Hause sollten, die
aufeinander aufbauen und nur sehr gemaechlich steigende Schwierigkeitsgrade
bieten sollten.

Diese Region sollte die Region "Anfaenger" sein.

Wichtig zu wissen ist, dass die Details dieses Konzepts gar nicht so
feinkoernig ausgearbeitet waren, wie ihr euch das jetzt vielleicht vorstellt.
Es waren eher so etwas wie grob umrissene Leitplanken, innerhalb derer sich
die Aktivitaeten in der Region abspielen sollten. Der Grund dafuer ist, dass
wir EMs zu der Zeit selbst keine genaue Vorstellung davon hatten, was man
genau tun muesste, um neue Spieler besser bei der Stange zu halten, zu
motivieren und an die ungewohnten Spielkonzepte heranzufuehren. Wir hatten
ein paar Ideen, was man vielleicht machen koennte, das Tutorial war eins
davon (das aber auch schon mehrere Iterationen brauchte, bis es endlich den
Stand erreicht hatte, den es heute hat). Darueber hinaus war kaum etwas
festgelegt; beispielsweise hatte auch niemand eine gute Vorstellung davon,
wie denn ein "gemaechlich steigender Schwierigkeitsgrad" aussehen sollte. Es
war uebrigens auch nicht definiert, wie oder woran der Erfolg des neuen
Konzepts eigentlich gemessen werden koennte.

Wenn ihr jetzt den Eindruck gewinnt, dass das mehr ein Experimentierlabor
war, als ein konsequent umgesetzter Plan mit vordefiniertem Ziel, dann habt
ihr vermutlich recht. Ich bin in der Rueckschau nicht einmal mehr sicher, ob
irgendjemandem der Beteiligten die Unzulaenglichkeiten dieses Ansatzes so
bewusst waren wie das vielleicht heute der Fall ist.

Es wurde also beschlossen, dass eine Region "Anfaenger" her muesse, und es
fand sich mit Ark einer der kreativsten Koepfe als Regionsmagier fuer die
Region, der auch schon einige Ideen hatte, wie es dort aussehen koennte. Er
hat also sozusagen als erstes Experiment der neuen Region zunaechst die
Wonnewichte ins Leben gerufen, und von da aus wurde weiter gebastelt.


Jetzt ist es aber so, dass es zum einen auch in diversen anderen Regionen
anfaengertaugliche Gebiete gibt (die zudem teilweise dort entstanden, als es
die Region Anfaenger schon gab und eigentlich hier haetten angeschlossen
werden muessen). Zum anderen existieren bekanntermassen in der
Anfaengerregion diverse Gebiete, die nicht anfaengertauglich sind und es nie
waren. Dieses Konglomerat stellt schon rein inhaltlich das Konzept der Region
in Frage, wobei gleichzeitig kein uebergreifender Plan zur Verknuepfung der
fuer Anfaenger geeigneten Bereiche der verschiedenen Regionen besteht.

Darueber hinaus stellen alle anderen Regionen (mit Ausnahme der Seher-Region,
wo aber nur die Seherhaeuser beheimatet sind) geographisch eingeordnete Zonen
des Morgengrauens dar wie beispielsweise Wueste, Dschungel, Gebirge oder
Polar. Die Region "Anfaenger" ist dies jedoch nicht - mit dem Ergebnis, dass
dort Gebiete entstanden sind, die inhaltlich in den Wald passen wuerden, aber
auch welche fuer die Unterwelt oder die Inseln, und Spieler wundern sich, wo
diese Region denn wohl rein raeumlich angesiedelt sein soll.

Alles in allem ist aus dem an sich sinnvollen Ansatz ueber die Jahre eine Art
Franken-Region aus mehr oder weniger geeigneten Gebieten und Objekten
geworden, die zum Teil stark miteinander verwoben sind und damit Anfaengern
eine wohl steilere Lernkurve abverlangen, als urspruenglich beabsichtigt.


Nach langer Vorrede aber nun zum Anlass dieses Artikels: Ich moechte in der
Region zwei voneinander unabhaengige Dinge umsetzen. Zum einen werde ich
versuchen, inhaltliche Unzulaenglichkeiten der einzelnen Gebiete weitgehend
zu bereinigen. Dabei will ich auch bereits seit langem bestehende
Kritikpunkte nach Moeglichkeit adressieren. Dieser Punkt ist das, was sehr
wahrscheinlich zuerst passieren wird.

Zum anderen moechte ich mittelfristig daran arbeiten, die Region aufzuloesen.

Das bedeutet, dass alle Gebiete, die inhaltlich in andere Regionen passen,
dorthin verlegt werden, so dass am Ende eine saubere geographische (und
Backstage auch technische) Zuordnung hergestellt ist. Wahrscheinlich werden
das Tutorial und einige Kleinigkeiten in der Region verbleiben, aber alle
anderen angeschlossenen Gebiete werden im Laufe der Zeit verlegt werden.
Dieser zweite Punkt wird viel Zeit in Anspruch nehmen, ist aber m.E. genauso
noetig wie der erste.

Das war jetzt ganz schoen lang, aber ich wollte euch nicht vor vollendete
Tatsachen stellen, ohne zumindest grob die Hintergruende mit darzustellen.

Gruss, Arathorn.

-----------------------------------------------------------------------------



