Llystrathe (Silvana,  8. Mar 1996, 08:35:04):
Hi.
Nochmal eine Kleinigkeit zu Llystrathe: Ich hab ihre Einschaetzung Eurer
mangelnden Faehigkeit etwas weiter unterteilt. Man sollte jetzt schneller
ein paar Fortschritte sehen (was nicht heisst, dass es auch schneller geht).

  Silvana

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



Ein Zauberer beim Ueben (Li,  8. Mar 1996, 11:55:59):

Tja, da untersucht man einen uebenden Zauberer, und was sieht man: man
bekommt bestaetigt, dass Zauberer doch Lichtwesen sind! :-)

unt snuggle

Das ist Snuggle. Er ist relativ gross, wenn auch nur fuer einen Zwerg.
Du siehst vor Dir einen kleinen Zwerg mit Rauschebart und Knubbelnase.
Im Moment guckt er freundlich, aber er sieht so aus, als wenn man ihn besser
nicht aergert, sonst kann er naemlich ziemlich unangenehm werden.
Wenn Du genau hinschaust, kannst Du ueber seinem Kopf ein schwaches Leuchten
erkennen, wie von einem Heiligenschein.
Er grinst Dich freundlich an.
Er ist absolut fit.
Eben haettest Du es beinah uebersehen. In seiner Hand traegt er eine gelbe
Rose mit sich herum, auf die er eifersuechtig achtgibt. Du solltest nicht
versuchen, sie ihm wegzunehmen, denn sie ist das Verlobungsgeschenk von
Pauline.
Er guckt ein bisschen geknickt aus der Waesche, da seine Pauline zur Zeit nur
sehr selten hier sein kann. Vielleicht kannst Du ihn ja etwas aufheitern.

Er ist Freund von Castaway, Aline, Ulo, Xera, Sasa, Hanni, Fyt, Horax,
Brummel, Caradhras, Ardana, Zephyr, Alboin, Morgon, Semira, Slyfox, Etain,
Flintnail, Tasha, Azzuro, Brit, Creative, Lamuerte, Yety, Tonya, Pauline und
Papalangi.
Snuggle hat keine Ruestung an, keine Waffe gezueckt und traegt eine
Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine
Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine
Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine
Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine
Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine
Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine Lichtkugel, eine
Lichtkugel und ein Freundschaftsband.

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



Re: Ein Zauberer beim Ueben (Tzuiop,  8. Mar 1996, 13:26:41):
~#! rn=Li rt=826282559
~#! tid=826282559
Keine Ruestung, keine Waffe, massenhaft Lichtkugeln ? Ich wuerde sagen,
so sieht ein Armleuchter aus !
(Sorry Snuggle, couldn't resist :))

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



FAQ (Li,  8. Mar 1996, 14:12:32):
Ok, es gibt nun in der Bibliothek eine schnell zusammengewurtelte, bestimmte
unvollstaendige FAQ-Liste.
Fragen, die noch reinsollten, per mail an mich.
bugs und typos -> /dev/null :-)

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



schutz (Silvana, 11. Mar 1996, 08:30:46):
Hi.
Beim Schutz-Spruch wird jetzt angezeigt, wessen Aura sich aufloest.

  Silvana

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



stufen (Laila, 11. Mar 1996, 19:14:23):
Hi

waere vielleicht jemand so nett, (jemand der den totalen Ueberblick hat :) )
mal alle stufen die man durchlaeft also so von schlecht bis
hypergalaktischsupergut mal tabellarisch aufzuschreiben und hier zu posten.
Dann koennte man sich mal so richtig einschaetzen und sieht, wieviel man noch
vor sich hat.

Mit untertaenigsten Dank schon mal im vorraus

Laila

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



Re: stufen (Silvana, 12. Mar 1996, 08:44:10):
~#! rn=Laila rt=826568063
~#! tid=826568063
Auch wenn's schon fast Spielerhilfe ist, werd ich das mal beantworten:
"unaussprechbar uebel"
"miserabelst"
"miserabel schlecht"
"reichlich schlecht"
"ziemlich schlecht"
"schlecht"
"ungenuegend"
"sehr mangelhaft"
"mangelhaft"
"mit Mueh und Not ausreichend"
"nur knapp ausreichend"
"ausreichend"
"gut ausreichend"
"schon fast befriedigend"
"befriedigend"
"sehr befriedigend"
"ziemlich gut"
"wirklich gut"
"sehr gut"
"aussergewoehnlich gut"
In dieser Reihenfolge, aber alles andere als linear.

  Hope this helps - Silvana

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



Re: Re: stufen (Laila, 12. Mar 1996, 10:24:33):
~#! rn=Silvana rt=826616650
~#! tid=826568063
Meinen untertaenigsten Dank und Wuensche auf ein langes und glueckliches
Zauberer-Dasein

Dankend
Mit vielen Verbeugungen
Einen Super-Knuddler schenkend

Laila, die Dankende

;->

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



Anfaenger und *wahre Anfaenger* :) (Hardil, 12. Mar 1996, 11:31:52):

> Durian sagt: Ist wirklich rasend spannend, Dir beim Ueben zuzuschauen!
Du konzentrierst Dich.
Eine strahlend helle Kugel erscheint aus dem Nichts.
Du breitest Deine Haende aus und sagst: SCHUTZ!
Der Zauberspruch ist missglueckt.
Du lernst aus Deinem Fehler.
> Durian sagt: Ziemlich hell hier :-)
Durian breitet seine Haende aus und sagt: SAND!
> Es beginnt Sand zu regnen ...

Also so einen fumble beim Schutz-Zauber hab ich auch noch NIE gesehen. :-)

-Hardil. Hat sich gerade vom Lachanfall erholt.

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



Re: Anfaenger und *wahre Anfaenger* :) (Aline, 12. Mar 1996, 11:34:30):
~#! rn=Hardil rt=826626712
~#! tid=826626712
*kicher*

Hmm suchte Silvana nicht letztens noch Sachen die passieren koennten
wenn ein Spruch mal schief geht? ;)

Aline

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



Re: Re: Anfaenger und *wahre Anfaenger* :) (Durian, 12. Mar 1996, 11:42:36):
~#! rn=Aline rt=826626870
~#! tid=826626712
Wieso ist der Spruch schief gegangen? Hat doch prima geklappt!

im Sand buddellnd

- Durian

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



Re^3: Anfaenger und *wahre Anfaenger* :) (Hardil, 12. Mar 1996, 11:44:50):
~#! rn=Durian rt=826627356
~#! tid=826626712

Na dann, Durian, dann warte ich mal auf den neuen Zweig der Zauderergilde,
die sich nur mit Sand-Spruechen befasst. Beschwoerung von Sandfloehen,
Sandsturm, Sandmann... wird sicher spannend. :)

-Hardil. :) Freut sich, dass andere Wuestenmagier hier mit Waldmagiern
zusammenarbeiten wollen. :)

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



Re^4: Anfaenger und *wahre Anfaenger* :) (Hardil, 12. Mar 1996, 11:50:10):
~#! rn=Hardil rt=826627490
~#! tid=826626712

Wenn Magier Spielerhilfe machen, klappts schon VIEL besser:

Hardil breitet seine Haende aus und sagt: SAND!
Du sagst: klappt nicht
Durian sagt: Klar!
Durian breitet seine Haende aus und sagt: SAND!
Hardil breitet seine Haende aus und sagt: SAND!
> Es beginnt Sand zu regnen ...
Es beginnt Sand zu regnen ...

Ha! So solls sein! Ob das einen Bonus fuer Cast gibt?

-Hardil. Wird Erzmagister der Wuestenzweigs.

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



Lhana di Leondro (Silvana, 14. Mar 1996, 10:44:57):
Hi.
Ich habe Lhana di Leondro etwas geschenkt, das auch fuer Zauberer sehr
interessant sein koennte - allerdings auch ziemlich gefaehrlich. Ihr
koennt es Euch ja mal ansehen...

Have Fun - Silvana

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



FAQ-Update (Li, 14. Mar 1996, 11:25:29):
es gibt jetzt in der bib eine neue Ausgabe der FAQ. Sie ist nicht nur
inhaltlich etwas groesser geworden, ich hoffe auch Typos und Formatierkfehler
sind weniger geworden...

Li

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



Ich kann es!!!! (Aline, 14. Mar 1996, 15:51:06):
Eben passiert:

licht
Du konzentrierst Dich.
Eine strahlend helle Kugel erscheint aus dem Nichts.
Lhana di Leondro erscheint in einer Rauchwolke.
Lhana di Leondro sieht etwas benommen aus.

Tja was ich alles so kann! Besoffene Blumenverkaeuferinnen herzaubern:)

Aline

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



Re: FAQ-Update (Terrorist, 14. Mar 1996, 16:17:45):
~#! rn=Li rt=826799129
~#! tid=826799129
Was issen das bib?
ich kenn das irgendwie anders :)

Terrorist ist naehmlich am bib

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



Re: Re: FAQ-Update (Hardil, 14. Mar 1996, 16:18:17):
~#! rn=Terrorist rt=826816665
~#! tid=826799129

Wer naemlich mit 'h' schreibt ist daemlich.

-Konrad Duden. :-)

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



Re^3: FAQ-Update (Terrorist, 14. Mar 1996, 16:19:54):
~#! rn=Hardil rt=826816697
~#! tid=826799129

Wer issen Konrad Duden? Ist der auch daemlich?
:)
Terrorist schreibt trotzdem naemlich mit h

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



BUG im Zauberstab (Paracelsus, 16. Mar 1996, 22:00:22):
Hi Zauberer.
Leider gibt es derzeit im Zauberstab einen Bug, der verhindert, dass der
Zauberstab gecloned werden kann.
Die Ursache liegt in einer Aenderung im Waffen- und Ruestungssystem, die
im Zauberstab noch nicht nachvollzogen wurde.
Daher kann es passieren, dass Zauberer, die die Lehrlingspruefung bereits
haben, nach dem Einloggen keinen Zauberstab mehr besitzen.
Wer seinen Stab wiederhaben will, wende sich an mich oder Silvana. Wer
problemlos ein-zwei Tage ohne Stab aushalten kann, wartet am besten, bis
naechste Woche Silvana wieder da ist.
Bei all denen, die von mir einen ersatz-Zauberstab erhalten haben, muss
dieser dann naemlich wieder gegen das Original ausgetauscht werden.

Paracelsus.

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



Re: BUG im Zauberstab (Paracelsus, 16. Mar 1996, 22:05:27):
~#! rn=Paracelsus rt=827010022
~#! tid=827010022
Damit ich nicht missverstanden werde:
Die "Ersatz-Version" des Zauberstabes ist natuerlich in jeder Hinsicht
ein vollwertiger Ersatz, ihr solltet dadurch keine Nachteile
bekommen.

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



Zauberstab (Silvana, 20. Mar 1996, 08:17:55):
Hi.
Ohne gelesen zu haben, was sonst noch los war: Am Freitag (nachdem ich
gegangen war) hat Wargon etwas an der std-Waffe veraendert, das dazu
fuehrte, dass sich der Zauberstab nicht mehr laden lies. Das hatte
wiederum zur Folge, dass die Lehrlingspruefung nicht mehr abzuschliessen
war. Der Bug ist jetzt behoben. Diejenigen, die den von Paracelsus
geschaffenen Ersatz-Zauberstab noch haben, koennen den bei Paracelsus, Li
oder mir umtauschen. (Lasst mir noch ne Stunde - muss mail lesen. ;-) )

  Silvana

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



Statistik (Hardil, 20. Mar 1996, 11:54:07):

Wenn ich schon mitzaehle...

Also, um im Cast von Ungenuegend auf Sehr mangelhaft zu kommen, war folgendes
bei mir noetig:

585mal Werte (davon 28 misslungen)
 22mal Licht (1mal)
 3mal hand (3mal)

und evtl noch ein halbes Dutzend sonstiges, das ich nciht mitgeschrieben
habe. Grob geschaetzt also knapp 600 geklappte Zauber. Gibt es sonst noch
Erfahrungswerte?

-Hardil. RL-Statistiker.

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



Statistik, die 2te (Hardil, 20. Mar 1996, 14:33:44):

Okee, fuehren wir die Statistik weiter:

vom Cast Sehr Mangelhaft auf Mangelhaft benoetigte ich:

324 Lichtsprueche, davon 11 misslungen
 15mal Sand, davon 0 misslungen.

Laut Aline sinds von Mangelhaft bis gerade mit Mueh und Not noch ausreichend
auch nur noch 300 SPrueche :-)

-Hardil. Derzeit leuchtend wie ein Pilz aus Russland.

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



Sprueche (Silvana, 20. Mar 1996, 16:33:51):
Hi.
Ich habe ein paar Kleinigkeiten in der Abstimmung der Sprueche geaendert.
Sollte nicht so masslos auffallen. ;-) Ausserdem gibt es zu 'schutzhuelle'
jetzt auch eine ordentliche End-Meldung.

  Silvana

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



Statistik Teil 3 (Hardil, 20. Mar 1996, 16:45:07):
So. Damit auch diejenigen, die wie ich auf Level 32 rumkrebs(t)en, wissen,
wie lange es dauert, bis man weiter hochkommt:

fuer den Sprung auf "mit Mueh und Not ausreichend" brauchte ich
 664 Licht (davon 9 misslungen)
 60 Werte (davon 1 kaputt)
ein paarmal schutz, stimme und sand.
War also doch eine groesser Muehe als angenommen.

-Hardil. Hat jetzt erstmal genug. :)

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



Flammende Hand (Silvana, 28. Mar 1996, 07:57:46):
Eine kleine Aenderung beim Spruch 'hand':
Der angerichtete Schaden ist jetzt proportional zur Zahl der zur Verfuegung
stehenden Haende. Also: keine Haenden - kein Schaden, viele Haende -
viel Schaden.
  Have fun - Silvana

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



Dringender Aufruf (Silvana, 28. Mar 1996, 09:46:34):
Da es ja jetzt den ersten Magister in der Zauberer-Gilde gibt, stellt sich
ein grosses Problem: Nicht alle Komponenten fuer Magister und Erzmagister
sind in ausreichender Zahl im Mud versteckt. Uns fehlen noch Ideen, wo
man diverse Komponenten unterbringen kann. BITTE mailt uns ideen, wo
wir diese unterbringen koennen, denn verkaufen wollen wir die eigentlich
nicht. Derzeit duerfte es aber zu DERBEN Engpaessen in der Versorgung
mit Komponenten kommen.

  Silvana

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



Rueste (Silvana, 28. Mar 1996, 16:55:18):
Ich habe keine Ahnung wieso, aber in den Rueste-Spruch hat sich ein Bug
eingeschlichen, den ich beim besten Willen nicht finde. Da er mit den
neuen closures in /std/armour/combat zusammenhaengt, denke ich das Wargons
neuste Ruestungs-aenderung schuld ist. Ist aber nicht sicher. Jedenfalls
werdet ihr vorlaeufig ohne den Rueste-Spruch auskommen muessen.

Sorry - Silvana

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



Angriffszauber (Gando, 29. Mar 1996, 12:24:22):
Halloechen
Waere es vielleicht nicht angebracht, wenn man in der Gilde einen Raum
einrichtet, indem man angriffszauber (wie ja z.Bsp. Hand) ueben
kann, ohne dabei irgendwelche kleinen harmlosen tierchen angreifen zu
muessen.
Der allgemeine Charakter leidet ja schliesslich schwer, wenn man die ganze
Zeit nut niedliche Hase und Schafe um die Ecke bringt.
Ich denke, es waere deshalb ganz nuetzlich, wenn man einen Uebungsraum fuer
Angriffszauber einrichtet, in dem man ohne
im Angriffsmodus zu sein z.Bsp. seinen Hand zauber ueben kann.
Waere nett, wenn sich mal jemand zu diesem Vorschlag aeussert..
Tschoe
Gando

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



Re: Rueste (Wargon, 29. Mar 1996, 12:51:44):
~#! rn=Silvana rt=828028518
~#! tid=828028518
Immer auf die Kleinen...
Der Closure-Kram war da auch vorher schon drin (und eben so buggy, es fiel
halt nur nicht auf, weil in der Regel die DefendFunc nicht in nem externen
Objekt steht).
Nichtsdestotrotz war es ein Bug, und der ist nun raus.
  Wargon

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



Re: Angriffszauber (Li, 29. Mar 1996, 13:32:13):
~#! rn=Gando rt=828098662
~#! tid=828098662
nun, in der gilde wirdes keine Uebemonster von userer Seite geben. vieleicht
kannst du ja jemanden, der "bezauberer" kann ueberreden, die was "nettes" dort
hinzustellen.
wir dachten uns jedenfalls, dass man die Sprueche wie Hand draussen, im Mg
lernt. Und wenn Du dir Sorgen um Deine Gesinnung machst: Bald wierst du auch
wieder Orks plaetten koennen!. Du musst halt versuchen "boese" Ameisen und
haeschen zu suchen! (Okok, ich geb zu das wird etwas schwierieg)
Li

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



Re: Re: Angriffszauber (Morgoth, 29. Mar 1996, 13:33:09):
~#! rn=Li rt=828102733
~#! tid=828098662
hey li, meine orks sind nicht boese
morgoth (entruestet)

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



Re^3: Angriffszauber (Li, 29. Mar 1996, 13:37:14):
~#! rn=Morgoth rt=828102789
~#! tid=828098662
Aeh sorry, Deine natuerlich nicht!
Li
(entschuldigungliebermorgothaberichhabdeineorkseinfachunterdentischfallengelassenverzeihmitbitte!!!)

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



Re^3: Angriffszauber (Bendeigid, 29. Mar 1996, 13:48:20):
~#! rn=Morgoth rt=828102789
~#! tid=828098662
Das ist definitiv ein Bug, Morgoth!

Bendeigid, grinsend

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



Re^4: Angriffszauber (Hardil, 29. Mar 1996, 18:29:40):
~#! rn=Bendeigid rt=828103700
~#! tid=828098662

Alle Orks sind boese.

Die drei Orktoeter von der Tankstelle.

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



Re^5: Angriffszauber (Orktoeter, 29. Mar 1996, 18:34:33):
~#! rn=Hardil rt=828120580
~#! tid=828098662
Sorry, Exhaeuptling, aber auf Orktoeter habe ich ein Exklusivrecht ! :)
OrkT.

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



Re^6: Angriffszauber (Hardil, 29. Mar 1996, 18:36:35):
~#! rn=Orktoeter rt=828120873
~#! tid=828098662

Also OrkT, aber DIch sehe ich NIE im Orktunnel. Bist Du denn Freund vom
Echsenkoenig? Der ist unser bester Verbuendeter im Kampf gegen die Orks.

Einer von der Tankstelle

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



rueste# (Helloween, 30. Mar 1996, 03:01:29):
waere nett wenn man es so einrichten koennte das der teleport spruch auch
ohne rueste gut zu koennen gelernt werden kann da mir der teleport spruch als
letzter der stufe 8 sprueche noch fehlt und ich so leider nich vorwaerts komme
da ich stehts die auskunft erhalte du musst dich in rueste noch ueben um
teleport zu lernen (geht aber leider nicht !!) :(

cu
   DAS

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



Re: Angriffszauber (Silvana,  2. Apr 1996, 10:12:32):
~#! rn=Gando rt=828098662
~#! tid=828098662
Hi, Gando
Angriffszauber sind nun mal zum angreifen da. Die Gefahr dabei sind die
Gegner - und das will ich eigentlich nicht abblocken. Also: KEIN Uebungs-
raum mit Monster.

  Silvana

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



Re: Re: Rueste (Silvana,  2. Apr 1996, 10:14:52):
~#! rn=Wargon rt=828100304
~#! tid=828028518
... und dementsprechend geht auch der Spruch wieder.

  Silvana

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



Neues von Llystrathe (Silvana,  4. Apr 1996, 09:41:21):
Zwei kleine Aenderungen bei Llystrathe:
1) Man kann sie jetzt alles aus der Ferne fragen, was man sonst aus
   der Naehe fragen konnte (was auch immer noch geht). Syntax:
   teile llystrathe mit <text>

2) Sollte jemand (wie auch immer) seinen Zauberstab verlieren, reicht es,
   Llystrathe danach zu fragen. Sie haendigt einem dann einen neuen aus.

Have Fun - Silvana

PS: zu 2): Auch das geht aus der Ferne.

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



Re: Neues von Llystrathe (Silvana,  4. Apr 1996, 09:44:34):
~#! rn=Silvana rt=828603681
~#! tid=828603681
Ach, ja. Was sich noch sagen wollte: Llystrathe antwortet nur
Gildenmitgliedern.

  Silvana

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



Hallo Zauberer! (Paracelsus,  4. Apr 1996, 17:20:27):
Hi Zauberer.
Es wird euch sicher freuen, dass es jetzt noch einen weiteren Weg in die
Zauberergilde gibt. Finden muesst ihr den natuerlich wieder selbst.

Paracelsus, der sich fragt, warum er diesen Artikel schreiben musste.

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



Spendenfreudigkeit (Aline,  9. Apr 1996, 11:23:44):

Lennon laesst 44278 Muenzen fallen.
Lennon breitet seine Haende aus und sagt: SCHUTZ!
Lennon wird von einer blaeulich schimmernden Auran S eingehuellt.
Lennon nimmt 44278 Muenzen.
Die Aura um Lennon verschwindet wieder.
Lennon laesst 44278 Muenzen fallen.

Ist das die spendenfreudigkeit von Zauberern?

Aline *grinsend*

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



Neues von Llystrathe (Eremis, 10. Apr 1996, 17:22:18):
Hi.
Im Auftrag von Silvana soll ich mal eine kleine Neuheit verkuenden:
Man kann Llystrathe jetzt nach den einzelnen Zweigen fragen, also
nach 'angriff', 'abwehr', 'illusionen', 'beherrschung', 'hellsicht' und
'verwandlung' und bekommt dann eine etwas - hmmm... - unuebersichtliche
zusammenstellung gescrollt. Ach, versuchts selbst.

Wegen Armageddon spaeter mehr.

Eremis (im Auftrage von Silvana)

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



Llystrathe (Teil 2) (Eremis, 10. Apr 1996, 17:58:49):
So - jetzt zum 2. Teil:
Llystrathe unterteilt ihre Einschaetzung Eurer Faehigkeiten jetzt noch
genauer. Hier die aktuelle Liste:
unaussprechbar uebel
aeusserst uebel
sehr uebel
miserabelst
aeusserst miserabel
miserabel
noch miserabel
aeusserst schlecht
sehr schlecht
reichlich schlecht
ziemlich schlecht
schlecht
gerade noch schlecht
aeusserst ungenuegend
ungenuegend
aeusserst mangelhaft
sehr mangelhaft
mangelhaft
gerade noch mangelhaft
so gerade eben noch mangelhaft
mit Mueh und Not ausreichend
nur knapp ausreichend
ausreichend
gut ausreichend
schon fast befriedigend
befriedigend
sehr befriedigend
ziemlich gut
wirklich gut
sehr gut
aussergewoehnlich gut

So, das war's - Eremis (im Auftrage Silvanas)

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



Re: Neues von Llystrathe (Eremis, 10. Apr 1996, 18:41:13):
~#! rn=Eremis rt=829149738
~#! tid=829149738
Ach, ja, noch was:
Ich wurde gebeten, noch etwas einzubauen, dass man mit einem Befehl ALLE
gelernten Sprueche mit Einschaetzung abfragen kann. Ich denke, das
duerfte etwas ZU stark scrollen. Bedenket, dass man immerhin ein Maximum
von 57 Spruechen lernen kann (je 2 Zeilen Antwort).

Eremis (fuer Silvana)

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



Feinheit des Stufensystems (Lifafa, 12. Apr 1996, 00:59:59):
Die neu eingefuehrten Stufen, v.a. im Bereich 'ungenuegend' und mangelhaft'
sind ein Schritt in die richtige Richtung. Nichtsdestotrotz muss ich mehr als
2000 erfolgreiche Versuche haben, bevor sich mein 'casting' um eine Stufe
erhoeht. Das mag an meiner begrenzten Intelligenz (INT = 13) und meinem
Menschsein liegen, aber fuer solche Spieler sollte die Zauberergilde ja auch
noch Spass machen. Deshalb, um die Frustrationen mit dem nicht stattfindenden
Fortschritt etwas zu minimieren, die Bitte um eine noch feinere Unterteilung.
Da es ziemlich schwierig sein wird, weitere Begriffe dafuer einzufuehren,
koennte ja eine Anzeige erfolgen: Du bist 10% odert 'ein bisschen' bzw. Du
bist 20% oder 'merkbar' auf dem Weg zur naechsten Stufe vorangekommen. Ich
glaube, es wuerde die Begeisterung bei dem ohnehin oeden Ueben  wesentlich
laenger aufrechterhalten.

                        Lifafa

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



Re: Feinheit des Stufensystems (Ktk, 12. Apr 1996, 17:18:12):
~#! rn=Lifafa rt=829263599
~#! tid=829263599

2000 Versuche nur?

Darf ich mich mal schlapp lachen?

Fyt. Hat mal Karate gelernt.

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



froschen (Rudiratter, 12. Apr 1996, 20:36:43):
Meiner Meinung nach laeuft hier etwas schief im MG mit den Gilden, niicht nur
wegen meiner Verfroschung vor ein paar Minuten, das habe ich auch schon vorher
bemaengelt.
Keine andere Gilde hat so einen maechtigen Spruch gegen einen Spieler einer
anderen Gilde wie die Zauberer mit dem Verfroschen -und mir reicht's echt
langsam. Wenn man sich in keiner Weise wehren kann, kann das nur zu
Missstimmung hier im MG laufen.
Ich fordere deshalb eine Abschaffung des Froschzaubers, andere Sachen sollten
auch mal ueberdacht werden.
MICH nervt die Zauberergilde von Tag zu Tag mehr und ich habe nciht viele
Moeglichkeiten, dem aus dem Weg zu gehen ausser gar nicht mehr hier zu
erscheinen -und das ist ja wohl nicht der Sinn der Sache.
Rudi

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



Re: froschen (Asmodis, 12. Apr 1996, 20:42:49):
~#! rn=Rudiratter rt=829334203
~#! tid=829334203
Du bist nur verfroscht worden, weil du vorher lautstark ueber die
Zauberergilde gemoserst hast ueber die Kanaele.

Da kann ich nur sagen: SELBST SCHULD !!

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



Kneipe (Gando, 15. Apr 1996, 12:21:46):

Ich finde, man sollte in unserer Zauberer-Kneipe wenigstens ein alkoholisches
Getraenk anbieten. Auch als Zauberer hat man dann und wann das Beduerfnis,
sich zu besaufen, oder einfachnur mal einen zu heben.
Dieses Grundrecht des besaufens wurde aus unserer Kneipe ja nun komplett
verbannt. Vielleicht gibts ja demnaechst ein Flens oder wat
anderes mit Alk drin. :-)
Tschoe Gando

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



Was neues! (Paracelsus, 15. Apr 1996, 12:29:13):
Hiho!
So, fuer die Erzmagister unter den Zauberern gibts was neues, wo ihr euch
draufstuerzen koennt, einen netten, kleinen Zauberer-NPC.

Paracelsus.

P.S.: Kleiner Tip: er ist NICHT in meinem Gebiet zu finden ];-)

P.P.S.: Froehliches Suchen!

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



Re: Kneipe (Li, 15. Apr 1996, 13:24:48):
~#! rn=Gando rt=829563706
~#! tid=829563706
koennt ihr gerne haben, aber bei Bir gibtskein Flens...

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



Komponenten (Li, 15. Apr 1996, 14:15:07):
die komponenten haben zusaetzliche IDs: (zauber-)komponente/n bzw.
(zauber-)zutat/en. ausserdem kann man schiefer und granit mit stueck/e
ansprechen.
Li

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



gilden.zauberer Schattenkaempfer (Catweazle, 16. Apr 1996, 09:42:50):
[Verlegt von allgemeines, Lefty, 14. Apr 1996, 13:01:08]:
Huhu ihr anderen Zauberer,

da es momentan die anderen gilden ziemlich nervt, das ueberall solche
schatten rumliegen (was ich auch durchaus verstaendlich finde) folgende
idee: wie waere es, das schatten nur von zauberern oder dem betreffenden
zauberer gesehen werden ? das ist bestimmt machbar, ausserdem liegen
dann nicht ueberall escubars und andere rum ;-) *grins escubar*

ciao, Lefty


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



Re^3: gilden.zauberer Schattenkaempfer (Catweazle, 16. Apr 1996, 09:45:02):
~#! rn=Arty rt=829521152
~#! tid=829479668
[Verlegt von allgemeines, Laurin, 15. Apr 1996, 12:20:01]:
Naja, ARTY ist auch schon auf einen Schatten von mir reingefallen
und wunderte sich wohl, warum er nicht
antwortet :)


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



Re^4: gilden.zauberer Schattenkaempfer (Catweazle, 16. Apr 1996, 09:45:08):
~#! rn=Laurin rt=829563601
~#! tid=829479668
[Verlegt von allgemeines, Arty, 15. Apr 1996, 12:28:08]:
Jo, das fand ich aber nich schlimm, sondern eher lustig :)

ARTY grinst Laurin ( und seine Schatten ) an.


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



Re^5: gilden.zauberer Schattenkaempfer (Catweazle, 16. Apr 1996, 09:45:21):
~#! rn=Arty rt=829564088
~#! tid=829479668
[Verlegt von allgemeines, Anatol, 15. Apr 1996, 12:48:46]:

Vielleicht sollten die Zauberer den "schattenkaempfer"-Spell erst dann casten
koennen, wenn der vorhergehende Schatten (ggf. mit "beende") zerstoert ist.

Anatol



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



Re: Re: gilden.zauberer Schattenkaempfer (Catweazle, 16. Apr 1996, 09:46:49):
~#! rn=Zuerileu rt=829521082
~#! tid=829479668
[Verlegt von allgemeines, Lefty, 15. Apr 1996, 18:23:52]:
Mann Zueri, ich habe doch nix gegen die Schatten an sich. Aber ueberlege doch
mal, wenn 10 zauberer ein Monster metzeln und jeder seinen Schatten da
hinlegt. Ich habe nur 24 zeilen und moechte auch nochwas anderes sehen als 10
schatten in der raumbeschreibung, so dass ich fuer die raumbeschreibung
nochmal zurueckscrollen muss.

Lefty


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



Re^3: gilden.zauberer Schattenkaempfer (Catweazle, 16. Apr 1996, 09:47:44):
~#! rn=Lefty rt=829585432
~#! tid=829479668
[Verlegt von allgemeines, Zuerileu, 16. Apr 1996, 00:21:17]:
Hallo Lefty,
Das gleiche musst du wenn viel gruebel rumliegt oder wenn 10 Spieler im Raum
stehen. Besonders wenns sie solche Titel wie Caradras und seine zweitis haben.
Und wenn dann musst du halt wohl zurueck scrollen, ich glaub sowas ist in
einem Mud normal.

tschuess Zuerileu


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



Re: gilden.zauberer Schattenkaempfer (Catweazle, 16. Apr 1996, 09:48:21):
~#! rn=Lefty rt=829479668
~#! tid=829479668
[Verlegt von entwicklung, Catweazle, 16. Apr 1996, 09:44:11]:
[Verlegt von allgemeines, Zuerileu, 15. Apr 1996, 00:31:22]:
hall,
ich kanns nicvht verstehen wie jemand eine kleinigkeit wie den schatten
aufregen kann. Hey wenn einer nicht antwortet dann laeuft doch einfach weiter
und laesst die Dinger stehen. Ich meine man muss ja nicht jedes Ding
anquatschen und dazu warum sollte man es ersichtlich machen das dies nun kein
spieler ist. Ich meine warum muss hier alles zu verdammt tot ernst sein ?

tschuess Zuerileu (jaja ich weiss ich geb ueberall meinen senf dazu, aber ich
                   zwing keinen diesen artikel zu lesen )



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



Re: Re: gilden.zauberer Schattenkaempfer (Catweazle, 16. Apr 1996, 09:48:23):
~#! rn=Zuerileu rt=829521082
~#! tid=829479668
[Verlegt von entwicklung, Catweazle, 16. Apr 1996, 09:44:25]:
[Verlegt von allgemeines, Arty, 15. Apr 1996, 00:32:32]:
ich bin auch dagegen das sichtbar zu machen.
schliesslich ist das ja auch gerade ein vorteil der schatten, das man idlende
anwesenheit vortaeuschen kann :-)
wens stoert der soll sich eben ein ali auf 'unt schatten' machen, dann ist es
ja leicht zu merken ob es einer ist.

  ARTY



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



aehem (Catweazle, 16. Apr 1996, 09:51:02):

Aeh, sorry, ich hab glaub ich die Reihenfolge etwas durcheinander
gebracht.
Yours truly,
        Catweazle (Stuemper)

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



llyst (Gando, 17. Apr 1996, 12:10:39):
Hi an alle Zauberer, die Llystrathe auch verachten ...
Es ist ja schon uebel genug, wenn man Verwolgungswahn hat und sich nicht mehr
selbst vernuenftig kontrollieren kann. Aber wenn man dann noch auf dem Weg

zu einem sicheren Raum (z.Bsp. Kneipe oder UE-Raum) Llystrathe nix besseres
einfaellt, als einen mal eben kurzerhand zu plaetten, faellt mir dazu nix
mehr ein.
Fand ich je mal echt uebel :-(
Tschoe Gando

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



Re: llyst (Morgoth, 17. Apr 1996, 12:56:47):
~#! rn=Gando rt=829735839
~#! tid=829735839
ich hab mich damals in meinem wahn mit funakoshi angelegt....war auch nicht
anders..

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



Re: Re: llyst (Asmodis, 17. Apr 1996, 17:12:49):
~#! rn=Morgoth rt=829738607
~#! tid=829735839
Dass die Zauberergilde ziemlich toedlich ist, haette dir schon frueher
auffallen koennen. Ausserdem gehoert das angreifen von npcs zum
Verfolgungswahn dazu, selbst schuld, wenn du dich da bei llystrathe
aufhaeltst.

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



Lernen (Gando, 17. Apr 1996, 17:43:22):
Halloe.. Ich bins wieder
Aus welchem Grund lernt man beim Zauberstab nicht, wenn die Beschwoerung

(oder wie ihr es nennen wollt) schiefgeht, so wie bei einem anderen
Zauberspruch.
Immerhin ist es doch auch irgendwo ein Fehler und ich sollte danach wissen,
was ich falsch gemacht habe.
Und bei der riesigen Aufladrate des Zauberstab dauert es ja sowieso ewig,
bevor man ihn nur als Gehhilfe benutzen kann.
Und selbst auf die Gafahr hin, dass es nicht viel bringt (wenn man aus dem
Fehler lernt), so ist doch wenigstens ein besserer
Ansporn dadurch gegeben, wenn man sieht, das es Fortschritte macht. Es kommt
so oft genug vor, dass man die gesamten Spellpoints
verprasst, nix passiert ist und man nix gelernt hat. SUPER.
Wenn es einen Grund fuer diese Regelung geben sollte, dann moechte ich den
gerne Wissen.
(Dann mag ich es auch gerne einsehen:-)
Tschoe
Gando

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



Re: Lernen (Asmodis, 17. Apr 1996, 18:16:41):
~#! rn=Gando rt=829755802
~#! tid=829755802
Beim Zauberstab lernst du (als Lehrling) in der Regel, wenn der
stabschaden gelingt. Das sollte doch ausreichen. Auch noch zu
lernen, wenn er nicht gehorcht, waere etwas zuviel, dann haette
man den stabskill ja in nullkommanix aufgebaut.

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



Neues (Silvana, 18. Apr 1996, 07:59:01):
Hi, Zauberer
Ich stelle heute (u.a. aus Geschwindigkeitsgruenden) so einiges um. Es kann
daher zu ein paar ungewoehnlichen Reaktionen kommen. Z.B. solltet ihr
jetzt alle neue Zauberstaebe haben.... Bis auf 3 Ausnahmen, bei denen das
neuladen nicht geklappt hat. Ausserdem werden derzeit auch Erzmagister-
komponenten und die Lupe bisweilen verbraucht. Das wird noch behoben, dauert
aber nen Moment. Ich bitte daher um etwas Geduld.

  Silvana

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



Re: llyst (Silvana, 18. Apr 1996, 08:02:52):
~#! rn=Gando rt=829735839
~#! tid=829735839
Heh, Moment. Llystrathe greift niemanden von sich aus an!
  Silvana

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



Re: Lernen (Silvana, 18. Apr 1996, 08:05:47):
~#! rn=Gando rt=829755802
~#! tid=829755802
Wenn Du das nochmal so ausdruecken koenntest, dass ich es mit meinem
Ostwestfaehlisch beschraenkten Verstand verstehen kann, antworte ich
Dir auch gerne darauf. Ansonsten kann ich Dich nur auf die FAQ
verweisen...
  Silvana (hat das nicht verstanden)

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



Re: Neues (Silvana, 18. Apr 1996, 08:07:10):
~#! rn=Silvana rt=829807141
~#! tid=829807141
Hmmm - irgendwas laeuft beim automatischen Laden der Staebe schief.
Daher hab ihr jetzt alle keinen Stab mehr. ;-) Also wie ueblich:
Llystrathe fragen, dann bekommt ihr nen neuen.

  Silvana

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



Robe -> Guertel (Silvana, 18. Apr 1996, 08:49:18):
Wie einige schon bemerkt haben, gibt es jetzt statt der alten Roben
Guertel in denen man die Zauberzutaten unterbringen kann (natuerlich in
den daran befindlichen Beuteln). Das hat zwei Gruende: Zum einen ist es
jetzt jedem Zauberer moeglich eine Robe seiner Wahl zu tragen ohne sich
das Inventory zu versauen, zum anderen (und das ist der wesentliche
Grund) ist das Spellbook dadurch schneller geworden (weniger Rechenzeit).

  Silvana

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



Geschenk (Silvana, 18. Apr 1996, 14:27:18):
Ich hab Euch uebrigens ein kleines Geschenk mitgebracht, ueber dass sich
speziell die Magister freuhen werden. Es (er) heisst Phlyaken.

  Viel Spass damit - Silvana

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



Re: Re: Lernen (Gando, 18. Apr 1996, 16:54:51):
~#! rn=Silvana rt=829807547
~#! tid=829755802
Tut mir leid Silvana, aber ich weiss leider nicht, was du mit westfaehlisch
meinst:-(  Ich komme auuserdem aus Koeln/Bonn.
Ich weiss aber erlicht nicht, wieso man das deutsch nicht verstehen soll.
Vielleicht ist es einwenig abgehakt,
das liegt aber eher am editor, da man voriges nicht aendern kann. :-(
Gando

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



Re: froschen (Snuggle, 18. Apr 1996, 18:39:31):
~#! rn=Rudiratter rt=829334203
~#! tid=829334203
Darf ich mal mit der ueblichen Antwort kommen?

Werd doch Zauberer oder geh halt..

heut schlecht gelaunt,
Snuggle

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



Guertel (Nikolaus, 18. Apr 1996, 19:00:33):

hab grad entdeckt, dass man die Zauberkomponenten im Guertel
unterbringen kann ... ungeheuer praktisch :)

Beim zaubern kommt dann aber leider
"Dir fehlen die noetigen Materialien.", das gefaellt mir weniger :(

Der Vorteil des Guertels wird doch komplett wieder aufgehoben wenn
man vor dem zaubern erst alles umraeumen muss.. und das inventory
ist genauso unuebersichtlich wie vorher.... hm, kann doch eigentlich
nur ein bug sein, oder ?!?

gruebelnd
           Nik-olaus

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



Re: Guertel (Nikolaus, 18. Apr 1996, 22:06:06):
~#! rn=Nikolaus rt=829846833
~#! tid=829846833

halt es geht doch...

man muss den guertel aber vorher anziehen und
das geht nur wenn man keinen beutel dabeihat ?!?

sich wundernd
              Detektiv-olaus

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



Gimmicks (Silvana, 19. Apr 1996, 09:34:29):
Hi.
Wie einigen gestern aufgefallen ist, ging alcotest (Zauberstab) nicht.
Das ist jetzt wieder aktiv - und zwar als Gimmick. Also Zugabe kann
man jetzt auch eine Zielperson dafuer angeben. Ausserdem gibt es noch
ein unfertiges Gimmick mit Namen 'fluchtest'. Ihr koennt ja mal nen
bisschen damit expermentieren. Offiziell gibt's das erst, wenn's fertig
ist - dann auch die Dokuseite dazu.

  Silvana

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



Re: Gimmicks (Silvana, 19. Apr 1996, 09:37:11):
~#! rn=Silvana rt=829899269
~#! tid=829899269
Ach ja, nochwas: Froschen haelt jetzt nur noch 2 min (etwa).

  Silvana

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



BUG im Satb (Hardil, 19. Apr 1996, 16:37:00):

Aehm, Typo in der Ueberschrift... sollte Stab heissen.

Also, der Zauberstab ist immer noch buggy. Wenn man seinen kleinen Wolpie
holt, und ihn auf den Arm (ins Inventory) nimmt, wird die ID des Wolp[is als
Besitzer des Zauberstabs gesetzt. Oder so aehnlich.
Jedenfalls klappt dann nix mehr. :-)

-Hardil. Hat so seine liebe Muehe mit den kleinen Viechers :)

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



Skripten und Gilden (Grimmborn, 19. Apr 1996, 16:43:38):
[Verlegt von allgemeines, Legoland, 19. Apr 1996, 15:51:55]:
Also, Kinnings, wundert's Euch, dass hier im MG so viel geskriptet wird? Bis
man auch nur einen Spruch in der zauberergilde einigermassen beherrscht - und
wenn's so was harmloses wie "Licht" ist, kann man mehrere tausend mal zaubern.
= Stundenlanges stupides tastengeklapper. Also, wundert's irgendwen? Mich
nicht. GET A LIFE!
Ein ziemlich verbitterter wohl baldiger Ex-Zauberer


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



Hochebene (Boing, 19. Apr 1996, 18:17:25):
Die Monster der Hochebene koennen jetzt per Zauberspruch vertrieben werden,
Danke an Aurian fuer den Hinweis.
Ausserdem gibt es fuer Aline ein alkoholfreies Waesserchen in der Zwergen-
bar.
  Boing

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



Re: Hochebene (Paracelsus, 19. Apr 1996, 21:18:43):
~#! rn=Boing rt=829930645
~#! tid=829930645
Was denn, nur fuer Aline? Alle anderen muessen beim Alkohol bleiben?
->schmarrn

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



Re: Re: Hochebene (Caradhras, 19. Apr 1996, 21:43:18):
~#! rn=Paracelsus rt=829941523
~#! tid=829930645
Moment, das ist aber gar nicht ausgeglichen, ich beschwer mich
gleich beim zustaendigen ElektroMagier. *grins*

-> schmarrner

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



Re: Skripten und Gilden (Fyt, 20. Apr 1996, 01:34:26):
~#! rn=Grimmborn rt=829925018
~#! tid=829925018

Hm, Grimmborn, ich hab mich noch nie gewundert, dass gescriptet wird :)
Wenn das so geklunge hat, muss ich mich verdrueckt ausgekehrt haben...

Fyt.

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



Re: Re: Skripten und Gilden (Grimmborn, 22. Apr 1996, 09:57:42):
~#! rn=Fyt rt=829956866
~#! tid=829925018

Also, Fyt, nur weil ich einen Artikel verlege bin ich nicht gleich der
Urheber...

Soviel dazu,
            Grimmborn der Atheist

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



Spiegelraum (Li, 24. Apr 1996, 11:03:13):
hi Zauberinnen und Zauberer!
Der spiegelraum ist nicht mehr fuenf- sondern seibeneckig. Er hat lso zwei
neue spiegel hinzubekommen.
Li

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



Re: Spiegelraum (Anatol, 24. Apr 1996, 11:26:32):
~#! rn=Li rt=830336593
~#! tid=830336593

Heisst das, dass man jetzt "betrete heptagramm" tippen muss? :)
Grinst sich was,
Anatol


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



Spiegel (Gando, 24. Apr 1996, 20:28:22):
Halloechen.
Ich fand es ja Super, dass es zwei neue Spiegel bibt. Das voraus.
Warum diese jedoch nocheinmal geaendert worden sind, kann ich beim besten
willen nicht verstehen.
Meiner Meinung nach war grade der Spiegel Richtung PV genau richtig gelegt.
(Nicht unbedingt, weil ich ein Mencsch bin)
In PV sind nun mal viele Einrichtungen, die alle Rassen nutzen sowie der
Hafen. Da waere doch ein Spiegel zum Hafen sprich PV
goldrichtig.
Warum dies nun wieder geaendert wurde ... ich versteh das nicht.
Ebenso find ich es zweifelhaft, wieso man denn nun einen Spiegel fuer die HE
braucht, wo man doch von Taramis aus in wenigen Schritten auch so da ist.
Dieser Spiegel ist ja wohl ueberfluessig. Zumindestens die Richtung.
Vielleicht sollte man sich ueberlegen, ob PV/Gilde oder Hafen nicht doch eine
gute Zielkoordinate fuer einen Spiegel waer.
Und von der aussage, dies waere eine zusaetzlicht Bevorteilung der
Menschen... nunja, wer sich auf sowas stuetzen muss.
Es war ja auch ein Tor zum Elfentor vorhanden und zu Zwergentown ist ja
sicher kein Tor noetig. Ist doch eh um die Ecke.
Vielleicht aendert sich das ja wieder oder nochmal ...
Gando

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



Restriktionen (Silvana, 25. Apr 1996, 07:56:47):
Hi.
Neben ein wenig Kosmetik hat es heute morgen eine Neuerung gegeben, die
speziell die 'tolpatschigen Jungzauberer' freuen wird: Ich habe die
Mindestforderungen fuer den Stufenaufstieg von 3 auf 4 drastisch
zurueckgeschraubt. Entsprechend wird Euch Llystrathe viel freundlichere
Worte sagen. Damit ihr aber nicht meint, Euch wuerde was geschenkt, hab
ich die Anforderungen dann auf den Stufenaufstieg 4->5 verlegt.
Zu verdanken habt ihr das ganze uebrigens einer Anregung von Feyaria
(hoffentlich hab ich das jetzt richtig geschrieben).

Silvana

PS: Wer's noch nicht gemerkt hat: Es geht um den 'Casting-Skill'

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



Re: Spiegel (Raffi, 25. Apr 1996, 12:37:47):
~#! rn=Gando rt=830370502
~#! tid=830370502
Ich bin ja kein Zauberer, abr einen Weg OHNE Robin zu begegnen zur
Zwergenstadt haett ich mir gewuenscht.

Gruss
H.

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



Re: Restriktionen (Feyaria, 25. Apr 1996, 21:52:25):
~#! rn=Silvana rt=830411807
~#! tid=830411807
Da soll mal einer sagen, Magier wuerden Spielervorschlaege nicht ernst
nehmen. Die Idde hab ich zwar am zweiten Tag der Zauberergilde gehabt ( Anfang
Maerz oder so ). Aber immerhin, die Hauptsache ist doch, es kommt irgendwann
:)) .
Vielleicht gibts dann in 2 Monaten mal eine Top-liste der Zauberer.

Feyaria (bald wieder in der Zauberergilde )

PS: An alle Spieler : Setzt ueberall, wo euch was nicht passt, eine idee ab,
irgendwann wirds ein Magier ja doch mal beruecksichtigen !


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



Re: Re: Restriktionen (Anatol, 25. Apr 1996, 21:55:25):
~#! rn=Feyaria rt=830461945
~#! tid=830411807

Feya, "teile llystrathe mit bestenliste" :)


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



Re^3: Restriktionen (Feyaria, 25. Apr 1996, 22:00:36):
~#! rn=Anatol rt=830462125
~#! tid=830411807
Habs grad erfahren, dass es die top-liste seit heute gibt. Hab mir nicht
gedacht, dass meine Ideen jetzt noch schneller erledigt werden :)
Leider geht das nur bei Zauberern :( .

Feyaria ( muss alleine wegen der Top-liste wieder in die Zauberer-Gilde
eintreten :)) )



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



Stabreport (Gando,  3. Mai 1996, 09:54:01):
Halloechen.
Waere es eigentlich moeglich, wenn man dem Stabreport eine Option hinzufuegt
...
Mir ginge es darum, dass man auch einen 1-zeiligen stabreport bekommt, damit
es nicht so arg scrollt.
Im Prinzip ein Satbreport wie der Nibelungen-Teddy, eben nur noch mit
Spellpoints dabei.
Ausserdem kann man ja am Anfang den Autokampf eh nicht nutzen. Warum soll er
mir dann staendig alles vollscrollen .
Es reicht ja, wenn man irgendwie <stabreport 1> unt <stabreport 2) macht.
oder eben irgendein anderes Options-System
z.Bsp. voreingeste;;t, wie die benutzten autokampf-Sprueche.
Tschoe .. Gando

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



Re: Stabreport (Nikolaus,  3. Mai 1996, 23:17:10):
~#! rn=Gando rt=831110041
~#! tid=831110041
jaaa... gute Idee :)

der Stabreport wuerde, auch mit allen infos, problemlos
in eine Zeile passen. hm... ich versuch mal :

LP xxx MP xxx SM xxx   flamm   extra   wille   schutz

und die eingeschalteten Sachen am besten invers oder fett
damit es auch die TF /verweigerer% schnell sehen was ein ist :)

gruss
      Zaub^H^H^H^HNikolaus

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



Re: Re: Stabreport (Snuggle,  7. Mai 1996, 10:25:32):
~#! rn=Nikolaus rt=831158230
~#! tid=831110041
Also mein Stabreport passt auf eine Zeile, sogar auf eine halbe:
  75  -- - ------    188  202

Die Zahlen sind Stabmagie, LP, MP. Wenn ich weiss, was wo steht, brauch ich
weder die Angabe, um welche Zahl es sich handelt, noch das jeweilige Maximum.
Beides kenne ich im Regelfall.

Die ersten beiden Striche sind fuer Xtrahand und Wille, die letzten fuer nen
Schutzzauber (da steht dann HUELLE oder SCHUTZ).
Passt in weniger als ne halbe Zeile und (zugegeben nur was fuer TFler) ist
zur Erkennung noch lila eingefaerbt.


Ich hab das Macro nicht programmiert, braucht also niemand nachzufragen, ob
ichs weitergeben kann. Ich benutz es nur. Aber ich denke, die Information
laesst sich auch standardmaessig von Mudseite her so oder aehnlich
formatieren.

YT Snuggle

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



Re^3: Stabreport (Silvana, 12. Mai 1996, 11:04:15):
~#! rn=Snuggle rt=831457532
~#! tid=831110041
Ich hatte irgendwann mal ueberlegt, die Meldung frei formatierbar zu
machen, aber das duerfte wegen der staendigen Formatiererei zu viel
Lag machen. ;( Ich mach mir aber mal Gedanken ueber ein 'stabreport kurz'.
Aber nicht alles auf einmal - etwas Geduld bitte.

  Silvana

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



Re^3: Stabreport (Dhojakt, 12. Mai 1996, 16:43:22):
~#! rn=Snuggle rt=831457532
~#! tid=831110041
Falls wer Interesse hat, eine aehnliche einzeilige Stabreportwandlung fuer tf
kann bei mir bezogen werden, sprecht mich einfach mal an. Und da das mein
eigenes Werk ist, muss ich da auch niemand fragen :)
Khidar, bzw. auch Dhojakt/Nok.

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



hand (Silvana, 13. Mai 1996, 09:01:37):
Hi.
Ich habe eben den 'hand'-Zaubere etwas ueberarbeitet. Aufgrund eines
Versehens meinerseite machte man bisher nur Feuerschaden damit - jetzt
ist es Feuer UND Schlag-schaden. Da gegen letzteres Ruestungen helfen,
ist der Spruch _etwas_ schwaecher geworden. Zum Ausgleich hab ich die
Staerke des Angriffs etwas erhoeht. Ausserdem hab ich ein paar
Berechnungen verschoben, so dass der Spruch zwar beim Sprechen langsamer,
aber in der Kampfrunde schneller ist -> weniger Lag - ich hoffe es bringt
nen bischen was.
Ach, noch was: Zauber-NPCs koennen ihr Angriffsmeldung beim 'hand'-Zauber
frei einstellen. Ein (Zauberer)-Hirsch koennte also dann mit brennendem
Geweih angreifen, oder so. How? Siehe Docu zu Paracelsus' Wiz-Npc.

  Silvana

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



*schnueff* (Gando, 17. Mai 1996, 09:23:36):
So .. ich bin dann weg aus der Gilde ..
tut mir schon irgendwie leid. Ich bin normalerweise in jedem FantasySpiel
ein Zauberer gewesen ... aber dieses stupide dauerueben war auf die dauer nix
fuer mich .
man will ja schliesslich nebenbei auch nich ein wenig mudden.
naja .. vielleicht ist das ja auch nur geschmackssache.
Tschoe dann Kinners und uebt schoien
vor allem wo ich hoetrte, was man ueben muss, um Magister zu werden :-(((

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



Aha! (Aline, 24. Mai 1996, 09:15:38):

Hi Zauberer,

hier ein kleines Log fuer alle die, die sich wie ich schon immer
gewundert haben warum der Werwolf aus dem Uebungsraum verschwindet:

Ramborolle rematerialisiert sich vor deinen Augen.
Ramborolle schleudert eine Silberkugel gegen den Werwolf.
Der Werwolf bruellt Dich ein letztes mal an.
schau
Der Uebungsraum  der Akademie ist ziemlich schmucklos, aber doch protzig
eingerichtet. Der gesamte Raum ist mit feinstem, gruengeaederten Marmor
ausgelegt. Nur ein paar Flecken stoeren den harmonischen Allgemeineindruck.
Es gibt einen sichtbaren Ausgang: westen.
Die Leiche eines Werwolfs.
[Anti-SP-Club:] (noch) Bierschuettmeister Ramborolle DER INFRA SOCCER MAN.
Ein Hase.
Ramborolle beamt nach Westen.
Ramborolle rematerialisiert sich vor deinen Augen.
Ramborolle nimmt eine Silberkugel.
Ramborolle beamt nach Westen.

Aline (braucht zwar seit sie Schattenkaempfer hat den Wolf nicht mehr,
findet dieses Verhalten aber aeusserst merkwuerdig)

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



Re: Aha! (Asmodis, 24. Mai 1996, 17:13:13):
~#! rn=Aline rt=832922138
~#! tid=832922138
Hmm, ich glaube, Ramborolle wird wohl ein beliebtes Ziel zum verfroschen 
werden, wenn er so weitermacht, Ombatisse kann mein Ersti sicher auch
spenden :)

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



Re: Aha! (Lefty, 24. Mai 1996, 17:15:40):
~#! rn=Aline rt=832922138
~#! tid=832922138
aaargh, was soll denn der sch... ? Sabotieren sich die Spieler nun schon
untereinander ? Super gemacht Rambo...

Wenn DU unbedingt das Beduerfnis hast, Werwoelfe zu killen, dann gebe ich Dir
nen paar Muenzen, damit Du Dir die selber kaufen kannst.
Die aus dem Uebungsraum zu entfernen finde ich eine Schweinerei.

Lefty

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



Re: Werwolf (Ramborolle, 28. Mai 1996, 21:27:39):
Hi und sorry, wenn ich den Zauberern Aerger bereitet habe!
Ich wollt eigentlich nur mal austesten, ob man den werwolf in der gilde auch
killen kann.  
Leider wusste ich nicht, dass der nicht wie alle anderen Monster resettet.
Deshalb moechte ich mich hier bei allen Zauberern und Zauberinnen(?) recht
herzlich entschuldigen.
Was ich allerdings ziemlich link finde ist, dass mich keiner darauf
angesprochen hat (z.B. Aline dies ja gesehen hat) sonderen dass unter
Gilden.Zauberer, die ich als Ex-Zauberer logischerweise nie lese ne kleine
Hetzkampange gegen mich gestartet wird.
Haett mich nicht zufaellig Todesengel (Gilde Chaos) darauf angesprochen, haett
ich nie was davon erfahren.
RamboRolle - Rolle reicht.

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



Re: Re: Werwolf (Aline, 29. Mai 1996, 09:04:05):
~#! rn=Ramborolle rt=833311659
~#! tid=833311659
Hallo Ramborolle,

finde ich toll, dass Du Dich entschuldigst. :)

Du hast auch vollkommen recht, wenn Du mir vorwirfst dass ich Dich nicht
darauf angesprochen habe. :(

Dafuer moechte ich mich hiermit bei Dir entschuldigen (mach ich auch
noch per PM, falls Du diese Rubrik nicht liest).


Aline (zerknirscht)

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



Re^3: Werwolf (Yendi,  4. Jun 1996, 15:58:32):
~#! rn=Aline rt=833353445
~#! tid=833311659

Hey, und da sage noch einer, die Umgangsformen liessen zu wuenschen uebrig...

Respekt, Respekt.


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



Levelanpassung (Silvana,  6. Jun 1996, 09:49:09):
Hi.
Endlich.... (Nein, nicht das Sehertor)
Ich hab die Gilde jetzt an das neue Level-System angepasst. Das heisst,
dass ihr jetzt die Sprueche wieder mit einem einigermassen erreichbaren
Level so gut lernen koennt, dass ihr damit aufsteigen koennt.
Anders ausgedrueckt: man muss nicht mehr Level 30-Seher sein, um
Magister werden zu koennen.
Was ich leider nachtraeglich nicht aendern kann, ist, dass ihr zwischen-
zeitlich wahrscheinlich abgestuft worden seit in Euren Fertigkeiten.
Dafuer geht das Lernen fuer gewisse Zeit erstmal deutlich schneller.
Aber Vorsicht: Dieser Service ist nicht von Dauer.

  Silvana

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



Das laestige Ueben - ein Vorschlag zum Casting (Frieda,  6. Jun 1996, 11:51:26):
Hi Leute,

Nachdem ich nun einige Zeit mit stumpfsinnigem Ueben verbracht habe, wollte
ich auch mal meinen Senf zu dieser Gilde dazugeben. So schoen und viel-
versprechend die Aussichten in ferner Zukunft Magistra zu werden auch sein 
moegen, ich bin ja wohl nicht die erste, die darauf hinweist, dass der Weg
dorthin mit reichlich Steinen und Frust gepflastert ist. Es wundert mich
daher nicht, wenn einige Leute schon bald entnervt aufgeben und der Gilde
wieder den Ruecken kehren. Ich war auch schon einige Male kurz davor, wieder
auszutreten.
Es ist ja wohl eigentlich so geplant, dass die Leute die Sprueche ueben, 
waehrend sie spielen und die Welt erkunden, aber dass das eben nur graue
Theorie ist und so nicht funktioniert, sieht man an meinem Beispiel.
Ich war schon Level 18 als ich in die Gilde eingetreten bin, kenne mich
einigermassen aus, habe praktisch alle einfachen Quests geloest und alle
leicht erreichbaren Zaubertrankverstecke abgegrast, so dass ich nun in
meinem derzeitigen geschwaechten Zustand (Gildelevel 4) nichts sinnvolles
mehr tun kann.
Das hat dazu gefuehrt, dass ich nun schon seit etwa 10 Stunden entweder 
in der Gildenkneipe rumstehe und mich selbst werte, oder den Anfaengern
beim Abmetzeln von Kaninchen und Wespen Konkurrenz mache, oder ihnen die
leicht erreichbare Ausruestung wegschnappe, um das noetige Geld zum Tanken
zu verdienen. Dass das auf die Dauer frustriert, wird wohl niemanden wundern.

Andererseits will ich aber nicht nur meckern, ohne konstruktive Vorschlaege
zu machen, also habe ich mir den Kopf zerbrochen, was man aendern koennte.
Dabei ist folgendes rausgekommen:

1. 'Spaeteinsteiger' sollten einen ordentlichen Casting-Bonus fuer ihr
Spielerlevel bei Gildeneintritt und/oder ihre bereits mit Abenteuergilden-
zaubern erworbenen Faehigkeiten bekommen, damit sie wenigstens ihre alte
Spielstaerke bald wieder erreichen koennen.

2. Es sollte einige intelektuell anspruchsvollere, aber dafuer effektivere
Moeglichkeiten geben, sein Casting zu erhoehen, aehnlich wie die ZT-Suche
speziell fuer Gildenmitglieder. Kleine Aufgaben, mit denen man sein Wissen
ueber die Zauberei vergroessert und sich dadurch verbessert. Z.B.: ein
verlorenes Buch finden, magische Raetsel loesen, aus Zutaten ein 
'Erleuchtungswasser' brauen u.s.w.
Als Belohnung kann man dann beim Casting ja nach Schwierigkeitsgrad einmalig
1 bis 2 bis x Stufen ueberspringen.

Ich glaube, dass dann alle nicht-scripter wieder mehr Spass an der Gilde
haetten. Ich zerbreche mir jedenfalls lieber zwei Stunden den Kopf ueber
ein gutes Raetsel, als eine Stunde lang auf die control-p-Tasten zu haemmern.

Frieda

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



Re: Das laestige Ueben - ein Vorschlag zum Casting (Silvana,  6. Jun 1996, 14:35:00):
~#! rn=Frieda rt=834054686
~#! tid=834054686
Hi, Frieda (und alle, die's sonst gelesen haben)
Ich find Deine Ideen so gut, dass ich die wahrscheinlich auch so (oder
so aehnlich) umsetzen werde. Lieder kommt Nummer 1 wohl fuer die meisten
Spieler zu spaet (ist auch nicht ganz einfach zu realisieren... mal sehen).

Die Miniquests/Raetsel/etc zum steigern des Casting bringen allerdings 
einen nicht unerheblichen Programmieraufwand mit sich und das kostet Zeit,
die ich nun nicht gerade im Ueberfluss habe. *seufz* Kann also noch eine
Weile dauern.
Sollte ein Magier bereits eine solche Miniquest haben/programmieren wollen/
sonstwie Ideen dafuer haben, bitte mail an mich.

  Silvana (begeistert)

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



Gildenquest (Eros,  7. Jun 1996, 00:42:23):
Also die Idee von Frieda gefaellt mir generell sehr gut. Ich wuerd das aber
nicht nur fuer die Zauberer vorschlagen, sondern vielleicht fuer jede
Gilde. Weiters, warum sollten eigntlich nicht generell Gildenquests
als Bedingung fuer den Aufstieg in den Gilden verlangt werden?
Dies wuerde vorallem dem neuen Stups system auh[1ch entgegenkommen.
Es gibt dabei fp zu finden, die stup fuer die Miniquest und eben dann
den Aufstieg in der Gilde. Dies bedeutet zwar enigen Aufwand fuer die
Programmierer, aber in Summe sollte sich das ganze mit dem neuen System in
MG ergaenzen. Ich erinnere mich da z.b. an die Suche der Magier in 
Unitopia, welche mir z.b. sehr gut gefallen hat. Sowas aehnliches wuerde
doch fuer die Zauberer hier glaube ich auch interessanter sein als das
was bisher verlangt wird. (Schliesst jetzt nicht nur die Zauberer ein, 
sonder alle Gilden). 
Ein fuer Gildenminiquests plaedierender
Eros

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



Re: Gildenquest (Wurzel,  7. Jun 1996, 00:56:01):
~#! rn=Eros rt=834100943
~#! tid=834100943
also ich finde die idee auch gut... mit abstrichen.
wie silvana schon gesagt hat, ist das arbeit, und zwar nicht wenig. so sehr
ich es gut finde, wenn ihr euch mit vorschlaegen hier einbringt, heisst das
aber doch im endeffekt, dass ihr das nicht selber machen wollt. und das ist
schade. ich muss mir nur die messages von merlin ansehen und vergleichen, wie
viele leute seher werden und wieviele magier. dazu kommt, dass zahlreiche
magier nichts oder nur sehr wenig tun. im endeffekt bleibt die arbeit an
wenigen haengen, zu wenigen, um nun auch noch alle gilden mit miniquests
auszustatten, natuerlich fuer jeden gildenlevel eine.
nochmal: ich finde die idee an sich sehr gut. es sind ja auch vor frieda
leute auf die gleiche idee gekommen. vor allem wenn ich stupide uebungsskripte
brauche, um ueberhaupt weiter zu kommen... ich frage mich manchmal schon,
warum so viele spieler in die gilden gehen. 

wer so gute vorschlaege machen kann, hat doch sicherlich das potential, auch
ein guter magier zu werden. das schoene daran ist, dass man seine vorschlaege
auch selbst verwirklichen kann. nur zu!

wurzel

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



Re: Re: Gildenquest (Hadra,  7. Jun 1996, 02:11:51):
~#! rn=Wurzel rt=834101761
~#! tid=834100943
es mag ja richtig sein, dass es einfacher ist vorschlaege zu machen als sie
auch zu proggen (das hab ich mal irgendwann herausgefunden ;), 
aber wenn wir spieler keien vorschlaege machen wird uns das asl untaetigkeit
angelastet und wenn auch nur die haelfte der seher magier wuerde und auch noch
was machen wuerde gaeb es echte koordinationsprobleme

jedes ding hat zwei seiten - welche besser ist? keine ahung, aber es muessen 2
sein ;)

hadra - philosophiert

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



Re: Das laestige Ueben - ein Vorschlag zum Casting (Asmodis,  7. Jun 1996, 10:45:51):
~#! rn=Frieda rt=834054686
~#! tid=834054686
Hmm, das stimmt schon, man braucht erhebliche Geldmittel, um in der
Zauberergilde etwas werden zu koennen, ist aber in der Chaosgilde
in den ersten Stufen aehnlich, vielleicht sollten die Verantwortlichen
sich dazu etwas ueberlegen.
Es kann doch nicht sein, dass man Zweities unbedingt braucht, damit der
Erstie in einer Gilde aufsteigen kann.
Naja, und falls es diese Mini-Quests geben sollte (waren doch sowieso
in Planung fuer die Stufenpunkte), dann sollte man sie halbwegs Script-
und Komplettloesungssicher machen, falls sie fuer den Gildenaufstieg
verwendet werden.
Nichts destotrotz lohnt sich das fleissige Ueben in der Zauberergilde :)

 just my 3 souls, Asmodis

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



Re: Re: Das laestige Ueben - ein Vorschlag zum Casting (Asmodis,  7. Jun 1996, 10:53:11):
~#! rn=Silvana rt=834064500
~#! tid=834054686
Wie weaers, wenn ihr mal das Magierkonzept uberarbeitet und angehende
Vollmagier erst mal ein Mini-Quest schreiben muessen, bevor sie es werden
koennen ? Wird in anderen MUDs auch schon so praktiziert (z.B. in 
Finalfrontier). Dann waere das Vorurteil wiederlegt, dass die meisten
Neu-Magier nixtun, weil sie dann eine Motivation haetten und die
Gilden haetten ihre Mini-Quests :)
Ich persoenlich halte nix davon, jeden Neu-Magier gleich einfach so
zu befoerdern, schliesslich ist es ja nicht Sinn der Sache, Magier
zu werden, ohne etwas programmtechnisch zum MUD beizutragen.

 just my 3 souls, Asmodis

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



Re: Das laestige Ueben - ein Vorschlag zum Casting (Snuggle,  7. Jun 1996, 11:22:16):
~#! rn=Frieda rt=834054686
~#! tid=834054686
Hi Ihr Mitzauberer und die, die es werden wollen.

Erstmal find ichs schoen, dass jemand mal nicht nur meckert, sondern m
mit konstruktiven vorschlaegen aufwartet.

Vorschlag 1. halte ich aber trotzdem fuer nicht durchfuehrbar.
a) muesste der Bonus von der alten Zauberfaehigkeit, 
nicht nur von der Stufe abhaengig gemacht werden
(da gibts naemlich ziemliche Diskrepanzen)
und b) passt es von der Idee her nicht so gut. 
Abenteurer lernen ein paar Sprueche so im Nebenbei, die sie 
anwenden koennen. Zauberer gehen von einem ganz anderen Ansatz aus und
muessen halt erstmal (das ist wohl das einzige Merkmal von zauberern, das in 
wirklich jeder Literaturvorlage gleich ist) sehr(!) viel ueben.
(abgesehen davon, dass es genug Leute auch 
so geschafft haben).

Vorschlag 2. hingegen befuerworte ich hingegen uneingeschraenkt,
ich weiss noch, was fuer eine Quaelerei war , den cast hoch genug zu bekommen 
und da faende ich ein paar kleine Aufgaben doch enorm erfrischend (und vom 
Hintergrund auch passend)

So, ichentschuldige mich fuer das graessliche Layout, schiebe aber alle Schuld
auf mein ebenso graessliches terminal.

YTSnuggle


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



Re: Re: Gildenquest (Snuggle,  7. Jun 1996, 11:37:43):
~#! rn=Wurzel rt=834101761
~#! tid=834100943
Hi Wurzel,

gib mirn crash-Kurs in Lpc und ich schreib Dir ne Miniquest.
Aber ich will hier Spieler bleiben, das hat naemlich auch seine Privilegien
:-9

Gruss
Snuggle

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



Re^3: Das laestige Ueben - ein Vorschlag zum Casting (Silvana, 11. Jun 1996, 10:39:40):
~#! rn=Asmodis rt=834137591
~#! tid=834054686
Die Sache hat leider einen Haken, Asmodis. Um eine Skriptsichere
Miniquest schreiben zu koennen, muss man schon nen bisschen was 
koennen. Und woher das koennen, wenn man gerade erst Magier geworden
ist?

  Silvana

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



Nichts geht mehr... (Patryn, 12. Jun 1996, 08:55:18):
Ich hoffe, Li liesst auch Zeitung :)
Das Pentagramm im Zauberberg funktioniert nicht mehr, wies scheint...
In den Raum mit den sieben Spiegel kommt man rein, aber durch die Spiegel
hindurchgehen kann man nicht mehr

------
patryn

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



Re: Nichts geht mehr... (Li, 12. Jun 1996, 10:00:15):
~#! rn=Patryn rt=834562518
~#! tid=834562518
Ja ich lese Zeitung...
Dummerweise hab ich gestern beim aendern der verben fuers pentagramm auch
"gehe" mit aufgenommen. dadurch wurde das durch die speigel gehen
ueberschrieben.
Sorry

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



komischer Tod (Nikolaus, 12. Jun 1996, 21:16:32):

eben beim 5 Versuch in der Magisterpruefung:


ein harmloses Monster nimmt mir pro Runde max. 8 LP ab,
Vorsicht war auf 20, Fluchtrichtung gar nicht,
es gab nur einen Ausgang "raus":

Lebenspunkte: 52 (178)  Magiepunkte: 190 (226) Stabmagie: 47 (75).
Lebenspunkte: 53 (178)  Magiepunkte: 191 (226) Stabmagie: 47 (75).
Lebenspunkte: 49 (178)  Magiepunkte: 191 (226) Stabmagie: 47 (75).
Lebenspunkte: 46 (178)  Magiepunkte: 191 (226) Stabmagie: 47 (75).
Lebenspunkte: 47 (178)  Magiepunkte: 192 (226) Stabmagie: 47 (75).
Lebenspunkte: 39 (178)  Magiepunkte: 192 (226) Stabmagie: 47 (75).
Lebenspunkte: 31 (178)  Magiepunkte: 192 (226) Stabmagie: 47 (75).
Lebenspunkte: 31 (178)  Magiepunkte: 184 (226) Stabmagie: 47 (75).
Lebenspunkte: 25 (178)  Magiepunkte: 184 (226) Stabmagie: 47 (75).
Lebenspunkte: 25 (178)  Magiepunkte: 177 (226) Stabmagie: 47 (75).
Lebenspunkte: 21 (178)  Magiepunkte: 177 (226) Stabmagie: 47 (75).
Lebenspunkte: 22 (178)  Magiepunkte: 178 (226) Stabmagie: 47 (75).
Flammende Hand (ein)  Wille (ein)  XHand (aus)  Schutzzauber (Schutz)
  Du greifst den Panikdaemodant mit brennenden Haenden an.
  Du schlaegst den Panikdaemodant mit dem Krachen brechender Knochen.
  Der Panikdaemodant greift Dich mit scharfen Krallen an.
  Der Panikdaemodant trifft Dich hart.
Lebenspunkte: 16 (178)  Magiepunkte: 178 (226) Stabmagie: 47 (75).
Flammende Hand (ein)  Wille (ein)  XHand (aus)  Schutzzauber (Schutz)
Die Angst ist staerker als Du ... Du willst nur noch weg hier.
Mist, falsche Richtung! Du rennst gegen eine Wand.
Lebenspunkte: 0 (178)  Magiepunkte: 178 (226) Stabmagie: 47 (75).

---> und ab in den Hain der Elfen... :(


ich finde das unlogisch und reichlich fies...
bin doch kein Sterbezweitie!

- ist das Absicht
- oder ein Bug
- oder ganz normal


*???*
       Sterb-olaus

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



Re: komischer Tod (Dhojakt, 12. Jun 1996, 21:51:15):
~#! rn=Nikolaus rt=834606992
~#! tid=834606992
Das ist Absicht, mich hat dieser Fluchtversuch ueber 60 lp gekostet, weil ich
erst 3 mal gegen ne Wand gerannt bin, bevor ich fluechtete.

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



Re: komischer Tod (Silvana, 13. Jun 1996, 09:15:34):
~#! rn=Nikolaus rt=834606992
~#! tid=834606992
Wenn Du die letzten 3 oder 4 Zeilen davor auch noch kopiert haettest,
haette wohl jeder sehen koennen, dass das voellig normal und so gewollt
ist. Ich kanns Dir auch mal erklaeren, aber das bestimmt nicht in der 
Zeitung. ;-) Nur soviel: Ein Panikdaemodant verursacht Panik.... ;-)

  Silvana

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



Gildenemblem/ -wappen/ -zeichen/ -blabla (Anakin, 13. Jun 1996, 10:22:33):
Fuer alle die zum Morgengrauensommercamp kommen wollen, 
wie waere es wenn die EURE Gilde auch durch einen
Wimpel/Fahne vertreten ist. Wir haben da so klasse
Fahnenstangen auf dem Zeltplatz. Das was die anderen
Gilden schaffen packt ihr Zauberer doch wohl auch.
Welche Schmach wenn da nur die dummen Chaoten mit sowas
auftauchen.
Also: Schreibt was zu der Idee ob ihr sowas machen wollt,
ob sich einer findet sowas zu entwerfen und zu realisieren.
Wenn mehrere Leute mit sowas ankommen, wird der Beste
gewinnen.
Wegen der Groesse Hate oder mich fragen.

Anakin - MGSC '96

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



Phoenixfeder (Li, 25. Jun 1996, 10:08:56):
HI!
Der Moench Bibliothekar in Xian hat eine Phoenixfeder gefunden. Da er leider
keinen kennt, der ihm die abnehmen wuerde, und da er wegen der Feder und der
Alraune immer von Zauberern angegriffen wird, hat er jetzt seine
Karatetechniken etwas staerker trainiert.

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



Re: Phoenixfeder (Morgoth, 25. Jun 1996, 10:22:26):
~#! rn=Li rt=835690136
~#! tid=835690136
ihr habt auch baeume, ja?
Morgoth

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



Re: Re: Phoenixfeder (Li, 25. Jun 1996, 10:23:37):
~#! rn=Morgoth rt=835690946
~#! tid=835690136
klar, wieso nicht? Aber hier fallen sie nicht so schnell um, erst wenn sie 100
Jahre alt sind.

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



Re: Re: Phoenixfeder (Bendeigid, 25. Jun 1996, 10:26:18):
~#! rn=Morgoth rt=835690946
~#! tid=835690136
Hm, Morgoth, ob Baeume oder nicht, es ist eine allgemein wichtige Sache, dass
Aenderungen an Monstern bekanntgegeben werden. Damit meine ich natuerlich nur
die Aenderungen, die die Kampfkraft betreffen, Es waere naemlich ziemlich
hintehaeltig, ein Monster ploetzlich doppelt so stark zu machen und sich dann
zu freuen, dass haufenweise Spieler, die es regelaessig metzeln, an zu
niedriger Vorsicht eingehen. Meine Meinung.

Z'par Servu,
          Bendeigid

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



Re: Phoenixfeder (Hadra, 25. Jun 1996, 16:49:35):
~#! rn=Li rt=835690136
~#! tid=835690136
was fuer ein seltsamer zeitgenosse. da kennt er niemanden, der ihm die feder
abnimmt und doch muss er trainieren, weil er immer umgebrahct wird um dann die
feder abgenommen zu bekommen?

hadra denkt . o O (geben ist seliger denn nehmen ;)

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



Re: Phoenixfeder (Asmodis, 25. Jun 1996, 19:41:24):
~#! rn=Li rt=835690136
~#! tid=835690136
Aeh, noch staerker ?
Der haut mich so schon zu Klump !

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



Re: Re: Phoenixfeder (Li, 26. Jun 1996, 08:17:05):
~#! rn=Hadra rt=835714175
~#! tid=835690136
Naja, denk, aeh, gruebel, ich meine keinen Fernwestler...
WElcher zivilisierter Fernwestler wuerde einem "Barbaren" schon so etwas
wertvollen wie eine Phoenixfeder geben?...
Zitat aus dem Li Ki, dem Buch der Sitten:
"Das Geheimnis der Phoenixfeder darf nur von Fernwestmund zu Fernwestohr
gehen"
(oder so aehnlich)
Li 

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



Re: Re: Phoenixfeder (Li, 26. Jun 1996, 08:19:06):
~#! rn=Asmodis rt=835724484
~#! tid=835690136
nicht staerker, nur besser!
Li (er wird sein Zusaetzliches sicherlich wieder verlernen, wenn er die
Phoenixfeder nicht mehr hat.)

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



Re^3: Phoenixfeder (Asmodis, 26. Jun 1996, 11:22:13):
~#! rn=Li rt=835769946
~#! tid=835690136
Wenn er die Feder nicht mehr hat, dann liegt wohl nur noch seine Leiche
herum, oder kann man neuerdings Sachen stehlen von NPCs ? :)

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



Re^4: Phoenixfeder (Wargon, 26. Jun 1996, 11:24:23):
~#! rn=Asmodis rt=835780933
~#! tid=835690136
Vielleicht kann man die apportieren lassen? ;)

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



Zauberstab V2.0 (Silvana, 27. Jun 1996, 11:27:17):
Hi.
Ich hab den Zauberer-Zauberstab mal gruendlich umgearbeitet. Ich denke,
die neue Versionsnummer ist bei den Aederungen gerechtfertigt. Wer sich
informieren moechte, lasse sich mal die aktuellen gimmicks anzeigen und
lese sich die dazugehoerigen Hilfeseiten durch.

  Viel Spass - Silvana

PS: Sollte der Stab Euch aus irgendeinem Grund mal nicht normal gehorchen,
oder angeblich einem anderen gehoeren, gebt den Befehl 'stabinfo' ein.
Das sorgt fuer einen Reset aller intern gespeichern Werte. Das betrifft
auch die nach einem Tod ja schwankenden Zahlen fuer maximale LP/SP.

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



neuer Stabreport :) (Nikolaus, 27. Jun 1996, 21:30:52):

der neue Stabreport ist wirklich oberspitzenklasse :)
endlich ein uebersichtlicher Einzeiler *freu*

gruss
      nikolaus, tankt schon gar nicht mehr voll
                damit er den Stabreport dauernd sieht ;)

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



Stabreport (Snuggle, 10. Jul 1996, 10:29:56):
Hiho alle.

Erstmal danke fuer den neuen Stabreport. Kann ich mich glatt mit anfreunden. 
Aber eine Bitte habe ich noch. Ich moechte die Daten auf der rechten
Bildschrimhaelfte haben, so dass sie nicht im Scroll untergehen. Wenn ich aber
einfach Leerzeichen einfuege, streicht der Report die wieder raus. Laesst sich
das aendern?

Danke,
Snuggle

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



nochmal Stabreport (Snuggle, 10. Jul 1996, 10:33:37):
Ich hab gerad festgestellt, dass deie zmessage das richtig interpretiert, aber
ich hab mir ein alias auf die Formatierung gelegt, welches gekuerzt wird.
(sprich die Leerzeichen raus - es wird zwar richtig angezeigt, wenn ich es
abfrage, aber beim ausfuehren, wirds vermurkst).

Ist wahrscheinlich gar keine Aufgabe fuer Silvana, aber vielleicht reicht es
ja jemand weiter (ich hab naemlich keineA Ahnung, wer zustaendig ist.)


YTSnuggle

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



Flagge (Snuggle, 10. Jul 1996, 11:26:45):
Gibts irgendwelches Interesse an ner Flagge fuers Somemrcamp?

Wie waers mit nem roten zerbeulten breitkrempigen, spitzen Hut mit der
Aufschrift Zaubberer (Aehnlichkeiten mit lebenden, toten ode ausgedachten
Personen der Disc- oder einer anderen Welt sind nicht zufaellig) -)


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



Re: Flagge (Lariel, 12. Jul 1996, 15:04:45):
~#! rn=Snuggle rt=836990805
~#! tid=836990805
Und dem Kunstturm in der Mitte? Und nem aufgeschlagenen Buch in dem unser
Motto steht?

-Lariel Falkenflug, Inquisitor von Taramis.
 (Liebt Terry ueber alles!!!)

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



Kleiner Bug... (Lariel, 14. Jul 1996, 14:37:37):
Schau mal, Silvana:

> ziehe guertel an
Die Robe widersetzt sich deinem Versuch.

Klingt seltsam... Ist denn Robe gleich Guertel?

- Lariel Falkenflug, Inquisitor von Taramis
  (Nervt liebend gerne seine Gildenmagier...)

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



Re: Kleiner Bug... (Asmodis, 16. Jul 1996, 02:11:13):
~#! rn=Lariel rt=837347857
~#! tid=837347857
Ist wohl das alte File wieder reingerutscht, ist mir auch schon passiert ...

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



Alraune (Li, 18. Jul 1996, 12:30:40):
Wer sich wundert, dass die Zwillingsalraune nicht mehr beim Moench in Xian
ist, dem sei gesagt, dass sie sich immer noch in Xian befindet.
Li

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



Schutzhuelle (Silvana,  5. Aug 1996, 11:28:45):
Eine ganz schlechte Nachricht... Sorry.
Zardoz hat mich heute auf einen Tippfehler im Zauberer-Spellbook 
aufmerksam gemacht, der dafuer gesorgt hat, dass die Schutzhuelle 
ERHEBLICH besser war, als sie sollte. Genaugenommen war ihr Schutz so
gut wie ein Meterdicker Stahlmantel. Ich denke, ihr habt Verstaendniss 
dafuer, dass ich das so nicht lassen konnte. Ich hoffe, der Spruch ist
nicht ZU schwach geworden, aber er ist in jedem Fall wieder in einer
verantwortbaren Region. Sorry...

  Silvana.

PS: Das ist NOCH nicht aktiv, wird erst in einer halben Stunde aktiviert,
damit es niemanden im Kampf voll erwischt.
PPS: Flames bitte an Zardoz, die Petze. ;-)

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



Phlyaken (Silvana, 12. Aug 1996, 09:31:58):
Hi.
Die Party hat so einige interessante Disskussionen mit sich gebracht, so
dass ich sicher ein paar Aenderungen im Laufe des Tages einzufuehren habe.
Eine davon wird die Schutzhuelle betreffen, aber das dauert noch. Die
erste Aenderung betrifft Phlyaken: Ein Bugfix (Thanx to Mupfel) und
eine kleine Aenderung an seinen Abwehrmassnahmen...

  Viel Spass - Silvana

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



schutzhuelle (Silvana, 12. Aug 1996, 11:43:38):
Nicht, dass ich etwas anderes erwartet haette... ;-)
Ich habe in den letzten Tagen zahlreiche Briefe zum Thema Schutzhuelle 
bekommen. Darin waren auch ein paar Zahlen zu finden, die so himmelschreiend
falsch waren, dass ich das mal richtig stellen moechte:
Jemand meinte, die Schutzhuelle haette vorher so viel gebracht wie eine
volle Ruestung und wuerde jetzt so viel bringen wie ein Umhang. Dem ist 
nicht so. Die Schutzhuelle bringt bei maessigem Erfolg (40%) jetzt fast 
so viel wie eine komplette Ruestung - bei mechanischen Schadenstypen.
Zu allem anderen: siehe Spruchhilfe.
Jemand meinte, ich haette die Schutzhuelle um Faktor 8 etwa abgewertet.
Ich hab sie tatsaechlich um den Faktor 50 (!) abgewertet. Die Huelle 
brachte als bei maessigem Erfolg vorher so viel wie fuenfzig komplette,
maximale Ruestungen. Ich denke ihr seht ein, dass das zu viel war.

Wie dem auch sei, ich habe mit nach ein paar Tests die Schutzhuelle noch 
einmal veraendert. Es gibt dazu einen kleinen Zusatztext in der 
Spruchhilfe, also lest es bitte da nach.

  Silvana

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



Schutzzauber allgemein (Silvana, 12. Aug 1996, 11:46:16):
Die Zauber Schutz und Schutzhuelle kuendigen jetzt ihr eigenes Ende vier
Sekunden vor dem tatsaechlichen Ende des Zaubers an. In diesen vier
Sekunden kann der alte Spruch von einem neuen 'uebersprochen' werden, so
dass ein lueckenloser Schutz moeglich sein sollte.
Dank an Aurian fuer diese Idee.

  Silvana

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



Schutzhuelle (Matsushita, 18. Aug 1996, 20:53:30):
Ich bin hier auf ein Problem bei der Schutzhuelle gestossen, bei dem ich mir
nicht
sicher bin, ob's ein Bug oder gewollt ist. Wenn ich eine Schutzhuelle caste,
bekomme
ich manchmal die Meldung, dass da kurz was aufblitzt, aber danach kommt dann
doch
eine "Missglueckt"-Meldung. Trotzdem meldet der Stabreport eine aktive
Schutzhuelle
und ich kann auch keinen weiteren Schutz sprechen.
Beenden kann ich das dann allerdings auch nicht, weil der aktive Zauber weder
als
Schutzhuelle noch als Schutz noch als sonstwas bekannt ist. Insbesondere wegen
der
fehlenden Moeglichkeit, den Zauber zu beenden, ist das irgendwie ziemlich
laestig.
Aber vielleicht hat ja jemand einen netten Tip. Matsu*

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



Re: Schutzhuelle (Silvana, 19. Aug 1996, 10:13:09):
~#! rn=Matsushita rt=840394410
~#! tid=840394410
Was Du beschreibst, ist die klassische misslungene Schutzhuelle. Es ist zwar
eine Schutzhuelle, aber eine, die anders wirkt, als das, was Du gewollt 
hast...

  Silvana - sagt nicht mehr dazu.

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



Re: Re: Schutzhuelle (Matsushita, 24. Aug 1996, 00:29:59):
~#! rn=Silvana rt=840442389
~#! tid=840394410
Ah ja, herzlichen Dank fuer die erhellende Antwort.
Hm, und das ist auch der Grund, warum ich sie nicht beenden kann?

Matsu* - rafft eben manches viel spaeter als andere - wenn ueberhaupt. :)

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



*wink wedel* (Caradhras, 25. Aug 1996, 21:12:33):
                 Tuess Zauberer

Ich bin ausgestiegen aus der Gilde. Sie war zwar seeeehr nett *lob Silvana*
aber das ueben dauert mir viel zu lange ueber lv 5 hinaus.

Viel Spass noch hier. 

   Es winkt euch zu:  Ein Ex-Zauberer und Ex-Frosch namens
Leises Rauschen dringt an Dein Ohr. Suedlich von Dir fuehrt ein Weg weiter 
an dem See vorbei ueber einen Abgrund. Dort stuerzt auch ein Wasserfall in die
Tiefe. Der Weg fuehrt auch nach Nordosten weiter zu einem Bach, der aus 
Richtung Norden vom grausamen Caradhras heruntergeflossen kommt. Ein schmaler 
Pfad fuehrt nach Nordwesten in die Hoehe. Du kannst nicht erkennen, wo er 
danach hinfuehrt. Er verschwindet in den Huegeln ueber dem Tal suedlich, ueber
das Du von hier eine gute Aussicht hast. Nach Suedosten und Osten geht es in 
einen See. Hinter dem See liegt die riesige Silberzinne, Celebdil genannt. 
Auch vermeinst Du, vor seiner Bergflanke einen Weg verlaufen zu sehen.

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



Das liebe Geld... (Anatol, 16. Sep 1996, 17:27:00):


Hiho!
Wie waere es, wenn Zaubererkomponenten nach einem Crash ein wenig mehr Bargeld
erzeugen wuerden? Es ist mir direkt peinlich, aber ich mach pro Shutdown (die
es ja ziemlich oft momentan gibt) 40k Verlust. Wie sieht denn das bei jemandem
aus, der keinen tollen Karate-Zweitie hat?

Anatol


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



Re: Das liebe Geld... (Zorya, 19. Sep 1996, 10:27:02):
~#! rn=Anatol rt=842887620
~#! tid=842887620
Du kannst die Verluste in Grenzen halten, wenn Du nicht zu grosse Vorraete
anlegst. Egal wieviele Rubine Du hast, Du bekommst max. 1000 Muenzen
Entschaedigung dafuer. Also: kleine Vorraete!

  Zorya - ist darueber auch schon gestolpert.

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



Geldquelle versiegt (Mupfel, 20. Sep 1996, 00:07:46):

Im Zauberkomponentenladen kann man jetzt nicht mehr negative Mengen an
Komponenten kaufen und sich damit finanziell sanieren.

-mupfel-

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



Erzmagisterkaempfe (Asmodis,  1. Okt 1996, 18:55:56):
Hmm, da ja jetzt mehrfach Erzmagister abgetreten sind (Sei es durch langes
Wegbleiben oder Magierwerden oder etc.), waere es vielleicht gut, wenn
nicht ein anderer Magister einfach so die Stelle besetzen koennte.
Man koennte ein Magister-Turnier austragen um diese Stelle, wobei nur
die Magister qualifiziert sind, die bei 'Rueckstufung' des alten
Erzmagisters auch schon diesem Zweig angehoerten.
Hmm, wie das ablaeuft bleibt wohl Li und Silvana ueberlassen, aber
besser waere das. Bei 4 Anwaertern koennte man z.B. ein Halbfinale
und ein Finale austragen, bei 3 jeder gegen jeden ...

Just my 3 souls, Asmodis

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



Re: Erzmagisterkaempfe (Silvana,  3. Okt 1996, 10:22:45):
~#! rn=Asmodis rt=844188956
~#! tid=844188956
Argl... Noch mehr Arbeit... :) 
Jaja, schon gut, ich ueberleg mir was....
Silvana - macht keine Versprechungen ueber Zeit...

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



Bestenliste (Matsushita,  4. Okt 1996, 10:56:44):
Aeh, ich haette einen Vorschlag zu machen wegen der "Bestenliste"
in der Gilde. Momentan umfasst sie 50 Plazierungen, was ja bisher
auch ziemlich ausreichend war (als ich im Sommer irgendwann ange-
fangen habe, waren die 50 Plaetze noch nicht mal alle belegt).
Momentan ist es so, dass der Zauberer auf dem 50. Platz bereits
Level 8 hat, und es dauert wahrscheinlich auch nicht mehr ewig,
bis da nur noch Magister auftauchen. Da nun so ziemlich alle Listen
irgendwie 100 Plazierungen aufweisen, moechte ich den Vorschlag
machen, die Liste zu erweitern. Gerne auch mit einer zweiten
Liste (oder anderswie gesplittet), damit man nicht immer gleich
die ganzen 100 Plaetze um die Ohren geschlagen bekommt. Naja, und
auch wenn die %-Punkte an sich ein ziemlich nutzloser Wert sein
moegen, finde ich's gerade fuer die Neulinge sehr wichtig, dass
sie den immer irgendwie sehen koennen, auch wenn sie auf Platz
9999 einer imaginaeren Liste stehen. Progress-Indikatoren sind
zwar auch nicht der Weisheit letzter Schluss, aber vielleicht 
"versuessen" sie dem einen oder anderen Spieler das endlose 
Geuebe doch ein bisschen...
Matsu*

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



Spielerhilfe durch Tierhasser (Hardil, 11. Okt 1996, 11:17:51):

Du hast ein Haustier?
Du hasst es, wenn stinkende und doofe Magier dauernd Dein Tier zappen?
Dann mach es wiefolgt:

Stell DIch neben den Magier, der Dein Tier per Trigger zappt.
Mch Dir ein Alias fuer 'hole tier' und eins fuer 'entsorgen leiche'

Und schon ist Dein Zauderstab so gut wie aufgeladen, ohne dass Du gescriptet
hast, und Du kannst den nervenden Magier wegen Spielerhilfe verpetzen. :)

-Hardil. Hat endlich ein Mittel gegen *** gefunden.

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



Re: Spielerhilfe durch Tierhasser (Guldukat, 11. Okt 1996, 11:24:28):
~#! rn=Hardil rt=845025471
~#! tid=845025471

Ich wusste gar nicht, wie lecker Papageien leichen sind!
Obwohl, irgendwann sollte ich voll sein! ;)
GD

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



Lefty (Silvana, 25. Okt 1996, 07:48:02):
Da Leftys Erstie jetzt Magier ist, hab ich Lefty von seinem Platz als 
Erzmagister entfernt. Viel Spass beim Gedraengel um die Nachfolge.

  Silvana

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



Re: Lefty (Silvana, 25. Okt 1996, 07:51:43):
~#! rn=Silvana rt=846222482
~#! tid=846222482
Ach ja, noch was. Ich habe meinen Testi Eremis als neuen Erzmagister.
Soll ja keiner ohne Duell Erzmagister werden. :)

  Silvana

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



Re: Lefty (Lefty, 25. Okt 1996, 18:17:11):
~#! rn=Silvana rt=846222482
~#! tid=846222482
darf ich mal erfahren, warum man als zweiti kein erzmagister sein darf ? und
wenn man das nicht sein darf moechte ich doch bitte wenigstens in einem duell
abgesetzt werden und nicht durch das umsetzen von ein paar bytes.

Lefty *grummelnd*

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



Re: Re: Lefty (Fyt, 25. Okt 1996, 18:22:58):
~#! rn=Lefty rt=846260231
~#! tid=846222482

Unabhaengig davon, dass ich die Zauberergilde noch nicht mal gefunden
geschweige denn nen Zweitie da drin habe, finde ich es gar nicht soooooo
unverstaendlich, wenn die zahlenmaessig beschraenketen Top-Positionen
*nicht* an Magierzweities vergeben werden, im Gegenteil.

Fyt.

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



Re: Re: Lefty (Anatol, 25. Okt 1996, 18:25:38):
~#! rn=Lefty rt=846260231
~#! tid=846222482
"Magier sein" heisst, an der Gestaltung des Muds mitwirken oder zumindest
nicht mehr spielen zu wollen. Magier ist man meiner (unbescheindenen) Meinung
nach in erster Linie; der Magierzweitie mit Spielerlevel ist ein Zeitvertreib,
der den normalen Spielverlauf nicht stoeren sollte - nicht zuletzt weil der
Magier zumindest in den Code schauen kann und vor keinen spieltechnischen
Raetseln steht (ob er den Zweitie dabei unmanipuliert laesst, spielt
eigentlich gar keine Rolle). Und damit duerften Magierzweities von
rationierten Gildenplaetzen ausgeschlossen sein.

Aber es scheint ja Mode geworden zu sein, dass man sich als "Zweitie" markiert
und einen Zweitcharakter zum Magier macht...

Anatol, Erstie ohne Magierzweitie


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



Re^3: Lefty (Methedras, 25. Okt 1996, 18:45:15):
~#! rn=Anatol rt=846260738
~#! tid=846222482
Anatol> Aber es scheint ja Mode geworden zu sein, dass man sich als "Zweitie"
Anatol> markiert und einen Zweitcharakter zum Magier macht...

*grins* Die Anspielung hat jetzt keiner verstanden. Eigentlich ists doch egal,
ob ich 'nen 10tie zum Mag mache oder nicht, solange der Erstie dann ein
Magier-
Zweitie wird (und der Rest der Bande natuerlich auch)

Jetzt werden bestimmt gleich die vorherigen Artikel geloescht. *kicher*
In gewissem Sinne verstehe ich Lefty, und auch Silvana, denn beide 
Begruendungen haben was fuer sich, Lefty, weil er wohl (hoffentlich) ohne
Magierhilfe als ganz normaler Seher sich hochgespielt hat und sich seinen
Rang in der Gilde erkaempft hat und Silvana, weil Magierzweities wirklich
nicht mehr so viel machen sollten wie vorher und auch natuerlich nicht
duerfen.

  Der letzte Berg Methedras, der Erstie Caradhras aufs Nebengleis
                            geschoben hat

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



Re^4: Lefty (Anakin, 25. Okt 1996, 21:22:33):
~#! rn=Methedras rt=846261915
~#! tid=846222482
Ich hab die Anspielung verstanden.

Anakin.

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



Re^5: Lefty (Silvana, 28. Okt 1996, 08:54:26):
~#! rn=Anakin rt=846271353
~#! tid=846222482
Die Zahl der Erzmagister ist bekanntlich begrenzt. Wenn ich auf den Posten
Magierzweities zulassen wuerde, waeren die Plaetze ziemlich permanent von
Magierzweities blockiert, beispielsweise von mir oder meinen Kindern.
Wenn ich das zulassen wollte, haette ich mir die Arbeit, Erzmagisterzauber
zu schreiben etc auch sparen koennen, weil sowieso kein _echter_ Spieler
je auf den Platz gekommen waere. Das mag jetzt arrogant klingen, aber ich
kennen meine eigenen Raeume im allgemeinen doch am besten selbst. :)
Wenn ich mir aber selbst (und Para* und Morgoth....) diese Moeglichkeit
nehme, muss ich die konsequenterweise auch allen anderen Magiern nehmen.
Daher: Keine Magierzweities in begrenzten Gildenraengen.

  Silvana (hat in diesem Fall das letzte Wort)

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



Re^6: Lefty (Patryn, 28. Okt 1996, 08:58:26):
~#! rn=Silvana rt=846489266
~#! tid=846222482
hmmm...ich wollte eigentlich auch wieder nen zweitie in die gilde hochspielen,
aber so wird das ganze hinreichend uninteressant :(
dabei wuerden gerade magier gefundene fehler mit ihren zweities eher
ausplaudern, denk ich mal. wie wears, wenn man magierzweities aus der 
begrenzung raushaelt, das heisst->sonderbehandlung
bitte mal drueber nachdenken...

------
patryn will wieder zaubern

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



Re^6: Lefty (Morgoth, 28. Okt 1996, 09:28:35):
~#! rn=Silvana rt=846489266
~#! tid=846222482
Miiiiiir ??? 
Ich habe keine Zweities. Wieso sollte icvh HIER spielen ? **wuerg**
M

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



Re^7: Lefty (Dhojakt, 28. Okt 1996, 12:40:45):
~#! rn=Patryn rt=846489506
~#! tid=846222482
In letzter Konsequenz hiesse das dann: ein zweiter (Erz-)magisterkreis nur
fuer Magierzweities?!?

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



Re^8: Lefty (Patryn, 28. Okt 1996, 14:58:18):
~#! rn=Dhojakt rt=846502845
~#! tid=846222482
ja...warum nicht? sonst koennte es schnell passieren, das zweities nicht mehr
als solche gekennzeichnet werden. ich jedenfalls moechte nunmal in keine
andere gilde und nen spielercharakter moechte ich aber trotzdem.
in anbetracht der vielen ueberei moechte man aber auch nen ziel vor augen
haben und das ist nunmal, irgendwann mal der/die beste seiner gilde zu sein
und die magister-spells zu beherrschen (ich denke da an bestimmte spells, die
verdammt viele vorteile mit sich bringen)
was kommt denn eigentlich als naechstes? magierzweities duerfen keine hydra
mehr killen oder wie?!?

------
patryn

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



Re^9: Lefty (Lifafa, 28. Okt 1996, 15:34:00):
~#! rn=Patryn rt=846511098
~#! tid=846222482
Also ich finde die Idee, einen Extra-Erzmagisterposten fuer Magierzweities zu
schaffen, gelinde gesagt, absurd.  Ganz abgesehen von technischen Details wie
der menge der zur Verfuegung gestellten magisterzutaten,  widerspricht diese
Konstruktion  der Idee, dass alle Spieler sich hier um dieselben Ressourcen
mit denselben Moeglichkeiten bemuehen.
Allerdings finde ich auch, dass magierzweities so, wie Silvana  das gemacht
hat, von den limitierten Plaetzen ausgeschlossen werden.
Die Diskussion hier ist meiner meinung nach ein bezeichnendes beispiel fuer
die mehr und mehr verschwimmende Grenze zwischen Magier und Spieler. Wenn dies
die Absicht der Goetter und ihrer Berater ist, dann sollte das aber auich
offiziell so verlautbart werden...dann spielen wir halt alle ein bisschen und
proggen nebenher ein bisschen   oder umgekehrt..das ist moeglich, fuehrt aber
meiner meinung nach zu einem anderen Mud.
Ein Spieler, der einen magiererstie hat, oder wie Anatol so schoen spielt eher
einen Magierzweitie, hat einfach mehr Einblick in das System, und damit
Moeglichkeiten, ganz legale, seinem Spielercharakter zu unterstuetzen, auch
ohne seine stats zu setzen oder aehnliches.
Lefty war so ehrlich, seine Zweities zu kennzeichnen..und damit auf das
problem indirekz aufmerksam zu machen.  Es  laufen hier aber jede menge
zweities von magiers ungekennzeichnet durch die Gegend, nicht nur in der
zauberergilde, ganz im gegensatz zu einem sntsprechenden Passus im
magiervertrag. Die meisten halten sich zurueck, wenn es um direkte Konkurrenz
mit Spielern geht, aber ich habe den Eindruck, dass Diese haltung weniger
wird.
Jeder, der Magier wird, solte sich darueber klar sein, welche Grenze er
ueberschreitet. Wenn er hier so gerne spielt, soll er halt Spieler bleiben;
wenn er hier gerne auch was dazuproggen moechte und ne gute Idee hat..dann
soll er halt seine Spiellust  und -ambitionen im wesentlichen in einem anderen
Mud froenen..gibt ja inzwischen jede menge davon.
                       
                           Lifafa

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



Re^10: Lefty (Bombadil, 28. Okt 1996, 17:45:06):
~#! rn=Lifafa rt=846513240
~#! tid=846222482

Also erstens: Ich finde es verstaendlich, dass mein Zweiti Lefty *ironisch
grins* nicht unbedingt Erzmagister bleiben darf. Das noch auf die
Magisterposten zu begrenzen ... so wie ich es rausgehoert habe ... na ihc
weiss net so recht schliesslich hat der kleine ne ganze Weile geuebt, bei den
Klerikern, Chaoten und Karatekas kann man ja auch bis ganz hoch als
Magierzweiti, gut, da nimmt man auch nur weniger nen Platz weg.

Ich habe mich damit abgefunden und kann damit leben. Das was mich nur
aufgeregt hatte war die Art und Weise, sowas nur aus der Zeitung erfahren zu
duerfen, das man abgesetzt ist. Ich hab's verkraftet, also Schwamm drueber
;-).

Ausserdem: Ich bin kein Magierzweiti, ich habe vor hier etwas zu proggen und
mit meinen Zweitis 'nebenher' zu spielen. Ich finde es ist verstaendlich das
ich dabei nicht gerade den Charakter zum Magier mache, der die meiste Zeit
fuer Ueben und so gebraucht hat.

So, und nu macht da nicht gleich wieder ne Megediskussion draus.

Lefty, genervt

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



Re^11: Lefty (Lifafa, 28. Okt 1996, 18:22:15):
~#! rn=Bombadil rt=846521106
~#! tid=846222482
Dass es wehtut, den Platz zu raeumen  oder gar geraeumt zu werden wie in
diesem fall, aknn ich absolut nachvollziehen, Lefty. Insbesondere angesichts
der zeit, die Du beim Hochpaeppeln zugebracht hast.

Aber wenn man Magier wird, sollte man sich genau diese frage stellen: ob man
das fuer die Moeglichkeit, hier auch zu gestalten, aufgeben will...oder nicht

Urspruenglich war in Muds die Grenze zwischen Magier und Spieler ganz scharf
gezogen...ganz im gegensatz zu der Position, die Du im dritten Abschnitt
vertrittst: ein bisschen proggen und auch noch ein bisschen spielen. Ich
finde, dass dieser Schritt schon eine Grundsatzdiskussion wert ist...und eine
entsprechende Stellungnahme von hoeherer Instanz zur Klarstellung beitragen
wuerde.

     LIfafa, nicht immer zaudernd...

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



Re^12: Lefty (Bombadil, 28. Okt 1996, 19:50:31):
~#! rn=Lifafa rt=846523335
~#! tid=846222482
Argh, es ist eindeutig geregelt, das ein Magier mit Zweitis spielen darf,
solange er diese nicht manipuliert und sich nicht gleichzeitig mit ihnen
einloggt. Und sowas gibts schon solange cih im MG bin, und das duerften
mindestens 1,5 Jahre sein :)

Lefty

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



Re^12: Lefty (Wurzel, 28. Okt 1996, 19:58:05):
~#! rn=Lifafa rt=846523335
~#! tid=846222482
ich bin zwar keine "hoehere instanz", sag aber trotzdem was dazu :)
ganz allgemein sehe ich durchaus einen gravierenden unterschied zwischen
einem spieler und einem magier. man ist entweder das eine oder das andere,
dazu ist eine grundsaetzliche entscheidung zu treffen. wer lieber spielt, soll
das tun und nicht magier werden. ein "magierzweiti" ist in keinem fall mit
einem normalen spieler vergleichbar, weil er eben zu viel weiss (wissen kann).

wurzel hat keine zweities

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



Re^13: Lefty (Bombadil, 28. Okt 1996, 20:01:13):
~#! rn=Wurzel rt=846529085
~#! tid=846222482
Dafuer unterliegt ein Magierzweiti gewissen Regeln, an die er sich zu halten
hat und die das 'normale' spielen im Mud gravierend veraendern.
Koenn mehr nu mal mit dem ganze Re-Geschreibe aufhoeren, das steht alles im
Magiervertrag und ist dort geregelt. 

Lefty *kopfschuettelnd*

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



Re^14: Lefty (Boing, 29. Okt 1996, 13:42:01):
~#! rn=Bombadil rt=846529273
~#! tid=846222482
Da eine Klaerung von hoeherer Instanz verlangt wird, werde ich das mal tun:
Wie Bombadil schreibt, gibt es eine eindeutige Regelung fuer Magierzweities.
Allerdings denke ich, dass Magierzweities trotzdem in erster Linie Magier
sind (durch das dadurch erworbene Wissen) und sich aus diesem Grunde so
verhalten sollten, dass echte Spieler nicht behindert werden. Ich habe
dahingehend jetzt auch die Zweitieregel erweitert:
-----------------------------------------------------------------------------
 o Der Zweitcharakter sollte sich etwas zurueckhalten, wenn er durch seine
   Aktionen echte Spieler behindert. Beispiele dafuer sind z.B. Quests
   blockieren oder hohe (limitierte) Gildenraenge einnehmen. Im letzten
   Fall steht es natuerlich jedem Gildenprogrammierer frei, seine eigenen
   Regeln bzgl. Magierzweities festzulegen.
-----------------------------------------------------------------------------
Ein Punkt, der bisher noch gar nicht erwaehnt wurde ist, dass es durchaus
SEHR nuetzlich ist, wenn man als Magier in Kontakt mit dem tatsaechlichen
Spielgeschehen bleibt. Wenn man als Magier laengere Zeit nicht mehr gespielt
hat (oder noch nie, gell Wurzel :), dann fehlen einem einfach wesentliche
Einblicke beim Programmieren von neuen Sachen. Aus diesem Grunde denke ich,
dass ein Magier ruhig immer mal wieder im eigenen Mud spielen sollte.

  Boing

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



hand (Silvana, 31. Okt 1996, 11:06:57):
Hi.
Nur ne Kleinigkeit eigentlich:
Der Spruch 'Hand' laesst sich jetzt nicht mehr 'uebersprechen'. Dafuer
kommt 4 sec (abzueglich lag) vor Ende des Spruches eine Meldung, dass der
Spruch aufhoert zu wirken (analog zu den Schutzzaubern). In dieser Zeit
kann der Spruch dann auch uebersprochen werden.

  Silvana

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



Re^11: Lefty (Asmodis, 31. Okt 1996, 20:55:45):
~#! rn=Bombadil rt=846521106
~#! tid=846222482
Uebrigens: Sperrt die Magierzweities bitte bei den Klerikern auch aus!
           Die Erleuchteten- und Hohepriester-Plaetze sind ja auch
           begrenzt, ich finde es nicht gut, dass da eventuell ein
           hochgepatchter Magierzweitie rumpfuschen kann!

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



Re^12: Lefty (Wargon,  4. Nov 1996, 10:24:19):
~#! rn=Asmodis rt=846791745
~#! tid=846222482
Wenn ein Zweitie "hochgepatched" wird, faellt er eh nicht mehr in die Gruppe
der Zweities, sondern in die der Testies (und er muss dann auch als solcher
gekennzeichnet sein).
  Wargon

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



Re^13: Lefty (Tanis, 18. Nov 1996, 17:26:00):
~#! rn=Wargon rt=847099459
~#! tid=846222482
Also, ganz davon abgesehen, das hochpuschen durch seinen magiererstie eh
unfair ist, finde ich schon, das man als magierzweiti auch erleuchteter werden
darf und kann. wenn man fair in der gilde spielt, so hat man auch net mehr
vorteile, als einer, der kein mag als erstie hat. falls ich mich da irren
sollte, lasse ich mich gerne belehren, aber dann auch mit begruendungen.

Tanis, der sich jetzt irgendwie betrogen vorkommt, das er seine zweitis fuer
umsonst hochgespielt hat.

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



Re^14: Lefty (Fyt, 18. Nov 1996, 18:33:42):
~#! rn=Tanis rt=848334360
~#! tid=846222482

Doch, der Magiererstie kann mal ganz fix nachschauen, welche Sachen
Einfluss auf die Lerngeschwindigkeit etc haben und sein Lernen dahin-
gehend optimieren.

Fyt.

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



Re^15: Lefty (Asmodis, 18. Nov 1996, 19:08:47):
~#! rn=Fyt rt=848338422
~#! tid=846222482
Och, das spricht sich auch unter Nicht-Magierzweities herum :)

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



Re^15: Lefty (Patryn, 19. Nov 1996, 00:06:31):
~#! rn=Fyt rt=848338422
~#! tid=846222482
das ist eher unerheblich denk ich mal....wichtiger ist, dass magier bei
duellen einen gewissen vorteil haben (ich mein dessen zweities ;)
da diese die duell-raeume kennen u.s.w.
von daher kann ich es schon verstehen...allerdings bin ich auch noch etwas
sauer, aber was solls

------
patryn

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



Re^16: Lefty (Wargon, 19. Nov 1996, 10:04:19):
~#! rn=Patryn rt=848358391
~#! tid=846222482
Verantwortungsvolle Magier unterlassen es in diesen Faellen deshalb auch, sich
sowas vorher anzusehen.
  Wargon

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



Re^17: Lefty (Raffi, 19. Nov 1996, 12:27:19):
~#! rn=Wargon rt=848394259
~#! tid=846222482

Hmm SOviel verantortungsbewustsein wie bei einem (trockenen) Saeufer dem man
Freibier verspricht ?

Gruss
H.
(Glaubt trotzdem an das gute)

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



Version 2.0 (Silvana,  9. Dez 1996, 07:31:56):
Hi. 
Ich stelle heute die Gilde auf die Version 2.0 um. Macht Euch lieber auf 
ein paar Bugs und so gefasst. Ausserdem gibts nen paar Neuerungen, die
Euch natuerlich voellig unvorbereitet treffen werden... :) Genaueres
erzaehle ich Euch dann, wenn's dran ist und laeuft - will sagen,
wenn's zu spaet ist. 

  Viel Spass - Silvana

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



Bestenliste (Silvana,  9. Dez 1996, 08:00:10):
Die selbige wurde ueberarbeitet und muss neu zusammengestellt werden. Daher
die ungewoehnlich kurze Liste. :)

  Silvana

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



Version 2.0 (Silvana,  9. Dez 1996, 09:43:21):
So, wie bereits angedeutet, gibt es jetzt die Version 2.0 der Zauberergilde
Was bedeutet das jetzt fuer Euch?

1) Ein Menge Bugs heute, denn nichts laeuft von Anfang an Bugfrei und nur
   sehr weniges wird es je... :)
2) Ein Menge Arbeit fuer Euch...

Was gibts also neues?
- Das wichtigste sind sicher die Gildenquests, bei Llystrathe zu erfragen
  und ab sofort eines der Aufstiegskriterien. Man benoetigt fuer Stufe 2
  10%, fuer Stufe 3 20% und so weiter.
- Die Questen sind im Gildenrateing beruecksichtigt, wundert Euch also
  nicht, wenn ihr erst mal schlechter dasteht.
- Die Bestenliste wurde angepasst.
- Das Lernen in der Gilde ist nur noch zu geringen Teil intelligenzabhaengig.
  Einen grossen Einfluss haben jetzt die rassenspezifischen Unterschieden
  will sagen: Elfen fallt das eine leichter, Zwergen was anderes.
- Magister und Erzmagister koennen nur noch alle 4 Tage ihren Zweig oder
  ihren Sekundaerzweig wechseln.
- Man kann von seinem Posten mit dem Befehl 'ruecktritt' zuruecktreten.
- Wenn man gefordert wurde, kann man nach einem freiwilligen Ruecktritt 
  24h in keinen neuen Zweig aufgenommen werden. Wird man im Duell besiegt,
  kann man sofort wechseln.

Was uebrigens noch nicht geht, sind ein Teil der Zauberer-Questen. Sie
funktionieren zwar, aber sie werden noch nicht gespeichert. Das wird
erst im Laufe des Tages aktiviert.

  Silvana

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



Phoenixfeder (Li,  9. Dez 1996, 12:52:47):
Hi!
Da die Phoenixfeder nur provisorisch in Fernwest untergebracht war, hat sie
jetzt der Bibliothkar nicht mehr. Im Grab gibts sie jetzt auch nicht mehr, da
der urspruengliche aufenthaltsort (der Phoenix) nun existiert.
viel spass beim Suchen! :-)
Li

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



Miniquests (Silvana, 12. Dez 1996, 07:49:41):
Hi.
Zweierlei:
1.) Besteht jetzt die Moeglichkeit, Gildenquests als optional zu kenn-
    zeichnen, was bei der 100er Quest geschehen ist. Diese Punkte werden
    dann nicht zu dem Aufstiegsbedingungen dazugerechnet, stehen aber
    als Bonus zur Verfuegung.
2.) Erscheint mir das Punkteverhaeltnis der Questen so nicht zu stimmen.
    Ich wuerde daher diejenigen, die schon einige Questen geloest haben,
    bitten, mal eine Punkte-Einschaetzung zu schreiben und mir per
    Mail zukommen zu lassen.

  Thanx - Silvana

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



Fussweg nach Taramis (Hardil, 12. Dez 1996, 11:51:15):

Hmmm, nur mal so als Idee...

KOennte evtl eingerichtet werden, dass die Rutsche, die ja nun doch ziemlich
lange dauert, eine aehnliche Funktion wie de ruebungsraum bekommt? Damit man
waehrend dem Rutschen noch was sinnvolleres machen kann als Zeitungslesen und
Artikel schreiben?

Naja, ist nur ein Vorschlag, aber da die Rutsche spaetestens beim dritten Mal
keinen Kitzel mehr bringt, und Zauberer da dauernd druchmuessen... :-)

-Hardil. gerade am Ruscthen.

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



Re: Fussweg nach Taramis (Zephyr, 12. Dez 1996, 11:53:29):
~#! rn=Hardil rt=850387875
~#! tid=850387875
hmm.. Hahdihl - grad Zauberer muessen da nicht mehr durch.. ;)

Gruss, Zeph, kennt wenigstens 3 Wege nach Taramis ohne Rutsche

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



werte... (Mindblast,  9. Jan 1997, 14:05:33):
warum bekomm ich eigentlich bei werte, trotzdem ich ihn auf max hab, keine
genauen angaben, also in zahlen ueber den wert eines gegenstandes ? Der
entsprechende Chaotendaemon liefert richtig detaillierte Angaben...

Mindy...

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



Re: werte... (Wargon,  9. Jan 1997, 14:34:00):
~#! rn=Mindblast rt=852815133 rg=gilden.zauberer
~#! tid=852815133
Vielleicht ist das ein spezielles Feature der Chaoten?
  Wargon

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



Re: Re: werte... (Asmodis,  9. Jan 1997, 14:54:49):
~#! rn=Wargon rt=852816840 rg=gilden.zauberer
~#! tid=852815133
Wenn das die Chaoten koennen, wieso sollen das alle anderen Gilden
auch koennen ? ist vielleicht wirklich nur bei denen :)

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



Re^3: werte... (Felagund,  9. Jan 1997, 15:12:42):
~#! rn=Asmodis rt=852818089 rg=gilden.zauberer
~#! tid=852815133
Hehe..dir kanns ja egal sein, Asmo. Hast doch eh in jeder Gilde sonen doofen
2ti stecken ;)

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



Re^4: werte... (Asmodis,  9. Jan 1997, 15:13:43):
~#! rn=Felagund rt=852819162 rg=gilden.zauberer
~#! tid=852815133
Noe, in der Magiergilde hab ich noch keinen :)

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



Re^5: werte... (Jasper,  9. Jan 1997, 20:05:45):
~#! rn=Asmodis rt=852819223 rg=gilden.zauberer
~#! tid=852815133
wechsel in ein mud wo es viel mehr gilde gibt 
den namen hab ich allerdings gerade vergessen :)
kannst dir ja von fela das password geben lassen ist eh kaum noch da


ps:zombie crashte gerade :)

Jasper [Blubber-Mode-ON]

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



Re^6: werte... (Asmodis,  9. Jan 1997, 22:00:17):
~#! rn=Jasper rt=852836745 rg=gilden.zauberer
~#! tid=852815133
Naja, das hift mir wenig (von kleinen ausnahmen mal abgesehen :) )

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



werte... (Mindblast, 10. Jan 1997, 09:59:36):
naja.. aber waer doch mal ne feine Sache, dass sich da auch was an der
Genauigkeit des Spells veraendert, wenn man ihn besser kann... 

seufz...
Mindy...

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



Re^6: werte... (Felagund, 13. Jan 1997, 02:42:03):
~#! rn=Jasper rt=852836745 rg=gilden.zauberer
~#! tid=852815133
wenigstens is Fela kein Nasenbaer, der seine Passwoerter im Suff aendert, und
dann wochenlang nicht mehr in besagtes mud reinkommt ;)

Fela (Anti-Nasenbaer-Verein ;))

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



Re: werte... (Silvana, 20. Jan 1997, 08:38:31):
~#! rn=Mindblast rt=852886776 rg=gilden.zauberer
~#! tid=852886776
Es gibt Sprueche, die mit zunehmender Faehigkeit auch genauer oder
ausfuehrlicher werden. 'werte' gehoert nicht dazu. Es muss ja wenigstens
einen Spruch geben, wo die Chaoten mehr koennen, sonst werden sie zu
neidisch. :)

  Silvana

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



werte... (Mindblast, 20. Jan 1997, 08:39:39):
hmmm... na gut.. iss n argument... aber dass sich an dem spell garnix
verbessert, wenn man ihn besser kann iss auch mist... :-/

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



Re: werte... (Bombadil, 20. Jan 1997, 08:53:17):
~#! rn=Mindblast rt=853745979 rg=gilden.zauberer
~#! tid=853745979

Man kann den Spell ja fuer niedere Level abwerten, dann kan man sich in den
hoeheren Leveln wenigstens darin verbessern.

--> schmarrn

Bombadil

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



Re: Re: werte... (Mindblast, 20. Jan 1997, 08:55:21):
~#! rn=Bombadil rt=853746797 rg=gilden.zauberer
~#! tid=853745979
*grins* oder so... mich solls nich stoeren... aber bringen tuts dann jetzt
auch nix mehr... dann lieber so lassen wie es iss... 

Mindy...

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



Schutzhuelle (Silvana, 30. Jan 1997, 12:46:17):
Hi, ihr.
So leid es mir fuer Euch tut: Die Schutzhuelle ist jetzt schwaecher 
geworden. Das  war im Sinne einer brauchbaren Balance einfach notwendig.

  Silvana.

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



Rueste (Silvana, 30. Jan 1997, 13:00:03):
Tja....
Auf die Gefahr, dass ich mich unbeliegt mache:
Der Rueste-Spruch hatte einen Bug (2 Zeilen vertauscht).
Das ist jetzt behoben. Dummerweise ist der Spruch dadurch bei sehr
starken Ruestungen (Hydraruestung etc) deutlich schlechter. Bei#+
anderen Ruestungen sollte es kaum etwas ausmachen.

  Silvana

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



Patryn (Silvana, 30. Jan 1997, 13:04:06):
Ach ja, noch was:
Ab sofort ist Patryn auch offiziell fuer die Gilde mitverantwortlich.
Bei Fehlern etc besonders bei Komponenten und Bib etc koennt ihr ihn
jetzt auch offiziell um Rat fragen (haben ja sowieso alle getan).

  Silvana.

PS: Nein, das steht in keinem ursaechlichen Zusammenhang mit den beiden
    vorangegangenen Artikeln.

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



Schutzhuelle (Hardil,  3. Feb 1997, 13:33:06):

Also ich finde die 'neue' Schutzhuelle klasse... 

Originallog:

schutzhuelle
Du konzentrierst Dich auf Deinen Schutz.
Kurz blitzt eine gueldene Aura um Dich auf.
Du hast jetzt 210 Lebenspunkte und 177 Magiepunkte.
Lebenspunkte: 210 (210)  Magiepunkte: 177 (226) Stabmagie: 73 (75)
Flammende Hand (aus)  Wille (aus)  XHand (aus)  Schutzzauber (Schutzhuelle)
Der Zauberspruch ist missglueckt.
Du lernst aus Deinen Fehlern.

Man beachte: Er klappt, ich habe ihn gesetzt, und trotzdem lerne ich noch aus
meinem Fehler. :)

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



Re: Schutzhuelle (Patryn,  3. Feb 1997, 13:33:52):
~#! rn=Hardil rt=854973186 rg=gilden.zauberer
~#! tid=854973186
wenn du denkst....mit dieser schutzhuelle solltest du sehr vorsichtig sein

------
patryn

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



Re: Schutzhuelle (Asmodis,  3. Feb 1997, 14:39:44):
~#! rn=Hardil rt=854973186 rg=gilden.zauberer
~#! tid=854973186
Das ist kein bug, das ist ein feature :)
Gabs mit der 'alten' Schutzhuelle auch schon ...

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



Re: Re: Schutzhuelle (Anatol,  3. Feb 1997, 19:52:37):
~#! rn=Asmodis rt=854977184 rg=gilden.zauberer
~#! tid=854973186

Ich schaetze mal, die Umstehenden sahen das nicht ganz so guelden ;-)
In diesem Fall Schwarzseher, 
Anatol


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



Miniquests (Silvana,  4. Feb 1997, 09:41:41):
Hi.
Bei den Aufstiegsanforderungen bezueglich Miniquests hat sich nen bisschen
was getan, wie den niedriger-stufigen Spielern auffallen wird, wenn sie
Llystrathe mal nach Aufgaben fragen. Damit sollte es wieder moeglich sein,
aus eigener Kraft den 2. Gildenlevel (und die danach) zu erreichen.

  Silvana

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



Zauberstab (Snuggle,  9. Feb 1997, 03:34:31):
Hm, ich hab mal gehoert, der Zauberstab soll mit der Zeit ne ganz gute Waffe
werden.. Ist da diesmal ne Klammer zu unsern Ungunsten verrutscht?

---- Recall start ----
Boing sagt froehlich zu Dir: Das ist die richtige Waffe fuer dieses Mud!
Ein Stiel einer Zwergenaxt sollten eigentlich alle benutzen.
Ich werde mal sehen, ob ich Jof davon ueberzeugen kann.

Trotzdem ueber diese seltsamen Anwandlungen unserer Goetter grinsend..
Snuggle

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



Re: Zauberstab (Silvana,  9. Feb 1997, 19:38:50):
~#! rn=Snuggle rt=855455671 rg=gilden.zauberer
~#! tid=855455671
Diese seltsame Einschaetzung des Zauberstabs liegt daran, dass er
rein rechnerisch eine Waffenstaerke von 0 hat. Das er aber trotzdem
Schaden macht - wenn auch nicht eben viel, verglichen mit dem, was
gute Kaempfer oder sowas anrichten, wir jeder im Kampf austesten
koennen. Dass er nicht so viel Schaden machen kann, wie 'hand'
bei feuerempfindlichen Monstern wird hoffentlich jeder einsehen.

  Silvana

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



Wenn der Gegner zaubern tut, (Snuggle, 11. Feb 1997, 15:17:19):
..dann koennen wir was erzaehlen. Und genau deshalb will ich jetzt noch ein
bisschen rumnoelen. Zauberer waren (zu?) stark, sind immer noch stark, aber
gestern musste ich mich in meien Schranken weisen lassen - von einem
Magiemonster, dass sich von meinen Zauberschild nicht im geringsten
beeindrucken liess. Ich hab staendig Feuerbaelle abbekommen, die weder
reflektiert wurden, noch von meiner schutzhuelle abgemildert. 
(Ja, ich weiss, dass haengt damit zusammen, wie der Schaden verursacht wird,
aber daas war eindeutig ein Spruch, der vom Schild reflektiert werden
sollte).

genug genoelt,
Snuggle - findet dass Magieschaden auch wie Magieschaden behandelt werden
sollte.

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



Re: Wenn der Gegner zaubern tut, (Silvana, 11. Feb 1997, 20:28:27):
~#! rn=Snuggle rt=855670639 rg=gilden.zauberer
~#! tid=855670639
Aeh, Snuggle...
Erstens gehoert sowas, wenn's denn ne Bug ist, nicht in die MPA,
sondern mittels 'zbug' in mein Repfile und
Zweitens kann ich damit nur was anfangen, wenn Du mir auch sagst,
um welches Monster es sich ueberhaupt handelt und von wen es
ist (siehe identifiziere) und wo.

  Silvana (kann mit Genoele ohne Inhalt herzlich wenig anfangen)

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



nochmal rumnoelen (Snuggle, 13. Feb 1997, 17:21:43):
Hi Ihrs,

nachdem ich nun in meinen Zweig die beiden Magistersprueche gelernt hatte,
wollte ich mal ein wenig ueber den Tellerrand hinausschauen und mich
in einem andern Zweig ueben. Hochmitiviert trete ich von meinem Posten
zurueck,
besorge mir noch einen +int ring, lasse mich segnen, will den ersten 
Magisterspruch des neuen Zweiges lernen (schaff ich sogar), frage neugierig
wie wir Zerge nun mal sind Llystrathe gleich danach und erfahre, dass ich ihn
aeusserst uebel beherrsche. 
*umpf*
*
*bittere Enttaeuschung*
+
Auf Nachfrage erfahre ich, dass das jetzt der Standard ist. Egal wie 
intelligent, neue Sprueche gibts immer auf aeusserst uebel und da frage ich
mich: muss das sein?
Es heisst immer die Gilde x ist zu stark, die Gilde y ist zu doof, aber
wenn ich einigen Kaempfern (und die gips noch nicht so lange) beim metzeln
zuschaue, finde ich uns Zauberer bestimmt nicht mehr zu stark und es wurden
ja vor allem bei den Schutzspruechen in letzter Zeit ein paar Fehler
korrigiert - voellig in Ordnung, Bugs muessen raus, wenn sie gefunden werden
(dagegen, dass man sie vorher noch ein bisschen ausnutzt, spricht eigentlich
nichts :-)

Aber:
Es gibt keine andere Gilde (und bis auf die Bierschuettler hab ich alle
getestet), in der man, vor allem bei den fortgeschrittenen Faehigkeiten,
nicht einen mehr oder weniger hohen offset bekommt. Einen Magisterspruch,
der teuer ist und nicht beliebig oft hintereinander gezaubert werden kann,
von schlecht oder ungenuegend hochzubekommen ist schon Arbeit genug, aber
von aeusserst uebel ist es einfach nur deprimierend.. (oder gibts zum
Ausgleich hoehere Lernraten?)

musste mal wieder noergeln,
Snuggle

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



Re: nochmal rumnoelen (Silvana, 14. Feb 1997, 00:00:48):
~#! rn=Snuggle rt=855850903 rg=gilden.zauberer
~#! tid=855850903
Hast Du's immer noch nicht gelernt, Snuggle-Schaetzchen? :)
Erst Silvana fragen, dann maulen. Ihr fangt zwar mit schlechteren Werten
an, lernt dafuer aber schneller. Gleicht sich in etwa aus.

  Silvana

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



Re: Re: nochmal rumnoelen (Snuggle, 14. Feb 1997, 15:12:03):
~#! rn=Silvana rt=855874848 rg=gilden.zauberer
~#! tid=855850903
nagut, in zukunft frag ich immer erst dich, silvana-maus :-)

Snug

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



Re^3: nochmal rumnoelen (Yantro, 14. Feb 1997, 16:53:35):
~#! rn=Snuggle rt=855929523 rg=gilden.zauberer
~#! tid=855850903
 Silvana ist keine Maus.... also echt nicht... alles, aber das nicht.

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



'erzwinge' (Hardil,  4. Mar 1997, 13:59:00):

Was mir beim Ueben aufgefallen ist...
Ich schauen dem Opfer tief in die Augen und sage 'Huepfe'.
Das stimmt eigentlich so gar nicht.
Eigentlich wuerde ich viel lieber sagen 'Wer nicht huepft der ist ein
Schalker'.
Dann huepfen die Leute schon fast von alleine.

Koennte das bittebitte implementiert werden? :-)

-Hardil.
Lieber Adept als Archon. (aber das kapeirt jetzt wieder eh keiner)

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



Re: 'erzwinge' (Jimdigriz,  5. Mar 1997, 01:12:37):
~#! rn=Hardil rt=857480340 rg=gilden.zauberer
~#! tid=857480340
Hardil schrieb:
>Lieber Adept als Archon. (aber das kapeirt jetzt wieder eh keiner)
Hmm cast a spell, summon, Wraith. Place it within your demense...
statt Shapeshifter (Fly 5) , *chodchodchodchodchodchodchodchod*

blubber....
 JdG

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



Re: Re: 'erzwinge' (Silvana,  6. Mar 1997, 08:45:30):
~#! rn=Jimdigriz rt=857520757 rg=gilden.zauberer
~#! tid=857480340
Ich kann nicht behaupten, jetzt mehr zu verstehen...

  Silvana (seufzend)

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



Re^3: 'erzwinge' (Felagund,  7. Mar 1997, 01:46:24):
~#! rn=Silvana rt=857634330 rg=gilden.zauberer
~#! tid=857480340
Tsts..Feen, keine Ahnung von guten Spielen.
Adept= ArchonII, eins der besten Spiele aufm C64, ArchonI zumindest, den
Nachfolger find ich weniger gelungen.
Also Hardi: dreh den Satz um, dann versteht den auch jeder ;)

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



Llystrathe streikt (Silvana, 14. Apr 1997, 13:53:00):
Wie der Titel schon sagt. Gruende? Siehe Wargons Artikel.

  Silvana

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



Trveshaende jetzt nutzen! (Bendeigid, 28. Apr 1997, 13:47:13):
Das Subject triffts eigentlich ganz gut. Nachdem wohl schon vor laengerer Zeit
mal drueber diskutiert wurde, ob man die von den Trves staendig "verlorenen"
Haende fuer Zauberer nutzbar machen koennte/sollte, das Ergebnis der
Diskussion aber irgendwo untergegangen ist, hab ich, nachdem nun die
Zustimmung der zustaendigen Magier zweifelsfrei nachgewiesen werden konnte,
ebenjenem Wunsch entsprochen und die Haende als Gildenzutat gekennzeichnet. Es
koennten allerdings noch alte Haende im Umlauf sein, also nicht gleich motzen.

Evtl. verschwinden dann ja auch die Haende aus den Laeden, wer weiss.... ;)

Z'par Servu,
              Bendeigid, eine winzige Gletscherfee angrinsend

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



Re: Trveshaende jetzt nutzen! (Patryn, 28. Apr 1997, 16:46:10):
~#! rn=Bendeigid rt=862228033 rg=gilden.zauberer
~#! tid=862228033
das mit dem 'aus dem laden verschwinden' vergessen wir man besser gleich
wieder, dafuer gibts einfach nicht genug kaempfer, welche sich die selbige
freiwillig abhacken :)
...aber ansonsten find ich die idee ganz lustig

------
patryn

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



Re: Re: Trveshaende jetzt nutzen! (Silvana, 28. Apr 1997, 19:49:41):
~#! rn=Patryn rt=862238770 rg=gilden.zauberer
~#! tid=862228033
*huestel*
Darueber unterhalten wir uns noch. :)
 
  Silvana

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



Re^3: Trveshaende jetzt nutzen! (Yantro, 29. Apr 1997, 10:17:39):
~#! rn=Silvana rt=862249781 rg=gilden.zauberer
~#! tid=862228033
und grins meine Frau nciht so sabbernd an, Bende... das ist MEINE :)

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



Re^3: Trveshaende jetzt nutzen! (Schlips, 30. Apr 1997, 00:06:53):
~#! rn=Silvana rt=862249781 rg=gilden.zauberer
~#! tid=862228033

Fuehrt das dann zu Kaempfer-Handabhack-Zweities?

Schlips

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



Re^4: Trveshaende jetzt nutzen! (Bendeigid, 30. Apr 1997, 11:30:13):
~#! rn=Schlips rt=862351613 rg=gilden.zauberer
~#! tid=862228033
Natuerlich fuehrt das nicht dazu, weil man das wohl auch nicht steuern
kann.... aber es waer natuerlich mal witzig, irgendwo ganze Horden von
Moechtegern-Trves stehen zu sehen, die sich auf Kommando die Haende
abhacken.... hihi

Bendeigid, kichernd 

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



Re^5: Trveshaende jetzt nutzen! (Dwight, 30. Apr 1997, 11:35:30):
~#! rn=Bendeigid rt=862392613 rg=gilden.zauberer
~#! tid=862228033
Dann moechte ich aber auch gebratene Zaubererkoepfe, denen eine Flamme im Hals
stecken geblieben ist
So als Wegzehrung ;-)

Dwight

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



Re^6: Trveshaende jetzt nutzen! (Janice, 30. Apr 1997, 16:40:31):
~#! rn=Dwight rt=862392930 rg=gilden.zauberer
~#! tid=862228033
Na wie ich die fiesen Magier kenne, baut bestimmt einer in einer Gilde den
spruch 'haendeabhacken' oder so ein
um ihre Haende fuerchtend, Janice

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



Re^7: Trveshaende jetzt nutzen! (Grimmborn, 30. Apr 1997, 17:06:07):
~#! rn=Janice rt=862411231 rg=gilden.zauberer
~#! tid=862228033
Kennst Du die Truhe?

GdA

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



Re^8: Trveshaende jetzt nutzen! (Janice, 30. Apr 1997, 17:37:36):
~#! rn=Grimmborn rt=862412767 rg=gilden.zauberer
~#! tid=862228033
jo, kennen andere sie auch ?

Janice hat trotzdem angst :-)

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



Re^7: Trveshaende jetzt nutzen! (Patryn,  2. Mai 1997, 09:17:16):
~#! rn=Janice rt=862411231 rg=gilden.zauberer
~#! tid=862228033
oh...gute idee, wer von den kaempfern in die kneipe der zauberer moechte
zahlt eine hand, der automat fuer die dazu noetige aktion steht direkt
am eingang ;)

------
patryn

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



Re^8: Trveshaende jetzt nutzen! (Silvana,  2. Mai 1997, 09:18:27):
~#! rn=Patryn rt=862557436 rg=gilden.zauberer
~#! tid=862228033
Nach der 'Aktion' sollte der Kaempfer das Tanken allerdings auch
noetig haben...

  Silvana

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



Re^9: Trveshaende jetzt nutzen! (Grimmborn,  2. Mai 1997, 09:27:34):
~#! rn=Silvana rt=862557507 rg=gilden.zauberer
~#! tid=862228033
Die Zauberer sind zu stark! Sofort abwerten!

Grimmborn der Atheist

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



Re^9: Trveshaende jetzt nutzen! (Fyt,  2. Mai 1997, 10:04:54):
~#! rn=Silvana rt=862557507 rg=gilden.zauberer
~#! tid=862228033
naja, sie koennen ja den stumpf im getraek desinfizieren...

ach nee, bei den zauberern gibt's ja nix handfestes zu trinken, oder?

fyt.

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



Re^10: Trveshaende jetzt nutzen! (Schlips,  2. Mai 1997, 13:23:10):
~#! rn=Fyt rt=862560294 rg=gilden.zauberer
~#! tid=862228033
kommt drauf an was Du unter was handfestem verstehst. richtig harte
Sachen gibts bei uns natuerlich net. Aber Pils und Koelsch kannste bei
uns auch haben ...

Schlips

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



kneipe (Trekan,  2. Mai 1997, 21:23:07):
ach was .. in der kneipe gibt es knallhaften whisky
und wilde kraeuterextracte.
Pils und koelsch sind nur zum ideln da
Trekan

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



idee (Sharia, 24. Mai 1997, 15:19:25):
Hi .. im Auftrag meines Ersties..
Ich faende ein "more" sehr angenehm bei der abfrage der faehigkeitenliste von
llystrathe...
nicht jeder hat einen 300 Zeilen Bildschirm :-)
nicht jeder hat einen 300 Zeilen Bildschirm :-)
Gruss i.A. Sharia

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



Re: idee (Schlips, 24. Mai 1997, 16:08:59):
~#! rn=Sharia rt=864479965 rg=gilden.zauberer
~#! tid=864479965
Gliech noch was dazu:
koennte man die Liste nicht nach den einzelnen Spellgruppen ordnen;
das waer dann etwas uebersichtlicher
momentan kann ich bei meine Anzeige keine sinnvolle Reihenfolge
erkennen. (Also die Spells aus einem Zweig sind ueber die gesamte
Liste verstreut; und die Reihenfolge wie ich sie gelernt habe
ists auch nicht).
- oder steckt hinter der Reihenfolge ein tieferer Sinn, den ich noch net
durchblickt habe

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



Re: Re: idee (Anatol, 24. Mai 1997, 16:45:36):
~#! rn=Schlips rt=864482939 rg=gilden.zauberer
~#! tid=864479965
Dein Erstie sollte einfach mal versuche, Llystrathe nicht 'faehigkeiten'
mitzuteilen, sondern Schlagworte wie "beherrschung", "verwandlung",
"hellsicht" o.ae. zu verwenden, bevor er Dich hier mit ueberfluessigen Artikel
beauftragt... :)

Anatol, Zauberer


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



Re^3: idee (Silvana, 24. Mai 1997, 18:10:09):
~#! rn=Anatol rt=864485136 rg=gilden.zauberer
~#! tid=864479965
Ich kann nur immer wieder empfehlen, die gute nach 'stichwort'
zu fragen. Sie weiss erheblich mehr, als die meisten vermuten

  Silvana

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



Re: Re: idee (Key, 24. Mai 1997, 20:46:40):
~#! rn=Schlips rt=864482939 rg=gilden.zauberer
~#! tid=864479965
Hmm Ordnung herrscht da schon etwas .... naemlich alphabetisch, von unten nach
oben :)
Aber eine Aufteilung nach angriffen, abwehren und sonstigen hielt ich auch
fuer sinnvoll ...

Key, im Auftrag seines Zweities :)=

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



hmm (Sharia, 24. Mai 1997, 21:07:13):
Ich weiss, ich weiss.. ich kenne ja die ganzen tricks wie ich weniger ausgaben
bekomme... aber ich haette einfach gerne in der auflistung der Gesamten
Faehigkeiten ein "more"... ist soviel mein erstie weiss nich soooo schrecklich
viel aufwand und wuerde das ganze etwas uebersichtlicher gestalten... 

Sharia.. immernoch fuer ihren doofen Erstie schreibend.

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



Re: hmm (Anatol, 25. Mai 1997, 17:09:15):
~#! rn=Sharia rt=864500833 rg=gilden.zauberer
~#! tid=864500833
Falls Du jemals auf den Gedanken kommen solltest, den Kram, den Dir Llystrathe
mitteilt, automatisch auf Platte loggen zu wollen, kaeme Dir ein "More"
aeusserst ungelegen.

Erfahrung :)
Anatol


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



Re: Re: hmm (Hadra, 25. Mai 1997, 17:49:51):
~#! rn=Anatol rt=864572955 rg=gilden.zauberer
~#! tid=864500833
ich dachte immer hier wird online gespielt, da sollte das die moeglichkeit auf
platte zu loggen vielleicht nicht unbedingt im vordergrund stehen

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



Re^3: hmm (Sharia, 25. Mai 1997, 21:55:15):
~#! rn=Hadra rt=864575391 rg=gilden.zauberer
~#! tid=864500833
hmmm also mich stoert ein "more" nich beim loggen weil ich sowas aehm ich
meine weil mein erstie sowas nich automatisch macht :-) (ich vielleicht schon
:-) )

Sharia, ohne erfahrung :-)

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



Komponenten (Silvana, 26. Mai 1997, 10:19:07):
Hi.
Ich hab nen paar der Komponenten ueberarbeitet. Sie sollten jetzt
eigentlich alle auf 'komponente' und aehnliches hoeren. Natuerlich
nur solche, die neu geclont werden, also bitte reboot abwarten, bevor
ihr meckert. :)
So, und nu werte ich die Zauberer etwas ab - oder vielleicht doch lieber
eine Gemeinheit fuer die Parawelt? :)

  Silvana

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



Re: Komponenten (Niete, 26. Mai 1997, 10:20:15):
~#! rn=Silvana rt=864634747 rg=gilden.zauberer
~#! tid=864634747
abwerten waere nicht genehm ;)

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



Re: Komponenten (Key, 26. Mai 1997, 10:20:19):
~#! rn=Silvana rt=864634747 rg=gilden.zauberer
~#! tid=864634747
Nix abwerten :)
Lieber noch so ein paar kleine Gemeinheiten in der Parawelt, die is eh viel zu
harmlos ;)=

Key stirbt gerne 

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



Re: Re: Komponenten (Silvana, 26. Mai 1997, 10:21:19):
~#! rn=Key rt=864634819 rg=gilden.zauberer
~#! tid=864634747
Ihr habt es so gewollt... :)
Silvana - hats diesmal schriftlich.

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



Re^3: Komponenten (Key, 26. Mai 1997, 10:22:00):
~#! rn=Silvana rt=864634879 rg=gilden.zauberer
~#! tid=864634747
Joop ich muss schliesslich noch einige male sterben :)
Key

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



Re^3: Komponenten (Fyt, 26. Mai 1997, 10:26:24):
~#! rn=Silvana rt=864634879 rg=gilden.zauberer
~#! tid=864634747

ok. abwerten.

Fyt, es silvana gebend. und zwar schriftlich...

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



Re^4: Komponenten (Felagund, 26. Mai 1997, 12:09:55):
~#! rn=Fyt rt=864635184 rg=gilden.zauberer
~#! tid=864634747
Wasn das fuern deal? Silvana darf gemein sein wenn sie dafuer die Zauberer
nicht abwertet?
Warum nicht beides?? ;)
Fela...immer gemein ;)

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



Re^5: Komponenten (Grimmborn, 26. Mai 1997, 12:34:30):
~#! rn=Felagund rt=864641395 rg=gilden.zauberer
~#! tid=864634747
Technisch unmoeglich.
Wenn sie die Zauberer abwertet, ist sie ja nicht gemein, sondern gerecht...

Grimmborn der Atheist

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



Re^6: Komponenten (Felagund, 26. Mai 1997, 14:24:56):
~#! rn=Grimmborn rt=864642870 rg=gilden.zauberer
~#! tid=864634747
habich gesagt, dass das gemein waere? sie ist halt lieber gemein als gerecht,
solang sie darf ;)

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



Re: Komponenten (Patryn, 26. Mai 1997, 17:14:11):
~#! rn=Silvana rt=864634747 rg=gilden.zauberer
~#! tid=864634747
Hi.
Ich hab die anderen paar Komponenten ueberarbeitet. *grins*
...also ueberall ein paar Details eingebaut, Typos und Bugs ausgebaut,
Typos und Bugs wieder eingebaut...aehem...ich hoffe nicht :)
also schaut die naechste zeit nochmal etwas genauer hin und bei problemen
und allzusinnlosen details (bei den vielen komponenten gar nich so einfach)
schlagt meinereiner...

------
patryn

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



Re^15: Weihebedingungen (Anatol, 10. Jun 1997, 16:43:30):
~#! on=Anatol ot=865953651 og=gilden.klerus
~#! rn=Morgar rt=865947079 rg=gilden.klerus
~#! tid=865272480
Maybe someone should create The Sword That Is Not a Sword - but not as
The Sword That Cannot Be Touched ... ;-)

> rgrinse silvana
Silvana->Anatol grinst Dich aus der Ferne an.

Anatol :)


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



Re^16: Weihebedingungen (Acrimon, 10. Jun 1997, 21:30:43):
~#! rn=Anatol rt=865953810 rg=gilden.zauberer
~#! tid=865272480
Hah ich kenne die Loesung! Soll ich sie verraten?

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



Re^17: Weihebedingungen (Grimmborn, 10. Jun 1997, 21:31:05):
~#! rn=Acrimon rt=865971043 rg=gilden.zauberer
~#! tid=865272480
Nein.

GdA

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



bestenliste (Birdy, 19. Jun 1997, 19:27:20):
HIHO :)

Also, ich habe mich gefragt,ob Silvana oder wer auch immer, nicht alle nicht
mehr spielenden Zauberer aus der Bestenliste raushauen koennte. :)
Ich erinner mich naemlich noch,als ich mit 17 % schon drinstand. *traeum*

Nastrowje !! Birdy

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



Re: bestenliste (Silvana, 20. Jun 1997, 07:34:27):
~#! rn=Birdy rt=866741240 rg=gilden.zauberer
~#! tid=866741240
Schon, nur hat die Sache einen Hacken: Woher weiss ich, wer nicht mehr
mitspielt? Es gibt leider keine Meldung an die Gilde, wenn jemand sich
loescht. Wenn Dir also jemand auffaellt, der sich geloescht hat und
trotzdem noch drinsteht, mail an mich.

  Silvana

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



Re: Re: bestenliste (Patryn, 20. Jun 1997, 12:44:27):
~#! rn=Silvana rt=866784867 rg=gilden.zauberer
~#! tid=866741240
wenn sich ein spieler selbst loescht, so wird in
der gilde automatisch 'austreten' aufgerufen.

------
patryn

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



Re^3: bestenliste (Morgar, 20. Jun 1997, 12:51:51):
~#! rn=Patryn rt=866803467 rg=gilden.zauberer
~#! tid=866741240
Noch ein Vorschlag zur Bestenliste. Koennten bei gleicher Bewertung zweier
Spieler nicht die Stufenpunkte entscheiden, wer vor wem steht und nicht der
Platz im Alphabet?

Morgar (Listengeil ;-) )

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



Re^4: bestenliste (Grimmborn, 20. Jun 1997, 12:53:51):
~#! rn=Morgar rt=866803911 rg=gilden.zauberer
~#! tid=866741240
Wo ist Dien Problem? Mach Dir halt nen Spieler namens Aaaaaaaab oder so, dann
bist Du vorne.
Denn ich vermute, darauf kommts Dir an...

GdA

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



Re^5: bestenliste (Bloodyharry, 22. Jun 1997, 01:36:19):
~#! rn=Grimmborn rt=866804031 rg=gilden.zauberer
~#! tid=866741240
Das war wieder mal ein bester Artikel von Dir fuer die Rubrik Schmarrn.

bh

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



Schlechte Nachrichten (Silvana, 30. Jun 1997, 08:12:35):
Schlechte Nachrichten, meine Lieben.
Der Erzmagier fuer Balance hat sich das Grossprojekt aufgehalst, alle
Gilden durchzurechnen und dummerweise mit den Zauberern angefangen.
Das Ergebnis jedenfalls ist drastisch. Eine ganze Reihe von Spruchen
wurden zum Teil deutlich abgewertet. Passt also auf Euch auf, wenn ihr
demnaechst metzelt...
Wartet aber bitte mit alzu harscher Kritik, bis ihr wisst, was er mit den
anderen Gilden anstellt. :)

  Silvana

PS: Ich hoffe mal, meine Soehne denken daran, dass mit einer Abwertung der
kampfstaerkeren Gilden das eine oder andere Monster bereits beim 
Begruessungsschlag toedlich ist. DIE gehoeren dann naemlich auch angepasst.

PPS: Eine etwas genauer Liste der Aenderungen kommt noch.

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



Re: Schlechte Nachrichten (Silvana, 30. Jun 1997, 08:29:18):
~#! rn=Silvana rt=867651155 rg=gilden.zauberer
~#! tid=867651155
Also, folgende Sprueche hat es getroffen:
Hand (schwaecher, vorsich mit Handschuhen)
Giftpfeil (vergiftet nicht mehr so stark)
Verletze (schwaecher)
Erdbeben (schwaecher)
Schutz (drastisch schwaecher)
Schutzhuelle (drastisch schwaecher)
Bann (Typo weg) ;-)
Stille (nicht mehr im Kampf wirksam)

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



Re: Re: Schlechte Nachrichten (Taragon, 30. Jun 1997, 08:33:12):
~#! rn=Silvana rt=867652158 rg=gilden.zauberer
~#! tid=867651155
WAAAAAAAHHHHHHHH!!!!!!

---Taragon, keine weiteren fragen---

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



Re: Schlechte Nachrichten (Slyfox, 30. Jun 1997, 09:49:06):
~#! rn=Silvana rt=867651155 rg=gilden.zauberer
~#! tid=867651155
Silvana, Du sagtest doch mal, Du hattest Dir ueberlegt, entweder
Du wertest die Zauberer ab oder Du proggst was fieses (Portal 8),
und haettest Dich dann fuer das letztere entschieden.
Dann koenntest Du ja das mit Portal 8 wieder ausbauen. Ich glaube, das
fanden viele nicht gut...

   Slyfox

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



Re: Re: Schlechte Nachrichten (Asmodis, 30. Jun 1997, 11:18:33):
~#! rn=Slyfox rt=867656946 rg=gilden.zauberer
~#! tid=867651155
ich war ja gleich fuer das Zauberer abwerten, aber mich hat ja
keiner gefragt :)

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



*wink* (Patryn, 30. Jun 1997, 11:33:17):
ab heute bitte ich darum, mails und anfragen bezueglich der zauberergilde
nicht mehr an mich zu richten da ich nix mehr in dieser gilde machen werde.
ansprechpartner sind also nur noch silvana und li.
viel spass noch...

------
patryn

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



Re: Re: Schlechte Nachrichten (Morgar, 30. Jun 1997, 12:01:51):
~#! rn=Silvana rt=867652158 rg=gilden.zauberer
~#! tid=867651155
Hm, jetzt stellt sich nur noch die Frage, was schwaecher und drastisch
schwaecher bedeutet.
Wenn Stille jetzt nicht mehr im Kapf wirkt, wozu ist der Spruch dann
eigentlich noch gut?

Morgar

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



Re^3: Schlechte Nachrichten (Silvana, 30. Jun 1997, 12:03:53):
~#! rn=Morgar rt=867664911 rg=gilden.zauberer
~#! tid=867651155
Den Unterschied zwischen schwaecher und drastisch schwaecher kann ich
nur in Zahlen ausdruecken, und das wollte ich eigentlich vermeiden.
Was Stille angeht: Du kannst damit immerhin noch einiges Scrolling
vermeiden. Ist jedenfalls nen Spruch, den ich ziemlich oft benoetige...
Silvana - leidet mit allen Zauberern.

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



Antwort fuer Morgar (Pyro, 30. Jun 1997, 13:19:33):
Deine Frage was schwaecher bedeutet kann ich dir, nachdem ich gerade mit ein
paar kleineren NPCs gekaempft hab beantworten: Man kommt sich vor, als waere
man von einem Pentium auf nen 386 umgestiegen: Es dauert und dauert und
dauert...

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



Re: Re: Schlechte Nachrichten (Schoko, 30. Jun 1997, 14:01:40):
~#! rn=Silvana rt=867652158 rg=gilden.zauberer
~#! tid=867651155

Jaaaa endlich wurden unsere Forderungen erhoert. Und da sage nochmal einer,
die Magier wuerden die Wuensche der Seher nicht beachten >;-)

Schoko (sorry aber das konnte ich mir nicht verkeifen)

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



Re^3: Schlechte Nachrichten (Zorro, 30. Jun 1997, 14:38:15):
~#! rn=Schoko rt=867672100 rg=gilden.zauberer
~#! tid=867651155
Ja Schoko aber es wird natuerlich jede gilde abgewertet damit der
Abstand/Vorsprung der Zauberer gewahrt, also freu dich nicht zufrueh Schoko...

Zorro geht da jede Wette ein.

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



Re^4: Schlechte Nachrichten (Morgar, 30. Jun 1997, 14:42:49):
~#! rn=Zorro rt=867674295 rg=gilden.zauberer
~#! tid=867651155
Also, das halte ich noch fuer ein Geruecht, dass die anderen Gilden so
abgewertet werden wie die Zauberer. Es sollen naemlich alle angepasst werden,
also werden sie etwa gleich stark.

Morgar (langsam aber sicher genervt)

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



Re^5: Schlechte Nachrichten (Hefe, 30. Jun 1997, 14:43:36):
~#! rn=Morgar rt=867674569 rg=gilden.zauberer
~#! tid=867651155
Was ja nur gerecht ist.

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



Re^5: Schlechte Nachrichten (Boing, 30. Jun 1997, 14:45:48):
~#! rn=Morgar rt=867674569 rg=gilden.zauberer
~#! tid=867651155
Wenn sie wirklich gleich stark werden, dann gibt's doch ueberhaupt
lkeinen Grund zur Beschwerde ... oder seh ich das falsch?
  Boing

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



Re^6: Schlechte Nachrichten (Morgar, 30. Jun 1997, 14:47:10):
~#! rn=Boing rt=867674748 rg=gilden.zauberer
~#! tid=867651155
Noe, gibt es ja auch eigentlich nicht, deshalb nerven mich ja solche Artikel
und die ganze Stimmungsmache gegen die Zauberer.

Morgar

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



Re^6: Schlechte Nachrichten (Slyfox, 30. Jun 1997, 14:47:35):
~#! rn=Boing rt=867674748 rg=gilden.zauberer
~#! tid=867651155
Unter den ganzen Gilden sehe ich die Chaoten und vor allem Abenteurern
ziemlich benachteiligt. Die koennte man vielleicht etwas aufwerten...
(nicht immer nur andere Gilden abwerten...)

  Slyfox

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



Re^6: Schlechte Nachrichten (Alpha, 30. Jun 1997, 14:47:49):
~#! rn=Boing rt=867674748 rg=gilden.zauberer
~#! tid=867651155
Wie waers damit: Alle gilden koennen garnix mehr. Dann sind wir alle gleich. 
Alpha, ist stolz auf seine Gilde, auch wenn sie nicht so stark (sein soll) wie
andere Gilden.

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



Re^7: Schlechte Nachrichten (Boing, 30. Jun 1997, 14:48:57):
~#! rn=Slyfox rt=867674855 rg=gilden.zauberer
~#! tid=867651155
Die Abenteurer sind keineswegs benachteiligt, man muss schliesslich auch
den Aufwand sehen, der in anderen Gilden in die Sprueche gesteckt werden
muss. Ausserdem war die Abenteurergilde immer als schwaechste Gilde geplant.
  Boing

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



Re^7: Schlechte Nachrichten (Hangover, 30. Jun 1997, 14:49:49):
~#! rn=Alpha rt=867674869 rg=gilden.zauberer
~#! tid=867651155
Naja, Alpha!

Zugegeben, die Bierschuettler kann man mit Sicherheit NICHT mehr grossartig
abwerten, aber auch Du wirst feststellen, dass es ganz bestimmte Stellen
im MG gibt, wo wir ganz gut aussehen.

Das einzig aegerliche an der Abwertung ist nur, dass ich mir jetzt Gedanken
um die Zukunft meines Zweitis machen muss ;-)

-Hangover

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



Re^8: Schlechte Nachrichten (Key, 30. Jun 1997, 16:18:29):
~#! rn=Boing rt=867674937 rg=gilden.zauberer
~#! tid=867651155
Hmm Boing du redest vom Aufwand den man betreiben muss um erstmal was zu
werden in der Gilde ... Naja das irgendwie zu vergleichen halte ich fuer sehr
schwer ...

Key

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



Re^9: Schlechte Nachrichten (Boing, 30. Jun 1997, 16:20:50):
~#! rn=Key rt=867680309 rg=gilden.zauberer
~#! tid=867651155
Ich hab auch nicht behauptet dass es einfach waere. Aber zumindest grob
abschaetzen kann man es ja wohl. Es ist offensichtlich, dass es deutlich
einfacher ist, in der Ab-Gilde auf sehr gute Werte zu kommen, als z.b.
in der Karategilde. Deswegen ist es auch nur gerecht, dass die Sprueche
der Ab-Gilde von der Wirkung nicht an einen Karateschlag ranreichen.
  Boing

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



Re^10: Schlechte Nachrichten (Zorro, 30. Jun 1997, 16:23:11):
~#! rn=Boing rt=867680450 rg=gilden.zauberer
~#! tid=867651155
Alle Macht den Scriptern...oder besser denen die noch scipten durften und sich
nicht erwischen liessen ...

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



Re^11: Schlechte Nachrichten (Fyt, 30. Jun 1997, 16:23:53):
~#! rn=Zorro rt=867680591 rg=gilden.zauberer
~#! tid=867651155

Kannst immer noch scripten. Ich kenne kein gutes Script, das im letzten
Jahr erwischt worden ist...

Fyt.

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



Re^12: Schlechte Nachrichten (Key, 30. Jun 1997, 16:25:16):
~#! rn=Fyt rt=867680633 rg=gilden.zauberer
~#! tid=867651155
Net mal die schlechten :)
Key

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



Re^13: Schlechte Nachrichten (Flavia, 30. Jun 1997, 16:27:42):
~#! rn=Key rt=867680716 rg=gilden.zauberer
~#! tid=867651155
Hm, scheinst Erfahrung damit zu haben Key ... :)

Eine Key frech anschauende Flav...

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



Re^6: Schlechte Nachrichten (Schlips, 30. Jun 1997, 16:30:23):
~#! rn=Hefe rt=867674616 rg=gilden.zauberer
~#! tid=867651155
also alle Gilden gleich stark ist ein Schmarrn. Schliesslich muss man
fuer manche Gilden erheblich mehr Aufwand betreiben um die die tolle
Staerke dieser Gilde nutzen zu koennen.

Schlips

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



Re^10: Schlechte Nachrichten (Phobos, 30. Jun 1997, 17:07:01):
~#! rn=Boing rt=867680450 rg=gilden.zauberer
~#! tid=867651155
Ich bin sehr dankbar fuer die angestrebte Vereinheitlichung
der Kampfkraft der Gilden. Das wuerde zum einen Hunderte
von Artikeln zum Thema Aufwerten/Abwerten in der Zeitung
einsparen, und damit zum anderen die aetzende Ruestungs-
spirale verlangsamen, die aus den immer staerkeren Gilden
resultiert.
Meiner Meinung nach sollten die Gilden sich weniger durch
Kampfkraft auszeichnen, sondern vielmehr durch Erreichen
desselben Ziels (Toeten eines NPCs) mit verschiedenen
Mitteln.
Auch das Verschaffen unlauterer Vorteile durch Einsatz von
Scripten zur Ueberbrueckung eines uebertrieben hohen Lern-
aufwandes koennte unterbunden werden, wenn man keine Vor-
teile mehr dadurch gewinnen kann.
Dann waehlt sich im Idealfall naemlich jeder die Gilde aus,
die er fuer die schoenste haelt, und deren Kampfmethoden
ihm am meisten zusagen, und nicht diejenige, die mit noch
weniger MP noch mehr Schaden verursacht. Und auch der Ein-
satz von Zweities koennte verringert werden, wenn sie nicht
staerker kaempfen, sondern bloss anders.

Nachteile, die mir dabei einfallen:
- Einige Gilden, die sich bisher nur durch stumpfsinniges
  Ueben ausgezeichnet haben, um die Prozentpunkte zu er-
  hoehen, wuerden u.U. an Attraktivitaet verlieren (die
  aber fuer Nicht-Scripter eh kaum bestanden haben wird)
- Einige Gilden verfuegen ueber zum Teil das Gleichgewicht
  im Mud stoerende Extras (Extremfall: Entgifte-Spruch),
  die den uebrigen Gilden vorenthalten werden.

Naja, wie auch immer, ich fasse es als positiv auf, dass
endlich ein Versuch in die richtige Richtung gemacht wird.


i.a. Mars  -  einziger Abenteurer unter den Top-60-Sehern

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



Re^11: Schlechte Nachrichten (Key, 30. Jun 1997, 17:11:07):
~#! rn=Phobos rt=867683221 rg=gilden.zauberer
~#! tid=867651155
Hmm naja also das halte ich fuer etwas uebertrieben, ich mein ich bin zwar
damals in die Chaosgilde eingetreten weil sie mir am besten gefallen hat vom
Aufbau, aber wohl auch weil ein chaot mehr Moeglichkeiten im Kampf hat.
So gibt es z.B. NPCs die ein Chaot besser schafft als nen Karateka, und so
sollte es auch bleiben.

Key

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



Re^12: Schlechte Nachrichten (Hefe, 30. Jun 1997, 17:59:42):
~#! rn=Key rt=867683467 rg=gilden.zauberer
~#! tid=867651155
Das ist richtig, Key, der Reiz der Gilden besteht ja darin, dass
sie verschiedene Staerken und Nachteile haben.
Doch wenn eine Gilde generell starker ist als die anderen und wenn
jede neue kampfbetonte Gilde die bisherigen noch uebertreffen muss, 
dann darf man sich nicht wundern, wenn Mitglieder aelterer Gilden
nach Abwertung der neuen schreien.
Insofern spricht mir Phobos mit seinem Artikel voll aus der Seele,
(besonders beim Thema Ruestungsspirale).

Hefe

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



Re^5: Schlechte Nachrichten (Taragon, 30. Jun 1997, 18:03:11):
~#! rn=Morgar rt=867674569 rg=gilden.zauberer
~#! tid=867651155
niemals, alle gilden gleich stark machen, wuerde JEGLICHEN spielspass einfach
deshalb entfernen, weil einfach alles einheitlich ist...
wir ueben mehr und gefaehrlicher also duerfen wir auch staerker sein

Taragon
(denkt schon an Bierschuetter die so stark wie zauberer sein sollen)
***schuettel***

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



Re^11: Schlechte Nachrichten (Taragon, 30. Jun 1997, 18:10:14):
~#! rn=Phobos rt=867683221 rg=gilden.zauberer
~#! tid=867651155
sorry
licht
schau
aber das halte ich fuer totalen schwachsinn
..
gerade die unterschiedlichen dinge die verschiedene gilden auszeichnet sind
das besondere, worin der spielreiz liegt
wenn alle gilden "gleich stark kaempfen, und nur anders" ist der gesamte reiz
weggeblasen
durch die verschiedenen eigenarten (entgifte usw.) wird auch das zusammenspiel
der gilden gefoerdert, bestes beispiel "ein kleriker zum entfroschen bitte"
oder "ein zauberer zum yrdstein aufladen bitte" usw...

Taragon
  von nix ahnung, aber davon ne menge

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



Re^6: Schlechte Nachrichten (Asmodis, 30. Jun 1997, 18:20:19):
~#! rn=Taragon rt=867686591 rg=gilden.zauberer
~#! tid=867651155
Hmm, war auch niemals die Rede davon, dass alle Gilden gleichstark gemacht
werden, das einzige, was momentan passiert, ist, dass uebertriebene Werte
(kamen bei den Zauberern gehaeuft vor) geschoenigt werden.
Dass eine Gilde etwas staerker ist, ist ja nicht so schlimm, nur soll
das nicht so ausarten, dass sie sich in einen Raum mit einem Megamonster
(jedenfalls fuer andere) stellen koennen und keinen Schaden abgezogen
bekommen, oder selbst das Viech mit 2 oder 3 Angriffen killen koennen,
ohne sich selbst anzustrengen.

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



Re^7: Schlechte Nachrichten (Taragon, 30. Jun 1997, 18:28:47):
~#! rn=Asmodis rt=867687619 rg=gilden.zauberer
~#! tid=867651155
akzepiert, asmodis...
aber ich finde, dafuer dass ein zauberer keine waffen benutzen darf (zb
vollstrecker) und somit nur auf seine sprueche und mp angewiesen ist, duerfen
meiner meinung nach seine kampfzauber ruhig ein bischen staerker sein ;)

Taragon
  durch und durch ueberzegter zauberer

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



Re^8: Schlechte Nachrichten (Key, 30. Jun 1997, 18:30:12):
~#! rn=Taragon rt=867688127 rg=gilden.zauberer
~#! tid=867651155
Hmm wieso sollte er net duerfen?
Wenn du so auf die Funktion des Todesschlages stehst zueck halt einen wenn der
NPC tief genug unten ist das du ihn mit einem Schlag erledigen kannst ;))

Key

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



Re^7: Schlechte Nachrichten (Grimmborn, 30. Jun 1997, 18:30:26):
~#! rn=Asmodis rt=867687619 rg=gilden.zauberer
~#! tid=867651155
Kann das sein, dass ihr von dem Begriff "gleich stark" keine vernuenftige
Vorstellung habt? Das heisst keineswegs, dass jeder alles gleichgut machen
kann, sondern dass im Schnitt, gegen alle Gegner, die lernintensiven Gilden
halbwegs gleiche Karten haben. OK, die Kleriker haben Vorteile bei Monstern
die vergiften, die Chaoten bei Monstern, die auf wechselnden Schadenstyp
empfindlich reagieren. Macht unterm Strich eine halbwegs aehnliche Kampfkraft.
Die Gilden sind nie so gemeint gewesen, dass sie sich wesentlich in der
Staerke unterscheiden, sondern sie sollten sich von Anfang an hauptsaechlich
in der Art unterscheiden. Ausnahmen natuerlich Abenteurer- und
Bierschuettlergilde.

Grimmborn der Atheist

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



Re^8: Schlechte Nachrichten (Key, 30. Jun 1997, 18:31:37):
~#! rn=Grimmborn rt=867688226 rg=gilden.zauberer
~#! tid=867651155
Argl!! nein!! Ich kann es doch nicht ....
Doch ich muss wohl ...
Stimmt Grimmi =;)

Uff geschafft ;))

Key

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



Re^8: Schlechte Nachrichten (Hefe, 30. Jun 1997, 18:31:57):
~#! rn=Grimmborn rt=867688226 rg=gilden.zauberer
~#! tid=867651155
Da muss ich Dir leider ausnahmsweise zustimmen, Grimmborn :-)

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



Re^9: Schlechte Nachrichten (Key, 30. Jun 1997, 18:33:48):
~#! rn=Asmodis rt=867688363 rg=gilden.zauberer
~#! tid=867651155
Noe asmo net ueberall ...
Denk mal an ein paar npx die zauber abwehren, auch bei kaempfernpc fuehle ich
mich mit nem karateka 100 mal sicherer, und frag mal robin ... :)

Key

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



Re^8: Schlechte Nachrichten (Asmodis, 30. Jun 1997, 18:34:37):
~#! rn=Grimmborn rt=867688226 rg=gilden.zauberer
~#! tid=867651155
Sicher, aber bisher war es so, dass Zauberer ueberall bessere Karten
haben, was hiermit hoffentlich passe ist.
Und die Zauberer gibts auch nicht erst seit gestern, sodass man es
laengst haette ausmerzen koennen, und nicht unsere Kritik als
Gejammer abtun !

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



Re^9: Schlechte Nachrichten (Escubar, 30. Jun 1997, 18:53:51):
~#! rn=Key rt=867688212 rg=gilden.zauberer
~#! tid=867651155
Hast Du das mal ausprobiert Key?

Man trifft schlicht und einfach nicht! Und kann anschliessend knapp 2 Minuten
nicht mehr zaubern.

Eisbaer Escubar, der schon seinen Vollstrecki zuecken wuerde wenn das anders
waere

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



Nachschlag (Silvana,  3. Jul 1997, 09:02:12):
Sorry.
In der Abwertung hat es nun, sozusagen als Nachschlag, auch noch den
Rueste-Spruch erwischt. Ebenfalls drastisch. Seht Euch also vor, Kinders.

  Silvana

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



Re: Nachschlag (Snuggle,  3. Jul 1997, 11:09:15):
~#! rn=Silvana rt=867913332 rg=gilden.zauberer
~#! tid=867913332
Na, ich will hoffen, dass unser verehrter Gleichgewichts-Erzi dabei bedacht
hat, dass wir un nicht bis ueber beide Ohren mit Ruestung behaengen
koennen/duerfen, wie andere Gilden.

Snuggle

PS _Ich_ habe noch nie einen Gegner atomisiert mit einem Schlag (im Gegensatz
zu einigen Kaempfern, die as wohl regelmaessiger mal schaffen -> Zauberer
aufwerten! :-)

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



Re: Re: Nachschlag (Patryn,  3. Jul 1997, 11:11:48):
~#! rn=Snuggle rt=867920955 rg=gilden.zauberer
~#! tid=867913332
da du bei den angriffsspells andere treffermeldungen erhaelst, erkennt man
schwer, wie stark man im vergleich zu anderen trifft...du wuerdest dich
wundern. ausserdem kann man sich als zauberer derzeit leider bis ueber
beide ohren mit ruestung zukleistern, und sie behindert nicht oder kaum...

------
patryn

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



zaubererbibliothek (Patryn,  3. Jul 1997, 12:55:06):
also nachdem ich nu aufgehoert hab zu schmollen, arbeite ich wieder in der
gilde mit: nur so als info, nich das noch 1000 laute fragen, warum ich hier
aufgehoert haette :)
als erste neue aktion meinereiner hab ich mal die hiesige bibliothek
renouviert. dabei wurden auch saemtliche buecher und schriftrollen
gruendlichsat ueberarbeitet. da dies eine sehr umfangreiche arbeit war und
unter zeitdruck geschah, bitte ich darum, fleissig ideen und typos abzusetzen,
ist nun mal ne menge text.

------
patryn

PS: ach so, in der bibo herrscht bitte ruhe :)

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



Re: zaubererbibliothek (Silvana,  3. Jul 1997, 16:14:44):
~#! rn=Patryn rt=867927306 rg=gilden.zauberer
~#! tid=867927306
Renauviert? Das ist, mit Verlaub gesagt, ne ziemliche Untertreibung...
Silvana (more --2%--)

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



Bibliothek (Birdy,  4. Jul 1997, 13:17:04):

Endlich haben wir auch eine Bibliothek auf dem Stand der Tatsachen. :)
Danke Patryn !
Zu den Abwertungen : wenigsten einen Schutzzauber haette Para* uns ja lassen
koennen ! :(

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



Brett (Birdy,  4. Jul 1997, 13:28:26):
Wo wir schon mal beim renovieren sind.
Was wird mit dem Brett in der Kneipe ?
  
Birdy

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



Lichtnebel (Yantro,  8. Jul 1997, 11:45:39):
Hallo Jammermagiekundige, 

mich erreichen alle 2-3 Tage Mails, dass es bei mir hinter dem Lichtnebel
einen ZT gibt und das Zauberer den nicht kriegen koennen. Das ist KEIN Bug,
sondern Absicht so, denn dies ist ein MUD und das steht fuer Multi-User und
wenn man als Zauberer was nicht kann, dann fragt man halt nen anderen, ob er
helfen kann. Dies ist meine Begruendung fuer den Spass da und das ist sowohl
von Boing als auch von Silvana so abgesegnet worden.

Yantro

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



Re: Lichtnebel (Key,  9. Jul 1997, 14:08:49):
~#! rn=Yantro rt=868355139 rg=gilden.zauberer
~#! tid=868355139
Yantro musst doch net alles verraten :)

Wer net rafft das es ein MUD ist darf dumm sterben ;)=

Key

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



magisterpruefung (Birdy, 15. Jul 1997, 17:26:39):
 Hi Silvana und dem Rest der Bande ! ;)

Also ich merkte heute bei meinem zweiten Versuch einer Magisterpruefung, dass
sie mit Metzeln nich mehr schaffbar ist.
Gruende: Der einzige Grund ist eigentlich nur die Abwertung unserer Sprueche.
Das letzte Mal hatte ich natuerlich noch keine Ahnung, wie so eine
Magisterpruefung
ablaeuft, aber jetzt schon, so dass ich dachte, dass es diesmal zu schaffen
sit.
Tja, leider habe ich die abwertung vergessen und so kam es, wie es kommen
musste,
irgendwann kurz bevor ich es geschafft haette, konnte ich nicht mehr tanken,
da ich ja jetzt beim kaempfen mehr magiepunkte
ausgegeben hatte und was schlimmer war, zu oft zu hart getroffen worden war.
Besonders zum Anfang, wo man sich ja nur auf Schutz verlassen kann, war es
oefter so, 10 LP - 200 MP.
So dass man gerade am Anfang so haeufig tanken muss, dass man schnell Pleite
ist.
Und wenn man Pleite ist, dann muss man eben zum Brunnen und dort saeuft und
saeuft man, man saeuft sich
den Wams voll und hat fast nix davon.

Als Fazit muss ich sagen:" Silvana ueberarbeite bitte die Pruefung. "

So das waer meine Meinung zu diesem Thema, vielleicht hatte es ja noch niemand
seit der Abwertung versucht, so dass ich jetzt gleich auf diesen Misstand
hinweisen moechte.

Nastrowje !
                       Birdy

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



Re: magisterpruefung (Key, 15. Jul 1997, 17:29:45):
~#! rn=Birdy rt=868980399 rg=gilden.zauberer
~#! tid=868980399
Hmm also ich glaube kaum das Silvana da nen Fehler machte ...
Eher wuerde ich mal behaupten du hast was falsch gemacht ... ;)

Geb mir mal einer nen zauberer der die pruefung machen kann, dann sehen wir
weiter ;)

Key

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



Re: Re: magisterpruefung (Silvana, 15. Jul 1997, 21:40:53):
~#! rn=Key rt=868980585 rg=gilden.zauberer
~#! tid=868980399
Ich kann Dir versichern, dass es auch nach der Abwertung noch zu schaffen
ist. Zugegeben, die Hardcore-Metzelmethode ist schwerer geworden, aber
es gibt so viele Moeglichkeiten... :) Versuchs doch mal ohne Metzeln...

  Silvana denkt . o O (Mehr zu sagen waere Spielerhilfe)


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



Re^3: magisterpruefung (Mindblast, 18. Jul 1997, 12:06:45):
~#! rn=Silvana rt=868995653 rg=gilden.zauberer
~#! tid=868980399
hmmm.. wenn ich mich recht erinnere versucht Aline seit einigen Monaten die
Pruefung ohne Metzelei zu knacken... :)

Mindy

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



taramis (Birdy, 24. Jul 1997, 15:36:26):
hiho !
nur mal so ne frage am rande.
Wann ist Taramis eigentlich endlich fertig ? ;)
Nastrowje !
Birdy

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



Re: taramis (Taragon, 25. Jul 1997, 01:02:56):
~#! rn=Birdy rt=869751386 rg=gilden.zauberer
~#! tid=869751386
Ich glaub, da wird seit Monaten regelmaessig nachgefragt, aber das einzige was
man regelmaessig als Antwort bekommt ist "bald".


Taragon
  -hoffend-

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



Re: Re: taramis (Silvana, 25. Jul 1997, 17:44:30):
~#! rn=Taragon rt=869785376 rg=gilden.zauberer
~#! tid=869751386
Dieses Jahr nicht mehr. 
  Silvana (fragt: deutlich genug?)

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



Re^3: taramis (Escubar, 25. Jul 1997, 19:44:17):
~#! rn=Silvana rt=869845470 rg=gilden.zauberer
~#! tid=869751386
Jou, dann werd ich mal puenktlich zum 1. Januar 1998 zur Besichtigung
schreiten ;)

Eisbaer Escubar, der dann sogar mal wieder was anders macht als quatschen

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



Re^4: taramis (Wurzel, 25. Jul 1997, 19:45:30):
~#! rn=Escubar rt=869852657 rg=gilden.zauberer
~#! tid=869751386
optimist.
das ist ein recycling-artikel, den kann man jedes jahr wieder posten :)

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



taramis (Birdy, 30. Jul 1997, 12:11:56):

Ich hab ja auch nur "mal" wieder gefragt. ;)

Nastrowje !!
             Birdy

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



Re: taramis (Li, 30. Jul 1997, 12:14:26):
~#! rn=Birdy rt=870257516 rg=gilden.zauberer
~#! tid=870257516
also abgesehen davon, dass man sowiso immer etwas hinausschiebt, kann ich zu
Taramis nur eins sagen: es wird eine riesige Stadt werden...
kein Wunder, dassSilvana so lange braucht.
Li

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



Magische Abstinenz ? (Taragon, 31. Jul 1997, 06:46:22):
Hi!
Soeben ist mir folgendes aufgefallen:

FINGER PATRYN:
Patryn ist anwesend,
und zwar von: Dresden.
Passiv seit: 02:58:01
Eingeloggt seit: Don, 31. Jul 1997, 02:37:26
Voller Name: Zaubermaus Patryn ist gluecklich
Rasse: Elf,  Gilde: Zauberer,  Geschlecht: maennlich
Magierlevel: 26
Datum des ersten Login: Mon, 11. Mar 1996, 13:23:06
Verheiratet mit: Llystrathe
z.Z. abwesend, Grund  : Ich bin derzeit in diesem MUD nicht zu sprechen. Ist
mir zu doof hier.
Bisher bereits 73 mal gestorben
Regionsmitarbeiter von: Ebene, Unterwelt.
Projekt: NICHTS...

man vergleiche "voller name" und "z.z. abwesend" und stelle sich folgende
fragen:
- wieso ist es zu doof hier ?
- warum bleibt patryn dann ueberhaupt eingeloggt, wenn es zu doof hier ist ?
- "patryn ist gluecklich" ... na watten nu ?

Moege sich Patryn sich nicht angegriffen fuehlen... aber das war mir doch
_etwas_ zu suspekt.

Taragon
  -schreibt noch schnell was, bevor Zeitung _auch_ abgewertet wird ;-)

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



Re: Magische Abstinenz ? (Patryn, 31. Jul 1997, 10:31:25):
~#! rn=Taragon rt=870324382 rg=gilden.zauberer
~#! tid=870324382
1.) warum ich gluecklich bin, geht dich gar nichts an. ich glaub nicht,
    dass dieser zustand durch dieses MUD bestimmt werden kann.
2.) warum es mir zu doof ist hier, geht dich gar nichts an...koennte aber
    mit solchen artikeln wie dem deinigen zusammenhaengen.
3.) ob, wann, wie, wieso und warum ich hier eingelogt bin, geht dich gar
    nichts an...und das wird wohl auch so bleiben.
4.) magische abstinenz? noe, ich progge weiter vor mich hin und hoffe, dass
    dich einer meiner NPCs erwischt. das sind dann schon 3 minuten, in denen
    du in der zeitung nicht ueber andere leute herziehen kannst.

------
patryn flamet mal mit

PS: solche artikel sind ja sonst nicht meine art, aber darauf war einfach
    mal ne antwort faellig, sorry

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



Gildentreffen auf Party in Muenster (Birdy,  1. Aug 1997, 15:48:33):

HIHO !

Ich wollte ein Treffen aller anwesenden Zauberer am Partywochenende in
Muenster vorschlagen.
Ich halte das fuer eine gute Idee. Wir koennten da naemlich gleich so einige
Sachen besprechen, fuer die wir hier im MUD manchmal wochenlang brauchen. :)

Nastrowje !!
Birdy

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



Re:Re:Gildentreffen auf Party in Muenster (Birdy,  1. Aug 1997, 16:05:19):

Ich wollte allen Jungzauberern, zu denen ich mich auch zaehle, die Chance
geben, alle alten Hasen kennenzulernen, Tips&Tricks auszutauschen, die
neuesten Infos von Silvana und Co. gleich vor Ort zu verarbeiten, ueber neue
Projekte im MG und im besonderen 
in unserer Gilde zu sprechen,Gildenprojekte zu disskutieren etc. .
Ausserdem dachte ich daran, unseren Gildenmagiern die Chance zu geben, die
aktuelle Stimmungslage unserer Gilde auszuloten, abzuchecken, welche Wuensche
fuer die Zukunft bestehen, 
sich unser Lob fuer ihre bisherige Arbeit einzuheimsen etc. .
Ich moechte mir diesem Treffen aber auch erreichen, dass das
Gildenzugehoerigkeitsgefuehl gesteigert wird. :)

Wie ihr seht, bin ich total idealistisch und ich schaetze, davon wird nach
einigen Antwortbriefen hier bald nichts von uebrig sein. :(

Nastrowje !!
Birdy

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



Re: Re: Magische Abstinenz ? (Taragon,  1. Aug 1997, 21:23:19):
~#! rn=Patryn rt=870337885 rg=gilden.zauberer
~#! tid=870324382
"...dich einer meiner NPC's erwischt."
--> deshalb diese "etwas" unnoetige und uebertriebene "Bibliothekarin" ?
*

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



Re: Re:Re:Gildentreffen auf Party in Muenster (Key,  2. Aug 1997, 04:00:13):
~#! rn=Birdy rt=870444319 rg=gilden.zauberer
~#! tid=870444319
Tips und Tricks austauschen ....
Nene net mit mir :)

Das was man wissen muss entnimmt man der bibliothek, aber tricks findet man
entweder oder man unterhaelt sich mal alleine mit nem zauberer .... Aber
oeffentlich alles verraten ... pff dann kann das ja jeder =;)

Key

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



Re: magisterpruefung (Fyt,  4. Aug 1997, 10:42:20):
~#! rn=Birdy rt=868980399 rg=gilden.zauberer
~#! tid=868980399

Komisch, sollten Zauberer nur an einer Stelle tanken koennen?

Fyt.

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



Re: Re: Re:Re:Gildentreffen auf Party in Muenster (Rochus,  4. Aug 1997, 14:50:01):
~#! rn=Key rt=870487213 rg=gilden.zauberer
~#! tid=870444319
Ach, was man auf solchen Treffen erfaehrt ist fuer
Gildenmagier meistens hoechst informativ :)

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



Erzmagister-Sprueche (Silvana, 11. Aug 1997, 08:29:05):
Wegen ein paar kleinerer Bugs sind die Erzmagistersprueche erst einmal
vollstaendig gesperrt. Ich hoffe, ich kann das bald beheben...
  Silvana

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



Rausch (Silvana, 11. Aug 1997, 11:04:36):
Dank eines Magisters, der sich in letzter Zeit nicht hat beherrschen 
koennen, ist das Rauschen von Spielern demnaechst nicht mehr moeglich.
Natuerlich nur fuer Spieler. NPCs koennen das auch weiterhin.
  Silvana

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



Rueste (Silvana, 11. Aug 1997, 11:08:03):
Ach ja, ich hab Rueste noch ein wenig den Vorstellungen der Balance 
angepasst... Kann mir kaum vorstellen, dass Euch das gefaellt, aber 
so isses nun mal. Mir gefaellt auch nicht immer alles... *sigh*
  Silvana

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



Ringe/Amulette (Silvana, 11. Aug 1997, 11:20:28):
Was positives zum Ausgleich:
Ringe und Amulette behindern nicht mehr im Kampf. Bei den Spruechen, bei
denen sich Behindern, tun sie das immer noch.
Das sollte die Kampffunktionen der Gilde geringfuegig beschleunigen...
  Silvana

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



Re: Rausch (Anatol, 11. Aug 1997, 18:24:39):
~#! rn=Silvana rt=871290276 rg=gilden.zauberer
~#! tid=871290276
Ich kann mich noch vage an die Anfaenge der Zauberergilde erinnern... das war
so um anno dazumal, als Bloodgore und Arty die fuehrenden "Kapazitaeten"
(heute laecheln wir muede ueber das damalige Wissen) waren. 
Irgendwo gab es ein Schild, auf dem stand, wer der erste Zauberer, der erste
Lehrling, der erste Magister war... und wer Mitglied im... war es "Gildenrat"?
... ist. Die Aufgabe des Gildenrats, damals bestehend aus... aeh... Silvana,
Li und Ancalagon (?), waere dann wohl gewesen, mit Leuten, die sich nicht
beherrschen koennen, irgendwie fertig zu werden - letztes Mittel der
Ausschluss aus der Zauberergilde.
Ich finde eine gezielte Bestrafung besser als ein generelles Ausschalten. Es
schafft ja auch keiner Email-ins-mud ab, nur weil irgendwer mal sp2_dt.exe
(16mb) als Attachment ans Mud schicken musste.

Zauberer, 
Anatol


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



Re: Re: Rausch (Silvana, 11. Aug 1997, 18:32:51):
~#! rn=Anatol rt=871316679 rg=gilden.zauberer
~#! tid=871290276
Ich hab halt derzeit weder Zeit noch Nerven oder Lust, das auszudiskutieren.
Ueber das Thema Zeit koennen einige derzeit ziemlich froh sein...
  Silvana (uebt derzeit mit einer GROSSEN Keule)

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



Re: Rausch (Dhojakt, 11. Aug 1997, 23:26:04):
~#! rn=Silvana rt=871290276 rg=gilden.zauberer
~#! tid=871290276
Wenigstens sich selber sollte man aber weiterhin berauschen koennen.
Dhojakt.

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



Re: Re: Rausch (Patryn, 11. Aug 1997, 23:28:15):
~#! rn=Dhojakt rt=871334764 rg=gilden.zauberer
~#! tid=871290276
genau DAS war das unlogischste an dem spell...man haette es eher explizit
ausbauen sollen, was ja nun aber ueberfluessig geworden ist.
im uebrigen bin auch ich gegen die bescheidung des berausche-spells,
derjenige (bloedmann) welcher sollte halt bestraft werden und gut ist.
sonst kommen demnaechst frosche, erzwinge, zwingtanz, illusion... dran

------
patryn

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



re ->Silvana (Birdy, 26. Aug 1997, 09:26:48):

Bei dem Teil mit Taramis warst du auch noch nuechtern. :)
Bei dem Teleportteil war ich mir nicht ganz sicher. ;)

Birdy in sich hinein grinsend**

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



Re: re ->Silvana (Silvana, 26. Aug 1997, 09:33:09):
~#! rn=Birdy rt=872580408 rg=gilden.zauberer
~#! tid=872580408
ICH war den ganzen Abend nuechtern. Ich sprach von den Leuten um mich rum. :)

  Silvana

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



Ueberraschung (Silvana, 26. Aug 1997, 10:45:12):
Tja, meine Lieben, es ist so weit, ich muss einen dummen Fehler meinerseits
korrigieren.
Leider hat die zahlenmaessige Begrenzung der Posten dazu gefuehrt, dass 
unter den Zauberern ein Konkurentkampf gefuehrt wird, der an Gemeinheit
kaum noch zu ueberbieten ist. Um diesem Zustand abzuhelfen werden jetzt
nach und nach ein paar Aenderungen aktiv:
1) Es gibt keine Top-Zauberer-Liste mehr.
2) Es gibt keine Erzmagisterposten mehr.
3) Die Magisterposten sind zahlenmaessig nicht mehr begrenzt, aber man
   kann als Magister nur einem Zweig angehoeren. Zweigwechsel sind nur
   alle 14 Tage zulaessig.
4) Paracelsus wird sich unter den gegebenen Unstaenden die Magistersprueche 
   noch einmal ansehen. Evtl werden einige Magistersprueche voellig
   ausgetauscht.
5) Duelle gibts damit natuerlich auch nicht mehr.

All diese Aenderungen brauchen einige Zeit, bis alles zueinander passt, also
bitte schreit nicht gleich, wenn nicht alles geht. Ich schaetze, dass 
fruehstens in einer Woche halbwegs alles sauber laeuft.

  Silvana

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



Re: re ->Silvana (Teddy, 26. Aug 1997, 11:19:01):
~#! rn=Birdy rt=872580408 rg=gilden.zauberer
~#! tid=872580408
Jaja, betrunkene Zauberer machen immer viel Mist ;)

Teddy
->schmarrn

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



Duelle (Anacrion, 26. Aug 1997, 12:07:29):
Ich denke, dass die Idee, dass ebn NICHT alle die ultimativen Zauberer im
hoechsten Gildenrang werden koenne, eigentlich ganz gut war (wer will schon
eine Gilde, in der ALLE Magister sind ? ). Das Problem dabei stellen doch
egentlich nur die Duelle dar, die in letzter Zeit mit immer haerteren Bandagen
ausgefochten worden sind.
Wenn man nun diese Duelle auf den Kern ihres Wesens beschraenkt, naemlich den
Vergleich der MAGISCHEN Faehigkeiten  zweier Zauberer, so wuerden auch die
'Gemeinheiten' verhindert, da sie hauptsaechlich aus nichtmagischen Dingen
(wie z.B. Ausruestung) resultieren.
Es waere doch z.B. moeglic, das (wie bei Pruefungen), alle
ausruestungsgegenstaende beider Zauberer draussen bleiben (ausser dem Guertel)
und sie im Kampfgebiet jeweils eine Ausruestung gestellt bekommen. Der
Prog-technische Aufwand hiervon duerfte, da die Routinen geschrieben wurden,
nahe bei Null liegen. Man muesste dann nur noch verhindern, dass sich
Duellanten VOR dem Duell verzaubern (z.B. beRauschen) und das Duell haette
eine vollkommen faire Form (eine Form, in der auch die Anzahl der Duelle
zurueckgehen duerfte, da man sich doch ueberlegt, ob man OHNE ueberlegene
Ausruestung gewinnen kann).

Anacrion - sich das erste mal an dieser Stelle geaeussert habend

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



Re: Re: re ->Silvana (Key, 26. Aug 1997, 12:46:52):
~#! rn=Silvana rt=872580789 rg=gilden.zauberer
~#! tid=872580408
ARGL!
Silvana was tust du ....
Ja es ist ein Konkurenzkampf, aber der ist ueberall.
Schau Dir mal die Chaoten an ....

Also das jetzt alle Zauberer genau gleich gut sind halte ich fuer nicht
besonderes gut. Die die sich auskannten haben die Duelle gewonnen, wer
jemanden herausfordert muss sich dessen halt bewusst sein.
Ausserdem hab ich oft genug mitgekriegt das jemand fuer einen anderen
zuruecktritt.

Ich weiss nicht was Dich dazu brachte diese Entscheidung zu faellen, aber ich
halte sie nicht fuer die richtige ....

Key dessen Zweitie keinen Magisterposten bekam weil er halt nur nen Zweitie
ist.

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



Re: Ueberraschung (Lefty, 26. Aug 1997, 16:47:59):
~#! rn=Silvana rt=872585112 rg=gilden.zauberer
~#! tid=872585112
Find ich gut :)

Lefty

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



Re: Re: Ueberraschung (Taragon, 26. Aug 1997, 17:33:40):
~#! rn=Lefty rt=872606879 rg=gilden.zauberer
~#! tid=872585112
Also ich weiss ja nicht... aber DAS ist seit der Abwertung das laecherlichste
was ich in meiner bisherigen Spielzeit gehoert habe.
Wo bleibt denn da noch der Sinn des Spieles ???
Wird wohl keinen hier kuemmern, aber wenn so ein Schmarrn tatsaechlich
eingefuehrt wird, bin ich raus :(
Weil dann macht es echt keinen Spass mehr hier...

Total frustriert
  Taragon

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



Re^3: re ->Silvana (Asmodis, 26. Aug 1997, 20:46:47):
~#! rn=Key rt=872592412 rg=gilden.zauberer
~#! tid=872580408
Hmm, auch mal rumsenfen:
Aaaaaalso ich finde es auch nicht gut, dass jetzt jeder Wurstzauberer
Magister werden kann, die Duelle waren doch immer was besonderes
und wer Magister werden wollte (oder gar Erzmagister), der musste
eben mal einen Tod riskieren.
Man koennte das Duell ja auch etwas veraendern und den Kaempfern
saemtliche Ausruestung abnehmen, den Alkoholstand auf 0 setzen und
eventuelle Verfolge-NPCs vernichten, wenn man ins Kampfgebiet getranst
wird. Dann kaeme es nur noch auf die Gildenfaehigkeiten an und
wie man sie einsetzt ...

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



Duelle (Silvana, 26. Aug 1997, 21:45:11):
Hab ich das richtig verstanden in dieser Rubrik und der zruf-History?
Der einzige Reiz der Gilde ist es, dass man sich am Ende gegenseitig
die Koepfe einschlagen muss? Sollte dem tatsaechlich so sein, moechte
ich mich hier an dieser Stelle in aller Form bei allen Zauberern
entschuldigen, dass ich Euch das so lange angetan habe... *sigh*
Fakt ist und bleibt: Solange ich die Gilde leite wird es keinen Zwang
zu Duellen geben. Wer sich gerne mit anderen die Koepfe einschlaegt,
kann das gerne in der Arena oder bei Jasper tun, aber zwingen werde
ich keinen mehr.
Allerdings ist mir bei der Lektuere der zruf-History so ziemlich 
jegliche Lust vergangen, noch mal etwas fuer die Zauberer zu machen.
Sollte also jemand, den ich fuer halbwegs kompetent halte, die Gilde
uebernehmen wollen - ich hab auch ohne Zauberer noch genug zu tun.

  Silvana

PS: Die Unterstellung, ich haette das nur aus Rache gemacht, weil
zwei Zauberer, mit denen ich persoenlich befreundet bin, abgesetzt wurden,
war hoffentlich nicht ernst gemeint. Ich kann mir nicht vorstellen, 
dass ihr SO tief gesunken seid...

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



Re: Duelle (Bloodyharry, 26. Aug 1997, 23:24:18):
~#! rn=Silvana rt=872624711 rg=gilden.zauberer
~#! tid=872624711
Amtsmuedigkeit gips ja bekanntlich auch in der Regierung...
Vieleicht moechtest Du aber nach einer Pause doch wieder einsteigen, denn
Deine Zauberer-Gilde ist wirklich spitze und es waere schade, wenn Du alles
endgueltig hinwerfen wuerdest.

bh

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



Re: Duelle (Liliput, 27. Aug 1997, 05:52:10):
~#! rn=Silvana rt=872624711 rg=gilden.zauberer
~#! tid=872624711
Vorab, so muss ich Key voll zustimmen!
In dem stets wachsenden Frust und emotionellen Auf und Ab beider, magiers und
Spieler der Zauberergilde, enttaeuscht es mich doch, dass lukrative
Vorschlaege und/oder konstruktive Argumente in der Form von Briefen oder
Artikeln einfach nur 'idle' herumstehen; anstelle von gemeinsamen
Ueberlegungen und Anstrengungen wird der radikale Kahlschlag der Gilde
weitergefuehrt. 
Es ist ja auch viel einfacher so. :(
Liliput

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



Re: Duelle (Key, 27. Aug 1997, 08:09:34):
~#! rn=Silvana rt=872624711 rg=gilden.zauberer
~#! tid=872624711
Hey Silvana ....

Also erstens gezwungen wurde keiner zu einem Duell, wer hoeher kommen wollte
musste halt beweisen das er es verdient hat .... Also ich fand es eine faire
Loesung.

Zweitens die Gilde jetzt abzugeben .... wieso?
Hab zrufe net mitgekriegt, aber dir Artikel in der Zeitung zeigen doch nur das
einige Leute an der Gilde haengen, und damit verbunden an dir als Gildenmag.
Es ist einfach nur Entaeuschung das die Gilde die meiner Meinung nach
ausgewogen war jetzt so eine grasse Aenderung erfahren soll!

Key

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



Re: Duelle (Anacrion, 27. Aug 1997, 10:43:50):
~#! rn=Silvana rt=872624711 rg=gilden.zauberer
~#! tid=872624711
Ich wollte an dieser Stelle nur zum Ausdruck bringen, dass der Zielpunkt der
gestrigen Diskussion auf -za, naemlich ein Zaubererquestgebiet einzufuehren,
in dem es ein Zeitmetzeln (scriptfrei) gibt, und dessen Rekordhalter jeweils
Erzmagister wird, eine tolle Loesung waere !! nicht nur ich Wurstzauberer, der
aber trotzdem eine Meinung hat (gell, Maverick), sondern auch andere,
namentlich Saramir und Taragon fanden diese Loesung absolut fair (und den
Spielspass erhoehend, muss ich aber wohl nicht dazu sagen).  Im Zuge dieser
Aenderung koennte man doch eigentlich die Bestenlisten in der 'Zeit-Form'
wiedererstehen lassen (JEDER Magister interressiert sich dafuer, wie schnell
den der Erzi war ;) ). 
Ich finde, dass wenn alle an der Gilde interessierten und involvierten so
zusammenarbeiten, meistens auch eine fuer alle akzeptable, wenn nicht gute
Loesung herauskommt.
Anacrion - hoffend, dass dies auch noch viele andere so sehen, damit der Frust
neuer Speilfreude weicht :)

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



Re: Re: Duelle (Patryn, 27. Aug 1997, 11:59:43):
~#! rn=Anacrion rt=872671430 rg=gilden.zauberer
~#! tid=872624711
also so nett die idee klingt, es ist nicht so ganz einfach umzusetzen.
was genau wird in dieser metzelquest zugelassen und was nicht?!
hauptprobleme sind autoload-sachen, die kann man nich einfach wegnehmen,
cursed-gegenstaende, nodrop, neverdrop u.s.w.
ich habe auch mit einem bug den seherwettbewerb bis zum letzten
gladiator durchgezogen (inzwischen wohl schon mehrere?) oder die hydra
in 13 sekunden gekillt, werte die dann kaum mehr zu ueberbieten sind oder
hoechstens durch andere bugs.
die idee fuersich ist gut, aber es ist zum einen nicht einfach und zum
anderen: wer wird jetzt magier nd setzt das um? weder silvana noch ich
duerften dafuer zeit finden.

------
patryn

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



Re^3: Duelle (Hangover, 27. Aug 1997, 12:23:40):
~#! rn=Patryn rt=872675983 rg=gilden.zauberer
~#! tid=872624711
Moin Zauberers!

Zu der Metzelquestidee wuerde ich noch vorschlagen, dass die erreichten
Zeiten nur ein paar Wochen gespeichert werden - wer dann seinen Titel
behalten will, muesste ihn eben immer mal wieder verteidigen...

War nur son Gedanke...

-Hangover

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



Re^3: Duelle (Quasimodo, 27. Aug 1997, 14:49:34):
~#! rn=Patryn rt=872675983 rg=gilden.zauberer
~#! tid=872624711
Man kann die Geschehnisse in der Metzelgegend loggen und das Log behalten,
wenn es einen neuen Eintrag in der Top-Was-weiss-ich zur Folge hatten und
diese auf Mogeln untersuchen. Bei Mogelversuchen hat man sich auf Lebenszeit
fure das Amt disqualifiziert.

Benoetigt natuerlich ne Definition von Mogeln.

Quasi

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



Re^4: Duelle (Fyt, 27. Aug 1997, 14:50:19):
~#! rn=Quasimodo rt=872686174 rg=gilden.zauberer
~#! tid=872624711

Ziemlich unrealistisch. Ich sag nur 'Scriptverbot' und 'schau Dich mal um'.

Fyt.

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



Re: Re: Duelle (Silvana, 27. Aug 1997, 18:08:35):
~#! rn=Anacrion rt=872671430 rg=gilden.zauberer
~#! tid=872624711
Ohne die Rubrik zu Ende gelesen zu haben, geschweige den die 28 mails:
Ich fand die Diskussion gestern recht fruchtbar und speziell diesen
Vorschlag (er stammte wohl von Asmodis urspruenglich) ueberdenkenswert.
Ich hab am Freitag Gelegenheit, mich RL mit Para abzusprechen, vorher
werde ich dazu nichts definitives sagen. Nur so viel:
Definitiv nie wieder Duellarena um den Posten zu bekommen.
Ueber 'Nie wieder Erzmagisterposten' hab ich nichts gesagt, obwohl
es sicher so geklungen hat... Nur erwartet bitte jetzt keine Wunder.
Dafuer ist immer noch Wargon zustaendig. :)

  Silvana

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



Re: Re: Duelle (Anatol, 27. Aug 1997, 18:16:56):
~#! rn=Key rt=872662174 rg=gilden.zauberer
~#! tid=872624711

Hey, was macht ihr da?
Na, also dass die Topliste weg ist, sollte nicht so sehr stoeren, denn
diejenigen, die sie unbedingt brauchen, haben in meinen Augen sowieso
keine verdient. Ich weiss, ich bin arrogant. Aber ich stehe dazu.

Umstrukturierung der Zweige... Ein sehr gewagter Schritt, aber ich finde,
das ist eigentlich schwer in Ordnung. Ich glaube, es gab nicht sehr viele
Ersties, die sich aus Prinzip aus dem "Great Game" um Posten und Sprueche
heraushielten. Aber es gab tatsaechlich Hickhack um Plaetze; das abzustreiten
waere dann doch sehr gewagt. Andererseits ist das auch eine ideale 
Gelegenheit, irgendwelche Gespenster zu sehen. Ich persoenlich neige zu
soetwas - das war noch ein Grund mehr, keinen Zweig zu waehlen... Beides
drueckte aber die Stimmung, beides brachte ein wenig Pratchett-Feeling.

Man kann jetzt stundenlang mosern, weil man gerne Duelle gefochten hat.
Weil man sie gewann. Es existieren Scripte, die die Gewinnchancen stark
erhoehen. Es gibt vielleicht auch Leute, die Spass an Duellen haben - 
auch wenn sie sie nicht gewinnen. 
Vielleicht sollten einige Noergler auch zwischen "Magister" und "Zweig"
differenzieren. Jemand, der selbst durch die Magisterpruefung muss und 
weder 'Loesung' noch grossartige Tips bekommt, wird nicht Magister werden
und Wurst bleiben.

Man kann sich aber auch freuen, dass jetzt _jeder_ den Zweig waehlen 
kann, den er persoenlich fuer den besten Zweig findet. Vielleicht ist
die Zeitspanne "14 Tage" nicht optimal - aber um Himmels Willen, sowas
kann zunaechst mal nur die Zeit beantworten.
Wenn man nicht mosert, koennte man vielleicht auch auf die Idee kommen,
Silvana ein paar Mails zu schreiben, wie man die Zweigerei gestalten 
koennte (Winz-Quests, zweigorientierte Pruefungen etc.), ohne dass sich 
zwei Spieler gegenueber stehen oder gegenseitig verdraengen. Programmieren 
kann es ja auch ein anderer, muss doch auch nicht gerade diejenige tun, 
die eh ein Manager-Terminplan hat, oder?

Eine spezielle Duellarena fuer Zauberer kann es doch - unabhaengig von 
Zweigen - eigentlich weiterhin geben, wer meint, seine Kraefte messen
zu muessen, kann das doch tun. Das waer' doch mehr als nur Code-Recycling,
finde ich...

Anatol, Zauberer 


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



Re^4: Duelle (Li, 28. Aug 1997, 10:31:45):
~#! rn=Quasimodo rt=872686174 rg=gilden.zauberer
~#! tid=872624711
soviel Aufwand nur fuer eine liste? Mach mal! :-(

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



Wahl! (Silvana, 28. Aug 1997, 21:37:53):
Hi, ihr Zauberer

Ok, ich sehe ein, die letzte Ueberraschung war gelungen, aber nicht eben
in Eurem Sinne. Um nicht noch mehr Geschrei zu verursachen, werde ich 
vor der naechsten Aenderung um Eure Meinung fragen, da diese Aenderung
mindestens genau so grundlegend sein wird, wie die letzte - es geht
noch einmal um die Magister/Erzmagisterposten.

Wahlmoeglichkeit 1:
Alles bleibt, wie es jetzt ist, nur die verbliebenen Unstimmigkeiten
werden noch beseitigt.
Vorteil: ist schnell erledigt
Nachteil: Keinerlei Herausforderung fuer Magister

Wahlmoeglichkeit 2:
Alles wird in den Ausgangszustand versetzt. Also begrenzte Posten,
Duelle etc.
Vorteil: Geht auch ziemlich schnell
Nachteil: Nachbessern werde ich daran nichts mehr, also muesst ihr mit
          den Unzulaenglichkeiten leben/sterben.
          Der Master macht wegen der Ueberpruefungen alle 45min
          ziemlich Lag.

Wahlmoeglichkeit 3:
Es wird eine Metzelarena geschrieben, die -aehnlich der Magisterpruefung-
sehr variabel ist. Man nimmt keinerlei Ausruestung mit (ausser Stab) und
kann in 1h zusehen, wieviel XP er/sie gemetzelt bekommt. Wer den hoechsten
Wert erreicht, kann Erzmagister seines Zweiges werden. Die Leistungen 
gelten dann aber nur fuer begrenzten Zeitraum, so dass sich ein 
Erzmagister staendig beweisen muss.
Vorteil: keine Duelle, trotzdem Erzmagister, stetige Herausforderung
         kein Lag, da nur geprueft wird, wenn jemand den Posten haben
         will.
Nachteil: Ziemlich gefaehrlich, wird ne Weile dauern, bis es fertig 
          ist. Keine Ahnung, ob das nicht Auswirkungen auf die Guete
          der Magisterspells hat...?

Und noch etwas, worueber es abzustimmen gilt:
Als die Gilde ins Leben gerufen wurde, war geplant, einen Spielerrat
zu waehlen, der sich um Verfehlungen von Zauberern untereinander oder
gegen andere kuemmert und (schlimmstenfalls) sogar ein Gildenbanish
aussprechen darf. Diesem Rat wuerden drei gewaehlte Spieler und zwei
Magier angehoeren. Wollt ihr das oder nicht? Falls ja, werde ich 
Kandidaturen entgegennehmen - falls nein... Dann muesst ihr eben mit
mir alleine klar kommen. :)

Fuer die erste Abstimmung steht im Spiegelsaal eine Wahlmaschine.
Fuer die zweite Wahl sammle ich ab sofort freiwillige Kandidaturen.
Wenn sich nicht mindestens vier Spieler freiwillig melden, werte ich 
den Vorschlag als abgelehnt.
Ach ja - Wahlzeit ist 2 Wochen von heute an.

  Silvana

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



Re: Wahl! (Key, 28. Aug 1997, 21:56:22):
~#! rn=Silvana rt=872797073 rg=gilden.zauberer
~#! tid=872797073
Darf sich mein 2tie auch melden?

Key

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



Re: Re: Wahl! (Anatol, 28. Aug 1997, 21:57:18):
~#! rn=Key rt=872798182 rg=gilden.zauberer
~#! tid=872797073

Silvana an alle Zauberer: Es duerfen Erstie-Zauberer waehlen. Keine Magier,
Silvana an alle Zauberer: keine Testies, keine Zweities.
...
Silvana an alle Zauberer: Ach ja - Kandidieren duerfen Zweities...

Noch Fragen? :)


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



Re^3: Wahl! (Key, 28. Aug 1997, 22:02:37):
~#! rn=Anatol rt=872798238 rg=gilden.zauberer
~#! tid=872797073
Ja noch eine
Wieso duerfen keine Zweities waehlen?

Key

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



Re^4: Wahl! (Silvana, 28. Aug 1997, 22:33:05):
~#! rn=Key rt=872798557 rg=gilden.zauberer
~#! tid=872797073
Inzwischen duerfen sie - nach kurzer aber deutlicher Abstimmung
ueber zruf

  Silvana

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



Zum Metzeln  (Birdy, 29. Aug 1997, 15:34:44):

HIHO !
Ich wollte mal fragen, wie das dann bei 3. mit den Spruechen fuer die Erzies
wird.

Birdy

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



Zweignamen (Birdy,  1. Sep 1997, 17:28:17):

Ich fragte neulich Basil nach den Zweigen.
Da sagte er was von Angriff, Schutz, Beherrschung, Beschwoerung, Hellsicht und
Illusion.
??? 

Birdy

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



Alchemistenladen der Gilde (Patryn,  2. Sep 1997, 20:02:00):
Hi Zauberers
------------

Um der allgemeinen Verwunderung vorherzukommen:
 Ab heute ist die Anzahl der kaufbaren Komponenten im Laden beschraenkt.
 Jeder Zauberer kann also nur noch eine bestimmte Anzahl an Komponenten
dort kaufen. Derzeit ist diese Anzahl noch recht hoch, aber sobald auch
die anderen Laeden umgearbeitet sind, wird die Verteilung noch geaendert.
Was sollen wir damit erreichen?
 Sparsameres umgehen mit den Komponenten.
 Suchen der Komponenten im MUD, es gibt ausreichend viele...
 Aufsuchen mehrerer Laeden.
Derzeit ist es ein Testlauf, aber auch Doktor Tod und Armax jammern
ueber zunehmende Komponentenknappheit... :)

------
patryn

PS: hat da jemand genoergelt? :)

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



Re: Alchemistenladen der Gilde (Hangover,  2. Sep 1997, 20:03:23):
~#! rn=Patryn rt=873223320 rg=gilden.zauberer
~#! tid=873223320
Moin Patryn!

Meiner Meinung nach eine sehr nette Idee - solange die Anfaenger
noch genuegend kaufen koennen, um ihre Sprueche zu ueben. DIe
sind doch mit der Ueberei (imho) gestraft genug :)

-Hangover

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



Re: Alchemistenladen der Gilde (Key,  2. Sep 1997, 20:07:30):
~#! rn=Patryn rt=873223320 rg=gilden.zauberer
~#! tid=873223320
Hmm also mir sind da ein zwei Zutaten bekannt die es nicht im MG gibt ....
Vielleicht auch net gab, weiss ja net was du so rumgespielt hast :)

Hmm und mit den Zutaten sparsmer umgehen? *gruebel* Wie macht man das? :)

Key

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



Re: Alchemistenladen der Gilde (Shorkan,  5. Sep 1997, 08:35:57):
~#! rn=Patryn rt=873223320 rg=gilden.zauberer
~#! tid=873223320
Hi
Das ist ein weiterer Schritt, einem den Spass am muddden zu nehmen.
Gerade in der Zauberergilde, wo man sehr stark von den Komponenten abhaengig
ist und wo man viel ueben muss, empfinde ich diese Beschraenkung als sehr
stoerend.
Jetzt rennen nicht nur alle umher um sich Geld fuer die Komponenten zu
beschaffen,
sondern auch noch um die Komponenten zu suchen.
Fuer gut Gespraeche und Abenteuer mit anderen Mudders bleibt da kaum noch
Wenn man nicht mehr so viel ueben muesste ... koennte man mit dieser
Einschraenkung leben.

Bei den Fischern heisst es Petri heil. Ich wuensche euch Kompi heil ;)

Shorkan

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



Re: Re: Alchemistenladen der Gilde (Hobo,  5. Sep 1997, 08:40:53):
~#! rn=Shorkan rt=873441357 rg=gilden.zauberer
~#! tid=873223320
Kompi heil? Heisst der Schutzpatron der Komponentensucher (=Zauberer) denn
Kompus? ;)

Hobo

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



Re^3: Alchemistenladen der Gilde (Grimmborn,  5. Sep 1997, 09:48:31):
~#! rn=Hobo rt=873441653 rg=gilden.zauberer
~#! tid=873223320
Hobo, ueberfordere doch bitte nicht einfache Geister mit altphilologischen
Kenntnissen. Bedenke, wir leben in einer Zeit, wo in Koelns feinster Strasse
"Koeln's erste Adresse fuer Maennermoden" existiert.
Merke: Mit dem Genitiv hats halt nicht jeder.

Grimmborn der Atheist

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



Re^4: Alchemistenladen der Gilde (Li,  5. Sep 1997, 09:51:26):
~#! rn=Grimmborn rt=873445711 rg=gilden.zauberer
~#! tid=873223320
dieses   's hat sich in Deutschland in den letzten Jahren so ausgebreitet, da
hat man das gefuehl, man waere in England. aber im Gegensatz dazu ist dashier
im deutschen voellig falsch. Ich frage mich, was im Deutschen durch das '
weggelassen wird: sprachkultur? intelligenz? der Genitiv?
Li

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



re:alchimistenladen (Birdy,  5. Sep 1997, 10:48:34):

Leider muss ich sagen, dass diese Komponentenaktion total ueberfluessig ist.
Shorkan hat recht, als Zauberer muss man massig ueben, diese Zeit wird jetzt
noch verlaengert, da man sich, ab einer bestimmten Grenze, jetzt auf die Suche
nach Komponenten machen darf. :(
Traurig.

Birdy

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



Re: re:alchimistenladen (Grimmborn,  5. Sep 1997, 10:56:26):
~#! rn=Birdy rt=873449314 rg=gilden.zauberer
~#! tid=873449314
Hmm, mir blutet das Herz, dass ihr aus lauter Uebe- und Sammelstress nicht
mehr dazu kommt, die schoenen Seiten des Mudlebens zu geniessen.
Auch auf die Gefahr hin, ketzerisches Gedankengut zu aeussern: Niemand wird
gezwungen, wer Kommunikation und Freunde aufgrund von Gildenstress
vernachlaessigt, kann sich da eigentlich nur bei sich selber beklagen...

Grimmborn der Ahteist

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



Re: re:alchimistenladen (Hangover,  5. Sep 1997, 11:04:34):
~#! rn=Birdy rt=873449314 rg=gilden.zauberer
~#! tid=873449314
Moin Zauberer!

Nachdem ich grade so ein zwei Jammerartikel gelesen habe muss ich nochmal
meinen Senf dazugeben:

1. man kann in gewissen Mengen Komponenten kaufen, das reicht imho
auch fuer einiges an Ueberei aus.

2. Es gibt Komponenten nicht nur im Laden der Zauberergilde, sondern
an diversen Orten im MG - teilweise sogar in recht grossen Mengen.
Wenn ihr Euch also im MUD nicht auskennt und deswegen an Euren Kram
nicht rankommt, schaut Euch mal um.

-hangover
(der ja bekannteremassen nen Zaubererzweiti hat...)

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



Re: Re: re:alchimistenladen (Patryn,  5. Sep 1997, 11:14:51):
~#! rn=Hangover rt=873450274 rg=gilden.zauberer
~#! tid=873449314
zumahl derzeit noch 2 laeden existieren, die zum teil billiger sind und
immer noch unendlich viele komponenten anbieten.
wenn bereits jetzt gejammert wird, so kann ich den naechsten wochen nur
mit freude entgegenschaun: jammern bis zum abwinken

------
patryn

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



idee (Birdy,  5. Sep 1997, 12:20:22):


koennte man unsere kneipe nicht fuer kleriker oeffnen ?
beim ueben passieren uns doch so viele boese sachen ! da waere ein kleriker,
der in der kneipe steht doch ganz praktisch, weil er dann hier auch tanken
kann !

Birdy

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



Re: idee (Hardil,  5. Sep 1997, 12:21:41):
~#! rn=Birdy rt=873454822 rg=gilden.zauberer
~#! tid=873454822
 Naja, ich weiss nicht. Dann lieber ein Kleriker-NPC, der fuer das
Taubheit-Heilen so viel Geld nimmt, dass man es sich doch lieber ueberlegt, ob
man nicht mit einem netten Kleriker "Treffpunkt Sandtiger" ausmacht. :)

-Hardil.

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



Re: Re: idee (Taragon,  5. Sep 1997, 12:22:52):
~#! rn=Hardil rt=873454901 rg=gilden.zauberer
~#! tid=873454822
Naja, lustig wird das dann wenn du 'blind' bist.
Nicht alle Spieler kennen die Wege so gut, dass sie blind auf Anhieb von der
Gilde zum Sandtiger finden ;-)

...

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



Re: idee (Patryn,  5. Sep 1997, 12:23:40):
~#! rn=Birdy rt=873454822 rg=gilden.zauberer
~#! tid=873454822
das einzige was du davon haettest waer, dass die kleriker beglueckt durch
unsere kneipe stuermen und euch alles wegtrinken :)
gegenvorschlag: wie waers mit einer begrenzung des getraenke? ;)

------
patryn

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



Re^3: idee (Hardil,  5. Sep 1997, 12:24:49):
~#! rn=Taragon rt=873454972 rg=gilden.zauberer
~#! tid=873454822
Also fuer alle, die bilnd den Weg zum Sandtiger nicht finden (vom Uebungsraum
aus):

w n o betrete pentagramm gehe durch spiegel 7 o o o o o (usw, bis es nicht
mehr weitergeht, weil man in der Akademie ist) w w w s s o o knuddel tiger

Reicht das?

-Hardil. Wurstseher, aber die einfachen Wege sind einfach Pflicht.

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



Re^4: idee (Taragon,  5. Sep 1997, 12:28:03):
~#! rn=Hardil rt=873455089 rg=gilden.zauberer
~#! tid=873454822
Hihihi, ich glaube da sind 2 x 'w' zuviel
Geh mal von der Akademie aus w w w s s o o und guck wo du landest ;-)
w s s o reicht aus 

Taragon
  ist in Bezug auf Wege _kein_ Wurstie

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



Re^5: idee (Hardil,  5. Sep 1997, 12:28:41):
~#! rn=Taragon rt=873455283 rg=gilden.zauberer
~#! tid=873454822

Hast recht.

-Hardil.

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



Re^3: idee (Taragon,  5. Sep 1997, 12:32:27):
~#! rn=Asmodis rt=873455392 rg=gilden.zauberer
~#! tid=873454822
Also Taubheit ist zumindest fuer diejenigen, die wie ich einen gewissen Bug
gefunden haben (der nicht genannt wird da er sonst ein Bug _war_) kein
Problem... aber je nachdem was man uebt, kann Blindheit doch schon ziemlich
nervig sein. Zum Beispiel beim Teleport, wenn man da wegen Blindheit nicht
einmal weiss wo man ploetzlich landet, hat man ein grosses Problem.

Taragon
  Heute gut drauf weil noch garnicht angeflamed worden ;-)

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



Re^4: idee (Hangover,  5. Sep 1997, 12:57:28):
~#! rn=Taragon rt=873455547 rg=gilden.zauberer
~#! tid=873454822
Moin Taragon!

Es soll im MG einen Gegenstand geben, der Dich auch bei Blindheit
sehen laesst...

-Hangover

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



Re^5: idee (Taragon,  5. Sep 1997, 12:59:00):
~#! rn=Hangover rt=873457048 rg=gilden.zauberer
~#! tid=873454822
Moin Hangover !
Ich kenne diesen Gegenstand. Aber wenn man blind _ist_ duerfte das Finden
dieses Gegenstandes auch ein Problem darstellen.
;-=)

Taragon
  Blind durch die Welt

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



Re^6: idee (Asmodis,  5. Sep 1997, 12:59:31):
~#! rn=Taragon rt=873457140 rg=gilden.zauberer
~#! tid=873454822
Dann hol ihn eben, bevor du blind wirst :)

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



Re^6: idee (Patryn,  5. Sep 1997, 13:02:43):
~#! rn=Taragon rt=873457140 rg=gilden.zauberer
~#! tid=873454822
finden ist das schlagwort....sich als zauberer ueber blindheit zu
beklagen ist mehr als peinlich...

------
patryn

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



Re^7: idee (Taragon,  5. Sep 1997, 13:07:11):
~#! rn=Patryn rt=873457363 rg=gilden.zauberer
~#! tid=873454822
Da hast Du mal wieder nur das verstanden, was du verstehen wolltest.
Sagte ich, dass _ich_ Probleme damit habe ?
Ich schrieb:
 Aber wenn man blind _ist_ duerfte das Finden
dieses Gegenstandes auch ein Problem darstellen.
Beachte das Wort 'man' ich sagte nicht 'ich'
Beziehen sollte sich dieser Artikel auf Anfaenger in der Gilde, die was weiss
ich Level 10 oder so haben und Gildenlevel 3 oder 4.
DIE duerften Probleme haben.

Taragon
  Hat endlich seinen alltaeglichen Patryn-Kommentar bekommen

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



idee (Birdy,  5. Sep 1997, 13:08:36):

das mit dem oeffnen koennte man ja nur so lange machen, bis taramis offen ist,
aber dann werden wahrscheinlich sowieso oefter andere gildenmitglieder hier
bei uns zu besuch sein :)
meine idee ist halt aus der not entstanden, komponenten fuer die sprueche, die
ich ueben muesste kann ich nicht mehr kaufen und so uebe ich halt die spruec
he ,die ohne sind
aber ich unterhalt mich auch sehr gerne, und zwischendurch helfe ich auch
anderen, ich wuerde vor langeweile ja sonst kaputtgehen.
darum faende ich es nett, wenn ein kleriker bei uns in der gilde waere
und gorog sagte vorhin zu mir, dass er schon gerne kommen wuerde, wenn er hier
tanken koennte = so is meine idee entstanden 

Birdy
PS: is wahrscheinlich ein bisschen durcheinander geworden, aber ich benutze
telnet pur, und wenn man da abschweift, hat man gewisse schwierigkeiten beim
schreiben laengerer sachen :)


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



Re^8: idee (Hangover,  5. Sep 1997, 13:09:12):
~#! rn=Taragon rt=873457631 rg=gilden.zauberer
~#! tid=873454822
Hiho!

Zu dieser "Diskussion"
(oder ist es doch nur Jammerei) faellt mir ein, dass der Reiz dieses
Spieles doch darin liegt, Loesungen fuer ein Problem zu finden...
gerade das macht den Spass aus, und gerade als Anfaenger. Ausserdem
duerfte die Mehrheit der Spieler hilfsbereit genug sein :-)

-Hangover

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



Re^9: idee (Taragon,  5. Sep 1997, 13:12:13):
~#! rn=Hangover rt=873457752 rg=gilden.zauberer
~#! tid=873454822
DAS ist ja wieder ein anderes Thema.
Allerdings muss ich Dir da Recht geben. Es ist wirklich so, dass man
eigentlich fast immer jemand findet der dann ploetzlich mit besagtem
Gegenstand neben einem steht.

Taragon
  -redet aus Erfahrung-

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



Re: idee (Mango,  5. Sep 1997, 15:21:51):
~#! rn=Birdy rt=873454822 rg=gilden.zauberer
~#! tid=873454822
jaaaaaaaaa, den zauberberg fuer alle gilden trinkbar machen

Mango, ist dafuer. ;)


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



idee (Birdy,  5. Sep 1997, 15:23:08):
so war das nie gemeint yaren :)

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



Re^4: idee (Janitze,  5. Sep 1997, 17:02:44):
~#! rn=Taragon rt=873455547 rg=gilden.zauberer
~#! tid=873454822
nun, fuer dieses problem gibs ne einfache loesung: mach die kristallkugel-
quest, da bekommste zwei neue befehle, der eine ist beschwoere. tja, dann
machste nur noch 'beschwoere taragon' und schon weisste wo du bist, also
blindheit ist beim ueben kein problem :)

Janice

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



Re^5: idee (Taragon,  5. Sep 1997, 17:04:46):
~#! rn=Janitze rt=873471764 rg=gilden.zauberer
~#! tid=873454822
Aehm, warum Kristallkugelquest ?
Dasselbe mache ich mit dem Zauberspruch 'finde' schon ewig ;-)
Wie ich bereits sagte, galt die Aussage den unteren Gildenleveln die diese
Moeglichkeiten nicht haben ,-)

Aber danke trotzdem.
  Taragon

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



Re^6: idee (Key,  5. Sep 1997, 17:08:04):
~#! rn=Taragon rt=873471886 rg=gilden.zauberer
~#! tid=873454822
Teste es dann weisste es!

Key

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



Re^7: idee (Taragon,  5. Sep 1997, 17:09:00):
~#! rn=Key rt=873472084 rg=gilden.zauberer
~#! tid=873454822
Aehm, ich muss ja nicht verstehen was du damit jetzt sagen willst.
;-)

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



Re: idee (Asmodis,  5. Sep 1997, 18:18:01):
~#! rn=Birdy rt=873454822 rg=gilden.zauberer
~#! tid=873454822
Naja, du solltest dir auch mal vor Augen halten, dass der
Zauberberg abgewertet wird, sobald die Kneipe auch fuer andere Gilden
offen ist.
Das war bei der Chaoskneipe auch schon so ...

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



Re: idee (Silvana,  5. Sep 1997, 22:12:26):
~#! rn=Birdy rt=873454822 rg=gilden.zauberer
~#! tid=873454822
Es gibt in der Umgebung der Gilde wirklich genug Heilstellen, die sogar
Spielerabhaengig reseten. Und wenn Taramis erst mal fertig ist... :)

  Silvana

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



Re: Re: idee (Teddy,  6. Sep 1997, 02:24:55):
~#! rn=Silvana rt=873490346 rg=gilden.zauberer
~#! tid=873454822
Es gibt Heilstellen in der Umgebung der Gilde?

Teddy, hat mal wieder keine Ahnung ;-(

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



Re^3: idee (Taragon,  6. Sep 1997, 14:15:58):
~#! rn=Teddy rt=873505495 rg=gilden.zauberer
~#! tid=873454822
Also die einzige Heilstelle, die mir bekannt ist, ist die Wasserstelle am
Portaleingang. Aber da saeuft man sich tot dran ;-)

Taragon
  hat auch keine Ahnung, aber davon ne ganze Menge

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



Re^4: idee (Silvana,  6. Sep 1997, 19:28:26):
~#! rn=Taragon rt=873548158 rg=gilden.zauberer
~#! tid=873454822
Jaja, manchmal haben Bluemchenpfluecker auch ihre Vorteile... Die
wissen wenigstens, wo man guenstig tanken kann. :)

  Silvana

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



magisterposten (Birdy,  8. Sep 1997, 12:06:14):

Ich moechte Silvana und Co. an dieser Stelle darauf hinweisen, dass ich immer
noch keinem Zweig beitreten kann, weil die Posten immer noch limitiert sind.
:(

Birdy

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



Re: magisterposten (Patryn,  8. Sep 1997, 12:23:04):
~#! rn=Birdy rt=873713174 rg=gilden.zauberer
~#! tid=873713174
ich moechte Birdy und Co. an dieser Stelle darauf hinweisen, dass die
Zukunft der Magisterposten noch nicht feststeht, da die Abstimmung noch
laeuft. Bis dahin muesst ihr euch schon (mindestens) noch gedulden...

------
patryn

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



magisterposten (Birdy,  8. Sep 1997, 14:01:42):

Oki !

Birdy sammelt seine Geduld und behaelt sie dicht bei sich. OMMM OMMM OMMM

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



gildenladen (Patryn,  8. Sep 1997, 14:42:30):
ab jetzt kann man den geist im gildenladen nach komponenten fragen.
er sagt dann, wieviel noch verfuegbar sind fuer den einzelnen...

ach ja, es besteht jetzt verwechslungsgefahr zwischen sturm- und
rabenschwungfedern dort. aufpassen also...der preisunterschied ist
betraechtlich ;)

------
patryn

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



mal ne frage (Birdy,  8. Sep 1997, 14:57:46):

fuellt der Zauberberg-Spezial jetzt schneller ab ? :(

Birdy

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



Re: magisterposten (Homm,  9. Sep 1997, 08:00:08):
~#! rn=Birdy rt=873720102 rg=gilden.zauberer
~#! tid=873720102
Das heisst HOMM!

Wuerdevoll verneigend
Papst Homm


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



zaubererlaeden (Patryn,  9. Sep 1997, 17:50:55):
die ueberarbeitung ist nun vollstaendig. die wirklich angestrebten
begrenzungen werden wirksam. man beachte bitte, dass eine voellig
neue komponentenverteilung und preisgestaltung durchgefuehrt wurde.
man muesste gut damit leben koennen, wenn man alles nutzt, denn es war
nicht sinn der sache, die komponenten quasi hinterhergeworfen zu
bekommen. lernende haben nun ein problem, zugegeben....aber es lernte sich
eh schon mal sehr viel schwerer...es rege sich doch bitte keiner auf.
wenn man alle laeden und fundstellen nutzt kommt man auch dann gut zurecht.

------
patryn

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



Re: zaubererlaeden (Asmodis, 10. Sep 1997, 03:45:56):
~#! rn=Patryn rt=873820255 rg=gilden.zauberer
~#! tid=873820255
Noch ein paar Fragen:
 - Bekommt man bei einem Reset wieder neue Komponenten zugeteilt,
   oder erst nach einem Reboot ??

 - Koennte man die Syntax im Gildenladen nicht wieder aendern,
   sodass man nicht alle zugeteilten Komponenten aufkauft, 
   wenn man 'kaufe komponente' eingibt ??

 - Werden die Komponenten im MG jetzt zahlreicher ?? So viele
   Verstecke gibts ja nicht bei manchen Sachen.

 - Wie waers mit einer Zaubererboerse, wo man seine 
   Komponenten zu einem guten Preis verkaufen kann,
   wenn man sie enicht braucht, und Anfaenger sich
   dann auch ausreichend bedienen koennen (wenn sie
   das noetige Kleingeld haben) ??


So, das wars fuers Erste.
 Asmodis (In Vertretung seines Hofzauberers)

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



Re: Re: zaubererlaeden (Patryn, 10. Sep 1997, 03:48:10):
~#! rn=Asmodis rt=873855956 rg=gilden.zauberer
~#! tid=873820255
- pro zeiteinheit onlinezeit gibts neue komps
- versteh ich nich?!
  meinst du ein 'kaufe alle komponenten' um alle derzeit kaufbaren komps
  zu kaufen? sowas ist zumindest in planung.
- ja, es ist auch so etwas in arbeit
- eine sehr gute idee, ich muss mal sehen

-------
patryn

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



laden (Birdy, 10. Sep 1997, 12:09:30):

Also 5 Stueck von jeder Komponente is ja wohl ein Witz. :(((((

Birdy

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



Re: laden (Patryn, 10. Sep 1997, 12:15:38):
~#! rn=Birdy rt=873886170 rg=gilden.zauberer
~#! tid=873886170
sehr vielsagend, birdy.
du gehoerst sicher auch zu den zauberern, die sich dran gewoehnt haben,
die komponenten quasi hinterhergeworfen zu bekommen. die kaempfer koennen
auch nicht in nen gildenladen gehen und sich ihre waffen/ruestungen
zusammenkaufen. die geballte anzahl von verschiedensten spruechen wurde
damals auch nur geduldet, weil die komponenten sicherstellen sollten,
dass man nich jeden spruch immer und ueberall anwenden kann.

------
patryn

PS: ja tatsaechlich, es gibt mehr als einen laden und angeblich soll
    es sogar ewige komponenten geben. fuer die meisten zauberer hier
    wohl inzwischen nicht mehr als ein geruecht...

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



warok-taramis (Birdy, 10. Sep 1997, 12:31:23):

Frage: Von wo im Warok sieht man Taramis ?
Muesste doch eigentlich zu sehen sein ? oder ?

Birdy

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



Re: warok-taramis (Silvana, 10. Sep 1997, 13:02:34):
~#! rn=Birdy rt=873887483 rg=gilden.zauberer
~#! tid=873887483
Es ist. Von wo? Von oben natuerlich. Ostoben, um genau zu sein.
  Silvana

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



Re: warok-taramis (Alpha, 10. Sep 1997, 13:38:32):
~#! rn=Birdy rt=873887483 rg=gilden.zauberer
~#! tid=873887483
Taramis, die Koenigsstadt des Cronoertals, liegt zu Fuessen des Warokgebirges.
Von hier oben wirkt die riesige Stadt wie Spielzeug, und doch kannst Du
erstaunlich viele Einzelheiten erkennen. So siehst Du zum Beispiel das
Koenigsschloss mit dem riesigen Schlossplatz, die enge, verwinkelte Altstadt,
aber auch die unschoenen, verfallenen Viertel im Osten der Stadt. Im Nordosten
scheint ein Rummelplatz zu sein, jedenfalls herrscht dort ein heilloses
Durcheinander von Buden.

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



Re: Re: zaubererlaeden (Iwo, 10. Sep 1997, 17:27:21):
~#! rn=Asmodis rt=873855956 rg=gilden.zauberer
~#! tid=873820255
Hallo Zauberers

Asmodis' Idee, wenig nuetze/gebrauchte Komponenten in einer Zaubererboerse
zusammenzufassen finde ich gut, allerdings koennte ich mir eine andere
Herangehensweise an den Komponentenpool vorstellen.
Mein Vorschlag lautet wie folgt :

- Als Zauberer kann /oder muss man sich die Komponenten, die man in einem oder
mehreren Zaubererlaeden kaufen moechte bestellen.

- Nicht bestellte, aber doch vorhandene Komponenten werden automatisch dem
allgemeinen Pool zugefuehrt.

- Fuer diese 'geopferten' Zutaten erhaelt Zauberer in einem gewissen Umfang
mehr von den bestellten Zutaten. Umfang dieser Zuteilung sollte dem
Wert/Seltenheit der nicht bestellten Zutaten entsprechen.

- Ungenuetzte Zutaten sollten zusaetzlich in den Laeden angenommen werden und
entsprechend ihrem Werte in bestellte Zutaten umgewandelt werden.

Ich hoffe, dieser Artikel ruft nicht nur Flames hervor, sondern wird
durchdacht und evtl. in die Realitaet umgesetzt.

YT Iwo#

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



Re: warok-taramis (Trekan, 10. Sep 1997, 18:36:27):
~#! rn=Birdy rt=873887483 rg=gilden.zauberer
~#! tid=873887483
es giobt stellen im warok, wo du taramios sehen kannst, wenn ich mich recht
entsinne ;)
Trekan

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



re: laeden (Sharia, 10. Sep 1997, 21:14:10):
ganz einfache loesung faende ich:
zaubererkomponenten im zaubererladen verkaufen und dadurch kaufbar
machen...sollte doch nich SO grosses problem sein.. 
senf.
aehm 
sharia

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



Re: re: laeden (Patryn, 10. Sep 1997, 22:20:24):
~#! rn=Sharia rt=873918850 rg=gilden.zauberer
~#! tid=873918850
dafuer geh in nen normalen laden....bietet diese funktionalitaet locker :)

------
patryn

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



Re: laden (Jasper, 11. Sep 1997, 07:48:29):
~#! rn=Birdy rt=873886170 rg=gilden.zauberer
~#! tid=873886170
Nur mal als kleine Randbemerkung, weil ich jetzt beim 10ten Jammerartikel
von dir uebergehe thread eingegeben habe, koenntest du bitte 'antworte'
benutzen, wenn du auf einen Artikel antworten moechtest und nicht jedesmal
nen neuen thread starten.

Jasper, bedankt sich und wundert sich warum er immer noch ne Zeitung hat

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



Grosses Tigonen-Team-Metzeln! :) (Thufhir, 11. Sep 1997, 10:56:18):

Hallo Zauberer und andere Interessierte! ;)

Birdy und ich werden am Mittwoch den 24. September 1997 so gegen 15.30 Uhr 
die Tigonen metzeln. Wir bitten alle Interessierten sich dem Metzelteam
anzuschliessen und sich bis dahin entsprechend auszuruesten.

Zahlreiche Mitmetzelankuendigungen bei Birdy oder mir. ;)

Thufhir, der heute besonders Blutruenstig ist.

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



Re: Re: zaubererlaeden (Festin, 11. Sep 1997, 13:22:14):
~#! rn=Asmodis rt=873855956 rg=gilden.zauberer
~#! tid=873820255

Da nach der Einfuehrung der neuen Komponentenregelung die uebenden
Anfaenger meiner Meinung nach etwas gekniffen sind, haette ich den
Voschlag zu machen, dass man so etwas wie Uebungskomponenten einfuehrt,
die man in etwas hoeherem Massstab im Gildenladen kaufen kann, mit
denen aber nur im Uebungsraum gezaubert werden kann.
So muesste man nicht staendig alle anderen Laeden abklappern, die den
meisten Anfaengern wohl sowieso nicht bekannt sein duerften, aber man
kann mit den "mehr" Komponenten im MG nichts anfangen.

Ist so ne Idee von mir
Festin

PS: Festin hat so eben seinen ersten MPA-Artikel geschrieben...

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



Re^3: zaubererlaeden (Patryn, 11. Sep 1997, 13:29:29):
~#! rn=Festin rt=873976934 rg=gilden.zauberer
~#! tid=873820255
jetzt will ich aber mal was klarstellen:
dass sich die leute bisher keinen grossen kopf um die komponenten machen
mussten duerfte ja wohl keiner abstreiten wollen. (ich meine jetzt nicht-
 magisterkomponenten)
dies jedoch war nicht unbedingt sinn der sache. die kaempfer koennen auch
nicht im gildenladen ihre waffen zusammenkaufen. was denkt ihr euch
eigentlich? hat ueberhauot noch wer von den zauberern nen bezug zu dem,
was in anderen gilden so laeuft?!
wenn sich die anfaenger nun im mud umschaun muessen, um komponenten zu
bekommen, so kann ich dies nur begruessen. evtl. sollten einige auch mal
ihre recht komponentenaufwendige uebetaktik ueberdenken. ein weiterer
punkt beim ueben waer wohl, die spells jetzt alle gleichmaessig parallel
hochzuueben....aber warum erzaehl ich das ueberhaupt. habt ihr keinen
kopp zum denken...wollt ihr das ueberhaupt?! scheinbar nicht.
wie waers, wenn jeder beim login gleich seine komplettausruestung nach
wunsch geliefert bekommt.
das gewisse komponenten wie silbernadeln, sturmvogelfedern oder blutsteine
jetzt etwas knapper sind ist durchaus beabsichtigt. es sind sehr maechtige
spells, wo man ueberlegen sollte, wann und wo sie zum einsatz kommen.
fuer die kleineren komponenten sind loesungen in arbeit, aber man
kommt auch derzweit schon gut klar. wer zum beispiel schimpft, dass
es zu wenig granit im laden zu kaufen gibt, bei dem kann ich nur noch
den kopf schuetteln....

------
patryn

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



Re^3: zaubererlaeden (Hangover, 11. Sep 1997, 15:12:39):
~#! rn=Festin rt=873976934 rg=gilden.zauberer
~#! tid=873820255
Moin Festin!

Auch nur sone Idee...die erfahrerenen Zauber brauchen die
"Anfaengerkomponenten"
meistens nicht so dolle, koennen aber welche einkaufen...Es liegt jetzt an
Dir,
einen Schluss zu ziehen :)

-Lilaf

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



Re^4: zaubererlaeden (Mindblade, 11. Sep 1997, 16:06:54):
~#! rn=Patryn rt=873977369 rg=gilden.zauberer
~#! tid=873820255
Urgs, hmpf...da muss ich Dir mal voll zustimmen Patryn. Uff geschafft!;)
Ich weiss echt nicht warum ihr euch so aufregt, Patryn hat ganz recht, in
jeder anderen Gilde ist man nach nem reboot noch mehr gea... . Keine Ruestung,
und mal klein anfangen... . Ausserdem ist es fuer einen Zauberer (von ganz
kleinen mal abgesehen) doch wohl kein problem nen paar gardis umzunieten und
sich mal nen bischen umzuschauen! Seit doch mal froh, dass ihr als Zauberer
gleich ne ruestung anhabt, das haben andere gilden nicht!;) Und wenn irgend
ein kleiner Zauberer zum ueben was braucht, hilft jeder seher (will ich doch
mal hoffen, ich tus auf jeden fall und habs schon oft getan) gerne aus.
Und ansonsten koennte man vielleicht mal Patryn drauf ansprechen, dass er
vielleicht nen paar mehr Komponenten im MG versteckt, wenn es denn wirklich
zuwenig davon gibt.;)

Mind*, immernoch ganz verwirrt, dass er mal Patryn zustimmen musste!

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



Re^4: zaubererlaeden (Key, 11. Sep 1997, 16:21:45):
~#! rn=Patryn rt=873977369 rg=gilden.zauberer
~#! tid=873820255
Hmm Patryn ... sorry aber muss sein:
Da du so schoen die Kaempfer als Beispiel anfuehrst: Waffen gehen zwar kaputt,
koennen aber repariert werden. Komponenten verbrauchen sich :)

Naja meine Meinung zu dem kuerzen der Komps kennste ja.
Fuer die anderen: Ich finds oki!

Key

i.A.:Tui :))

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



zaubererladen (Patryn, 11. Sep 1997, 18:22:19):
Irgendwo im fernen VLand gibt es jetzt einen 4. Komponentenladen.
Ich weiss, das interessiert jetzt keinen, da man sich daran gewoehnt hat,
alle seine Einkaeufe in der Gilde abzuwickeln, aber ich weise trotzdem mal
drauf hin. Der Laden ist zwar etwas teurer, bietet aber auch etwas mehr.

------
Patryn

PS: nein, ihr muesst nicht im Sumpf oder im Moor im Suedteil der Insel
    rumsuchen...wir wollen doch nicht, dass ein Zauberer ohne Schwefel
    da unten verschollen geht...

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



Re: zaubererladen (Trekan, 11. Sep 1997, 18:40:09):
~#! rn=Patryn rt=873994939 rg=gilden.zauberer
~#! tid=873994939
koente man mal armax beibringen, dass man mehrere items miteinmal kaufen kann?
10mal 'kaufe blutstein' ist doch einfach laestig.

Aber zum theme items allgemein will ich auch noch as fix loswerden:
Das wir im vorteil sind, da wir keine ausruestung nach m reboot brauichen,
duerfte so ziemlich allen klar sein. Jedoch das argument: die andern muessen
ja
erstma ruestungen und waffen holen als vergleich ist hart, da man ja
zauber-zutataten nunmal nicht so oft findet wie eben n std-schwert.
Wenn man dies entsprechend ausgleicht, soltle die restriktion innerhalb des
ladens
voellig ok sein und nur zu mehr spielnaehe fuehren. 
Allerdings sollte man den aspekt mit dem ueben von kleineren spielern und
somit deren komponentenverbrauch mit bedenken. Klar, dass es verschiedene 
methoden zum ueben gibt, aber meistens sieht man doch leute, die im ue-raum
stehen und straight-forward ihre spells runterrattern. 
Alle Zauberers, welche den Gildelevel 9 ueberschritten haben, sollten eh von
der restriktierung nix merken, es sei denn sie ham geld wie heu am strand
Also trifft es die kleinen .. und die wolln wir ja alle nixcht so arg quaslen
;)
Trekan

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



Re: Re: zaubererladen (Patryn, 11. Sep 1997, 18:42:24):
~#! rn=Trekan rt=873996009 rg=gilden.zauberer
~#! tid=873994939
armax kann das bereits.
die 'kleinen zauberer' haben es heut sehr viel leichter als noch vor
einem jahr. die komponenten gleichen das sicher wieder etwas aus, aber wie
bereits angedeutet: man muss halt jetzt parallel lernen, sich im mud besser
umschaun u.s.w.
es ist dabei bei weitem noch nicht so schlimm wie bei den kaempfern

------
patryn

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



Re^3: zaubererladen (Key, 11. Sep 1997, 18:45:26):
~#! rn=Patryn rt=873996144 rg=gilden.zauberer
~#! tid=873994939
Stimmt ne ordentliche Kaempferwaffe finden ist schwer :)
Progg doch mal eine ... ein beil waere ganz nett =;)

Key

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



Re: zaubererladen (Escubar, 11. Sep 1997, 19:57:40):
~#! rn=Patryn rt=873994939 rg=gilden.zauberer
~#! tid=873994939
Hinter Satan waere der richtige Platz, Patryn!

Eisbaer Escubar

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



Re^4: zaubererlaeden (Asmodis, 11. Sep 1997, 20:14:33):
~#! rn=Patryn rt=873977369 rg=gilden.zauberer
~#! tid=873820255
Aeh, Kaempfer koennen sehr wohl ihre Waffen zusammenkaufen, wenn 
Gramdala sie im Angebot hat :*
Und genausowas schwebte mir bei meinem Vorschlag vor, ein NPC/
Laden/Lagerraum, an den man seine Komponenten verkaufen kann,
wenn man sie nicht benoetigt, und dafuer einen guten Preis bekommt.

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



Re^5: zaubererlaeden (Grimmborn, 11. Sep 1997, 20:15:11):
~#! rn=Asmodis rt=874001673 rg=gilden.zauberer
~#! tid=873820255
Du meinst: einen Laden?
Gibts schon...

GdA

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



Re^6: zaubererlaeden (Dhojakt, 11. Sep 1997, 20:22:07):
~#! rn=Grimmborn rt=874001711 rg=gilden.zauberer
~#! tid=873820255
Zeig mir mal den Laden, wo ich 10 sachen von ner unit, die 3000 stueck hat,
kaufen kann.
Dhojakt.

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



Abstimmung (Silvana, 11. Sep 1997, 23:36:04):
Tja, es ist gelaufen. Ihr hattet 2 Wochen Zeit, Euch an der Abstimmung
zu beteiligen. Nun kommt die Auswertung:

Abgegeben wurden 47 gueltige Stimmen. Davon stimmten fuer:
 --  1.) Unbegrenzte Magisterposten, keine Erzmagister:   5 (10.64%)
 --  2.) (Erz)-magisterposten ueber Duelle:   6 (12.77%)
 --  3.) (Erz)-magisterposten ueber Metzeltest: 36 (76.60%)

Ich denke, das kann man als eindeutig werten. :) Was die Umsetzung 
angeht, werdet ihr Euch aber etwas gedulden muessen. Sowas schuettelt
man nicht mal eben aus dem Aermel.

  Silvana

PS: Bis die Sache fertig ist, wird der derzeitige Zustand wohl erst einal
bleiben, aber halt nicht _sooo_ lange.

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



Re: Abstimmung (Anatol, 12. Sep 1997, 00:08:26):
~#! rn=Silvana rt=874013764 rg=gilden.zauberer
~#! tid=874013764
Tja dann viel Spass beim Implementieren, Gletscherfee. :-) Und Danke fuer 
die Muehe, die Du Dir wegen uns Wurstzauberern machst...

Hm, fuer mich stellt sich jetzt allerdings die Frage: Wie sieht es mit den
Magisterposten aus? Ich haette mich ganz gerne dafuer ausgesprochen, die
Magisterstellen in den Zweigen unbeschraenkt zu lassen, und nur die
Zweig-Erzmagister regelmaessig in ein Metzelareal geschickt werden. Aber
das konnte man der Wahlmaschine so genau nicht erklaeren... ;-)

Anatol 


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



Re^4: zaubererladen (Boing, 12. Sep 1997, 09:00:15):
~#! rn=Key rt=873996326 rg=gilden.zauberer
~#! tid=873994939
Ich allein hab vier verschiedene Aexte programmiert, die alle nicht sooo
uebel sind. Und ich denke, dass es im MG noch ein paar mehr geben wird.
  Boing

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



Re: Re: zaubererladen (Teddy, 12. Sep 1997, 09:11:14):
~#! rn=Trekan rt=873996009 rg=gilden.zauberer
~#! tid=873994939
Versuch mal kaufe blutsteine, dann kriegst du IMHO alles von der einen Sorte

Kuschelmaus

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



Re^5: zaubererlaeden (Li, 12. Sep 1997, 09:14:10):
~#! rn=Mindblade rt=873986814 rg=gilden.zauberer
~#! tid=873820255
komponentenmangel wird sicherlich auftauchen, denn es wird (leider) immer
Spieler geben, die lieber die Komponenten fuer sich behalten, als sie anderen
zur Verfuegung zu stellen. 
aber dassollte kein Grund sein, unendlich viele Komps. zur Verfuegng zu
stellen.
Das sit ein Problem, das ihr loesen muesst, so hart es sich auch anhoert.
Li

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



Re^6: zaubererlaeden (Ark, 12. Sep 1997, 11:45:05):
~#! rn=Li rt=874048450 rg=gilden.zauberer
~#! tid=873820255
nur so als brainstorm: wie waere es mit nem spruch 'komponenten erschaffen'?

sicher ist da natuerlich nicht jede komponente gemeint.
is nur ein vorschlag, der auch zum abschmettern freigegeen bist ;)^



              *** ARK * the * Magnificent ***


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



Re: Re: Abstimmung (Birdy, 12. Sep 1997, 14:42:00):
~#! rn=Anatol rt=874015706 rg=gilden.zauberer
~#! tid=874013764

genau. 

Birdy moechte naemlich auch in einen Zweig :)

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



Re^3: Abstimmung (Anacrion, 12. Sep 1997, 14:42:39):
~#! rn=Birdy rt=874068120 rg=gilden.zauberer
~#! tid=874013764
Genau......

Anacrion irgendwann auch ;)

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



Re^4: Abstimmung (Rochus, 12. Sep 1997, 14:44:43):
~#! rn=Anacrion rt=874068159 rg=gilden.zauberer
~#! tid=874013764
me too!

  rochus@aol.com

:-)

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



Re^5: zaubererladen (Key, 12. Sep 1997, 16:05:12):
~#! rn=Boing rt=874047615 rg=gilden.zauberer
~#! tid=873994939
Yep Boing weiss ich, bin Dir ja auch dankbar dafuer :)

Aber man wird schon neidisch wenn man da einen Haufen Schwerter sieht und dann
den kleinen Haufen Aexte ;) Naja mit Speeren und Messern sieht es ja auch
nicht unbedingt besser aus ...

Aber des gehoert in eine andere Rubrik ;)

Key

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



Verknappung ist umgehbar (Hardil, 15. Sep 1997, 10:53:10):

[Zauberer:Li] hmm ,warum koennen spieler "beschraenkungen" nie so akzeptieren,
[Zauberer:Li] wie sie gedacht waren...?

Das ist doch immer so. Solange das Spiel einem eine Moetglichkeit gibt,
auszuweichen, wird diese wahrgenommen.
Das bedeutet im Fall der Verknappung der Zutaten halt wirklich, dass sich
Zauberer eine Zweitie-Famlie zulegen, die fuer sie Komponenten einkauft.
Lass das sogar markierte Zweities sein, damit es richtig offiziell wird.
Selbst wenn dann limitiert wird und Level1-Spieler nur noch 1 Einheit kaufen
koennten - das fuehrt dann nur dazu, dass noch mehr Leute beim
Alchemisten-Geist idlen.

Aber - um einen Gegenvorschlag zu machen:
macht doch das Preisprofil der Zutaten flexibel. Je begehrter Einheiten sind,
desto teurer werden sie. Je weniger Zutaten gekauft werden, desto billiger
werden sie. Und so weiter.

Hokus pokus fidibus.

-Hardil.

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



Kegler (Silvana, 15. Sep 1997, 12:44:20):
Auf besonderen Wunsch eines einzelnen Zauberers besteht der Kegler jetzt
nicht mehr (teilweise) aus Quarz. Letztern gibts jetzt wo anders. Viel
Spass beim suchen.

  Silvana denkt . o O (-z*)

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



Re^5: Abstimmung (Astar, 15. Sep 1997, 14:41:54):
~#! rn=Rochus rt=874068283 rg=gilden.zauberer
~#! tid=874013764
Willst Du das fuer die Raeuber?

Astar

--> schmarrn (oder so)

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



Re: Kegler (Nairolf, 16. Sep 1997, 00:00:58):
~#! rn=Silvana rt=874320260 rg=gilden.zauberer
~#! tid=874320260
Danke Dir Silvana!!!!
....und fuer die die Fragen wieso:
ueberlegt es euch selbst... ich will nich zuviele tips geben...

Gruss Nairolf

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



(Erz-)Magisterposten (Obermotz, 18. Sep 1997, 10:22:10):
Hm, die Abstimmung hat also ergeben, dass die Masse fuer Metzequest ist. Damit
koennte ich ganz gut leben, wenn bei den magistern eine kleine Aenderung noch
durchgefuehrt wird. Da Silvana die Magistersprueche noch ueberarbeiten will
(oder ist das nicht mehr aktuell?), koennte doch noch eine Magisterstufe
eingeschoben werden, fuer die es keine zahlenmaessige Begrenzung gibt.
Die 2. Magister- und die Erzmagisterstufe kann dann beschraenkt und ueber die
Metzelquest besetzt werden.
Fuer mich waere das ein guter Kompromiss.

Obermotz

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



Re: (Erz-)Magisterposten (Key, 18. Sep 1997, 19:26:16):
~#! rn=Obermotz rt=874570930 rg=gilden.zauberer
~#! tid=874570930
Aehm ....
Also wenn ich Dich richtig verstanden habe sollteste Dir die Gilde nochmal
ansehen, wenn nicht vergiss was ich hier schreibe ;))

Key

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



Re: Re: (Erz-)Magisterposten (Silvana, 18. Sep 1997, 23:05:40):
~#! rn=Key rt=874603576 rg=gilden.zauberer
~#! tid=874570930
Ich denke, er meinte, dass nur der zweite Magisterspruch der Zweige
auf 5 Leute beschraenkt wird und man sich, wenn man nicht zu den fuenf
gehoert, einen Zweig aussuchen kann und dort den ersten Spruch lernen
kann. Da ich mit Paracelsus sowieso noch mal ausfuehrlich ueber die
Gilde reden muss (*Nudelholz zueck*), koennte man auch das als 
Alternative vorstellen.

  Silvana

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



Buch (Birdy, 22. Sep 1997, 10:48:07):

Silvana, coole Idee.
Leider ist die Geschichte zu Ende, als es grad spannend wird :"In diesem
Moment oeffnete sich die Zellentuer."
Wann gibs ne Fortsetzung ? :)

Birdy, schmoekernd :)

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



finde-Zauber (Hardil, 23. Sep 1997, 13:38:29):

Probiert mal 

finde marian
aus.
Ich wusste doch, dass es irgendwo einen Null-Raum gibt. :)

-Hardil.

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



Zutaten (Hardil, 26. Sep 1997, 11:35:04):

Ich wundere mich, dass hier kaum Artikel zum Thema Zutatenmangel stehen.
Als die Beschraenkung kam, konnte man immerhin noch bis zu 5 Stueck einer
Zutat kaufen. Inzwischen ist es so, dass man, wenn man Glueck hat, genau 1
Exemplar einer Zutat bekommt.
Und das ist wirklich nicht ausreichend, wenn man nach dem Erhoehen der
Gildenstufe erstmal fuer eine Weile ueben, ueben und ueben muss, um neue
Sprueche
:lernen zu koennen.
Solange man noch soviel ueben muss, sollten wenigstens die Zutaten in einer
zumindest ausreichenden Menge zur Verfuegung stehen. Es kann gut sein, dass
man nachts auf gefuellte Ladeen trifft.
Aber tagsueber hat man fast keine Chance, an kaufbare Zutaten zu kommen, und
so viele Fundstellen gibt es in der freien Wildbahn wirklich nicht, um dem
Lernbeduerfnis der Zauberer Rechnung zu tragen.
Ich glaube wirklich, dass ich mir Zaubererzweities zulegen muss, damit ich
wenigstens pro Reboot 3 oder 4 Pendel, Nachtigallenzungen oder Blutsteine
bekomme und nicht mit einem/r abgespeist werde. :-(

Koennt ihr bitte eine "Reform" testen, bevor ihr sie einfuehrt?
Mit Schnellschuessen wie diesem veraergert man doch nur die Spieler, was sich
sofort in schlechter Stimmung ausdrueckt.

Etwas moekig heute,

-hardil.

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



Re: Zutaten (Patryn, 26. Sep 1997, 11:39:02):
~#! rn=Hardil rt=875266504 rg=gilden.zauberer
~#! tid=875266504
mit schnellurteilen wie diesem veraergert man doch nur die magier, was sich
sofort in schlechter stimmung ausdrueckt.
ich kann dier vorrechnen, dass du pro reset auf weitaus mehr komponenten
kommst und hab mich damit sicherlich ziemlich lang beschaeftigt,
scheinbar zumindest laenger als du. mehr mag ich dazu auch jetzt schon
nicht mehr sagen, es kaemen eh nur die ueblichen:
 du-hast-keine-ahnung-floskeln

------
patryn

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



Re: Re: Zutaten (Hardil, 26. Sep 1997, 11:48:52):
~#! rn=Patryn rt=875266742 rg=gilden.zauberer
~#! tid=875266504

Das ist kein Schnellurteil. Ich habe jetzt im Lauf dieser Woche (Montag bis
heute) mal mitnotiert, wieviele Zutaten ich bekommen kann. Und (da kann ich
meine Strichliste zitieren):
Das Histogramm sagt aus, dass es am wahrscheinlichsten ist, dass man im
Gildladen nix mehr bekommt und bei Armax noch ein Exemplar.
Dann wartet man auf den naechsten Reboot und bekommt im Gildneladen ein
weiteres Exemplar. Klasse. Die Moeglichkeit, einen Spruch mal einen Vormittag
lang zu ueben, bis die Tastatur prellt und nur in der Zeit,
in der man nichts mehr essen und trinken kann, mpa lesen zu muessen, ist weg.

Wie gesagt, dass ruft alles nur unerwuenschte, evtl sogar unmarkierte Zweities
auf den Plan. Und die wollen wir doch alle nicht, oder?

-Hardil. Jetzt langsam sauer ueber die betonkoepfige Borniertheit, die aus
Patryns Antwort spricht.

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



Re^3: Zutaten (Patryn, 26. Sep 1997, 12:25:20):
~#! rn=Hardil rt=875267332 rg=gilden.zauberer
~#! tid=875266504
du solltest sehr vorsichtig mit persoenlichen angriffen sein, auf sowas
reagier ich allergisch und was dabei herauskommt, sind gewisse threads
auf die ich nicht naeher eingehen moechte :) ...na ja, hab grad gute laune
also, da es nicht richtig ankam bei dir:
 du hast keine ahnung!!!
wer was von rebbots im zusammenhang mit einer komponente faselt, hat dies
zum ersten man bewiesen. wer dann in seinem ach-so-tollen histogrammm
nur zwei laeden auffuehrt, disquallifiziert sich zum zweiten mal
 (wie anatol zu sagen pflegt). wer sich jetzt noch einen vormittag lang
die finger mit dem ueben eines spruchs wundscheuert, hat das dritte mal
verloren. ich will die liste jetzt nicht weiter fortfuehren, sonst
stuerzt du dich nachher noch von irgendwelchen klippen, und das wollen
wir doch (fast) alle nicht, oder?! der groesste teil deiner mitzauberer
jedenfalls duerfte inzwischen nur noch grinsen ueber deine artikel...

------
patryn

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



Re^4: Zutaten (Birdy, 26. Sep 1997, 12:39:32):
~#! rn=Patryn rt=875269520 rg=gilden.zauberer
~#! tid=875266504
warum hat man verloren, wenn man uebt ?
Dass ein Spruch manchmal nen Vormittag lang braucht, kann schon vorkommen.

Birdy

PS: Wenn ihr ein Problem miteinander habt, schickt euch Mails, ansonsten bleib
fachlich Patryn.

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



Re: Zutaten (Hangover, 26. Sep 1997, 12:42:13):
~#! rn=Hardil rt=875266504 rg=gilden.zauberer
~#! tid=875266504
Hiho Zauberer

Zu Hardils Artikel: totales Unverstaendnis - auch mein Zweiti muss ab und an
sehr viel ueben und er hat genauso wie andere Zauberer KEIN Probkem mit 
Komponentenmangel. Wenn Du Dich a) gut umschaust wirst Du einige Kauforte
finden oder b) ueberlege Dir mal welcher Zauberer alle Komponenten gleich-
zeitig braucht...

Kopfschuettelnd,
Hangover

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



Re^5: Zutaten (Patryn, 26. Sep 1997, 12:42:27):
~#! rn=Birdy rt=875270372 rg=gilden.zauberer
~#! tid=875266504
bleib fachlich patry...ich hab mich grad koestlich amuesiert, danke birdy
wie lange man fuer einen spruch braucht, brauchst du mir echt nich erklaeren.
du hast auch ueberhaupt nicht den sinn hinter der anmerkung kapiert, damit
tritt auch fuer die unfaehigkeits-faktor 3 in kraft :)

------
patryn

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



Re^6: Zutaten (Hardil, 26. Sep 1997, 13:48:50):
~#! rn=Patryn rt=875270547 rg=gilden.zauberer
~#! tid=875266504

Flame on
Es tut mir echt leid, wenn ich nicht zu denjenigen gehoere, liebster Patryn, 
die jederzeit allen Magiern an den Lippen haengen, um auch wirklich alles, was
es so an Tricks gibt, mitzubekommen.
Ich bin auch kein Extremmudder, der mit tf sich naechtelang Level erschuftet.
Ich betrachte mich als einen normalen Gelegenheitsmudder von der sorte, die
halt waehrend der Woche vom Buero aus oft mal Zeit hat, ne Weile zu mudden.
Wenn ich feststelle, dass ich regelmaessig nach einem gewissen Zeitintervall
wieder Zutaten bekomme, die vorher ausverkauft waren, dann schliesse ich
daraus, dass das ganze Reboot-abhaengig ist.
Vielleicht bin ich nicht so in den hoeheren Sphaeren wissend, dass ich Deine
absolut tollen und von allen Spielern begruessten Konzepte durchblicke.
Natuerlich weiss ich, dass es mehr Moeglichkeiten gibt, Zutaten zu erwerben.
Aber die an besten zu erreichenden, wenn man gerade mal ein wenig lernen will,
sind halt Armax und der Gildenladen.
Apropos Armax (wenn ich gerade am flamen bin, dann auch richtig): den hast Du
ja richtig verhunzt. Frag ihn mal nach kaufbaren Zutaten und schau Dir die
Ausgabe an. Als Bug abgesetzt ist das schon laenger.

Mir ging es einfach darum, dass es bei der Einfuhrung der Begrenzung zuerst
das Argument gab "Man kann doch noch 5 Stueck jeder Zutat im Gildenladen
bekommen". Damit hatte Silvana (zurecht) die Diskussion abgebremst.
Jetzt bekommt man oft gar nix mehr. Und das ist einfach das, was ich an den
Pranger stelle. Ich weiss zwar, dass Du das nicht begreifen willst (
oder kannst), aber ausser GdA und Anatol gibt es hier niemand, der das
Attribut "unfehlbar" fuer sich in Anspruch nehmen darf. (Hier fehlt ein
Smiley, aber  ich denke, Anatol und GdA wissen, dass ich ihnen hier einen
zugedacht habe).
Also auch nicht du.
Zaubern ueben ist und bleibt nervig. Aber der Nervgrad war noch okee.
Jetzt ist ist er einfach uebel. Und wenn dann ein Besserwisser von Minimagier
kommt und noch nicht mal anfangs helfend gemeinte Kritik kapiert, dann tuts
mir leid.
Ich hoffe, irgendjemand mit _Hirn_ stoppt noch gewisse Prozesse, bevor die
Zauberergilde zu einem zweiten VLand wird - einem Platz, wo nur wenige
hinwollen.

Flame off

-Hardil. Sauerkirsche.

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



Re^7: Zutaten (Hardil, 26. Sep 1997, 13:56:37):
~#! rn=Hardil rt=875274530 rg=gilden.zauberer
~#! tid=875266504

Man moege mir den Anfaengerfehler verzeihen, nach mehreren Jahren Mud
verwechsele ich immer noch Reboot und Reset.

-Hardil.

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



Re^7: Zutaten (Grimmborn, 26. Sep 1997, 13:57:17):
~#! rn=Hardil rt=875274530 rg=gilden.zauberer
~#! tid=875266504
Ich nehme an, der smiley gilt dann nur fuer Anatol, wuesste nicht, wieso er
sich auf mich beziehen sollte...

GdA

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



Re^7: Zutaten (Patryn, 26. Sep 1997, 14:09:30):
~#! rn=Hardil rt=875274530 rg=gilden.zauberer
~#! tid=875266504
zu deinen stichelein (besserwisser, nervgrad, minimagier, vland, nix
 kapieren koennen u.s.w.) sag ich mal nix. hab grad keine lust auf solch
platte bemerkungen zu antworten, zumahl sie auch recht unwichtig sind, da
sie ja von dir kommen.
dass du mit reboot reset meinst, ist auch geklaert, ok, liegst trotzdem
falsch. nein, ich werde das jetzt nicht erklaeren, wie das laeuft und nein:
mich interessiert nicht, was du nebenher beim mudden machst.
es ist mir reichlich schnuppe, wieviel zeit du hier eruebrigen kannst.
wenn es nicht mal in deinen zeitplan passt, alle laeden aufzusuchen, frag
ich mich, was du in der gilde willst? andere leute muessen auch
ihre waffen und ruestungen zusammensuchen. sicher, die erwaehnte ich
bereits mehrere male, aber extra fuer dich, hab ich es halt noch mal
hingeschrieben.
der bug der angeblich ganz armax verhunzt ist schon lange behoben, muss
aber erst mal rueberkopiert werden, da fehlen mir die schreibrechte.
 (nebenbei gesagt, hast du nicht "etwas" uebertrieben?! musst ja echt
  schon selbst ueberlegt haben, ob du den muell so da hinschreibst)
sicher sind auch nicht alle mit meinen konzepten einverstanden, aber es
ist zum einen nicht nur auf meinem mist gewachsen und zum anderen
finden es wirklich viele recht gut. auf jeden fall gab es lange nicht
mehr eine solch gute zusammenarbeit unter zauberern wie in den letzten
wochen. gerade dies sollte zu denken geben.

------
patryn ist genervt

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



Re^8: Zutaten (Dhojakt, 26. Sep 1997, 14:10:32):
~#! rn=Hardil rt=875274997 rg=gilden.zauberer
~#! tid=875266504
*Flame on*
Willkommen im SUD...
*Flame off*
Im ernst: es soll sogar mitspieler geben, die man ja evtl fragen koennte, ob
sie etwas von ihrem kaufvorrat, den sie evtl nicht ausschoepfen, abgeben.
Dhojakt.

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



Re^9: Zutaten (Trekan, 26. Sep 1997, 14:35:15):
~#! rn=Dhojakt rt=875275832 rg=gilden.zauberer
~#! tid=875266504
oh ja .. da hat dhojakt wohl recht. Auch ist es ja (gluecklicherweis) in
letzter zeit in mode gekommen, zutaten in das pentagramm zu legen.
Dabei sollten aber leute, die sich da dinge nehmen, nicht im staubsaugermodus
da durch gehen. Ich gehe oefter mal durchs mud und hole n paar items, wenn ich
nix zu tun habe um andere zu unterstuetzen. Aber nicht, um itm's zu verbraten.
Diese Zutaten sollten eigtl hauptsaechlich dafuer gedacht sein, dass wenn ein
zauberer nachm reboot reinkommt er sich was nehmen kann um erste ausruestung,
bzw items sich zu besorgen und er somit nicht ganz hilflos ist und nicht, um
nur damit zu ueben (was ja im gewissen masse auch ok ist)
Aber alls in allem ist mir schon mehr zusammenarbeit unter den zauberern
aufgefallen, was sicher schoen und gut ist. Allerdigs stoerts mich auch
manchma, das nix da ist, in dem fall: activte idle mode ;)
Trekan

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



Re^8: Zutaten (Anatol, 26. Sep 1997, 17:08:05):
~#! rn=Patryn rt=875275770 rg=gilden.zauberer
~#! tid=875266504
Vielleicht sollte irgendjemand Hardil Bescheid sagen, dass Patryn nicht
ernstgenommen werden will. Es ist eh' eines jeden Einzelnen Entscheidung, 
ob er den herunterputzenden Bemerkungen eines Magiers, der zu seiner 
Spielerzeit als Zauberer vermutlich mehr Befehle, die mit einem Slash 
beginnen, abgeschickt hat, als 'normale Befehle von Hand eingegeben, 
mehr als belaechelnde Beachtung schenkt.

Anatol, der "disqualifizieren" mit einem einzigen 'l' schreibt.


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



Re: Zutaten (Alpha, 26. Sep 1997, 17:24:35):
~#! rn=Hardil rt=875266504 rg=gilden.zauberer
~#! tid=875266504
Pendel willste? 4-6 pro Reset. Wo? In Fernwest. Meine Zweitie weiss schon gar
nicht mehr wohin mit dem Zeugs. Aber eigentlich muesstest Du die Stelle auch
kennen mit Level 27.
Alpha.

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



Re: Re: Zutaten (Key, 26. Sep 1997, 18:10:00):
~#! rn=Alpha rt=875287475 rg=gilden.zauberer
~#! tid=875266504
Hmm eigentlich haette ich gute Lust mal alles aufzuzaehlen was Tuareg in
seinem Guertel hat ... und zwar ohne grossartig einzukaufen, bzw es extra zu
ermetzeln ....

Und andere Zauberer fragen ist ja wohl kein prob, hab letztens auch einiges an
... aeh mom was war das fuer zeug? *gruebel*
Naja egal auf jeden fall einiges an einen uebenden zauberert abgegeben ....

Aber wer unebdingt nur stur vor sich hinueben will ohne sich umzusehen oder
nachzufragen .... :)

Achja ... Silvana ... ich will mehr quarz :) 

Key

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



Re^3: Zutaten (Silvana, 26. Sep 1997, 21:29:20):
~#! rn=Key rt=875290200 rg=gilden.zauberer
~#! tid=875266504
Wir arbeiten dran. :)
Aber: Quarz wird rar bleiben.
Silvana

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



Re^3: Zutaten (Trekan, 27. Sep 1997, 10:54:53):
~#! rn=Key rt=875290200 rg=gilden.zauberer
~#! tid=875266504
jawohl .. quarz regelt ... ;)
Trekan

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



Re^4: Zutaten (Highlander, 27. Sep 1997, 17:18:04):
~#! rn=Trekan rt=875350493 rg=gilden.zauberer
~#! tid=875266504
Quarz? Quartz? Irgendwie fehlt mir da ein t. Oder les ich zuviel englische
Buecher?
  HrT

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



Re^5: Zutaten (Wurzel, 28. Sep 1997, 13:18:16):
~#! rn=Highlander rt=875373484 rg=gilden.zauberer
~#! tid=875266504
du liest tatsaechlich zuviel englische buecher :) aber auch in deutschland
verkaufte quarzuhren tragen gelegentlich die bezeichnung "quartz", und es
wird vermutlich nur noch wenige jahre dauern, bis die allgemeine legasthenie
(neudeutsch auch "rechtschreibreform" genannt) die englische schreibweise als
die richtige anerkennt, ggf. mit einer uebergangsfrist fuer die halsstaarigen
quarz-schreiber.

wurzel

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



Re^9: Zutaten (Li, 29. Sep 1997, 10:35:29):
~#! rn=Anatol rt=875286485 rg=gilden.zauberer
~#! tid=875266504
Was mich wundert, dass Magier oft (immer?) daran gemessen werden ob/wieviel
sie als Spieler gescriptet haben.
Was hat daseine mit dem Anderen zu tun?
Ist ein scriptender spieler automatisch ein schlechter Magier?
Sollte ein scripternder Spieler gar nicht Magier werden?
Oder wird ein scriptender Spieler, wenn er Magier wird, zum Ungeheuer, der es
seinen Ex- mitspielern heimzahlen will?
also lass doch diese Polemik Anatol.
Li (vergiss nicht, meine Rechtschreibfehler zu korrigieren!)

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



Re^10: Zutaten (Patryn, 29. Sep 1997, 10:39:34):
~#! rn=Li rt=875522129 rg=gilden.zauberer
~#! tid=875266504
zumahl der liebe anatol in keiner weise einschaetzen kann, wie ich mich
als spieler verhalten habe...
es hat auch wenig mit dem eigentlichen thema zu tun, denn dass jemand,
der sich in hardils art und weise ueber etwas beschwert, von mir als
unfaehig deklariert wird, scheinen ja auch andere antworten mitlerweile
zu bestaetigen. die komponentenverknappung ist eiune tatsache und ich
will sie gar nicht abstreiten, aber es wurde auch tatsaechlich so
beabsichtigt.

------
patryn

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



www-seite unserer schoenen gilde (Birdy, 29. Sep 1997, 11:42:39):

HIHO :) !

Beim Durchstoebern der FernWest-Seiten, sehr gut gelungen Li !, habe ich mich
gefragt, ob es eigentlich Gildenseiten gibt. Na gleich nachgeguckt und nix
gefunden.
Wenn es welche gibt, dann wo ? Und wenn nicht, waere es in unser
em Interesse, wenn sich eine/r hinsetzt und mal eine Idee und ein Konzept fuer
unsere Seite ausdenkt ? :)

Nastrowje !!
  Birdy

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



Re: www-seite unserer schoenen gilde (Li, 29. Sep 1997, 11:54:25):
~#! rn=Birdy rt=875526159 rg=gilden.zauberer
~#! tid=875526159
Danke!
*rot werd*
-> schmarrn

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



Re^8: Zutaten (Guybrush, 29. Sep 1997, 19:21:38):
~#! rn=Patryn rt=875275770 rg=gilden.zauberer
~#! tid=875266504
Immer wieder, wenn ich hier Zeitung lese, merke ich, dass meine Zuneigung zu
einigen Leuten steigt. 

Guybrush

P.S.: Dieser Artikel entstand nicht nur aus Langeweile, sondern auch aus
Intoleranz.

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



ruesten oder nicht ruesten?! (Patryn, 30. Sep 1997, 03:36:39):
eine "leicht" veraenderte 'score' und 'info' anzeige bietet ein nettes
kleines tool im besitz eines weniger netten versoffenen seebaeren im
vland. fuer zauberer gibts sogar einen kleinen bonus in der anzeige...

------
patryn

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



Re^9: Zutaten (Asmodis, 30. Sep 1997, 14:25:53):
~#! rn=Guybrush rt=875553698 rg=gilden.zauberer
~#! tid=875266504
Sach bloss, du bist in Patryn verknallt ??
So eine Geschmacksverirrung :)

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



prophrtischer papagei? (Li,  2. Okt 1997, 08:12:14):
Eben passiert:
[Zauberer:Yedy] wie kann man den normalwert des zauberstabs erhoehen?
[Zauberer:Denti] durch zaubern
Musashi kraechzt: ... zumindestens heute noch ... krrrooaaa!

*grins* ok->schmarrn
Li

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



komponenten (Patryn, 15. Okt 1997, 12:56:28):
ids welche sowohl fuer plural als auch fuer singular gelten, werden nun
als plural gewertet. vorsicht also in den laeden:
auswirkungen... lege 1 pendel weg funktioniert jetzt zB
                kaufe pendel -> man kauft nicht mehr nur ein pendel sondern
                 alle derzeit kaufbaren!!! kaufe 1 pendel waer also nun
noetig

------
patryn

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



re:komponenten (Birdy, 15. Okt 1997, 14:30:28):

gut, hat mich schon immer genervt, wenn man maximalanzahl kaufen wollte, die
genaue anzahl einzugeben :)

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



WWW (Silvana, 15. Okt 1997, 22:27:35):
Nachdem es jetzt Gilden-WWW-Seiten im Morgengrauen gibt, wuerde ich gern
auf denjenigen zurueckkommen, der mal vorgschlagen hatte, solche
zu designen. Da ich jedoch nicht mehr weiss, wer das war, hier der
Aufruf: Wer Lust hat, unsere Seite zu gestalten und Ahnung von html
und sowas hat: melden, gibt Arbeit.

  Silvana

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



Re: WWW (Birdy, 16. Okt 1997, 11:51:09):
~#! rn=Silvana rt=876947255 rg=gilden.zauberer
~#! tid=876947255

Ich bekenne mich schuldig, gefragt zu haben. :)

Birdy

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



GildenHomePage (Birdy, 20. Okt 1997, 11:10:17):
Oki !
Ich werde das mal in die Hand nehmen :)
Erstmal moechte ich fragen, wer sich an der Mitgestaltung unserer Gildenseite
beteiligen moechte, gefragt sind Ideen, Vorschlaege, Wuensche und wenn
moeglich auch Quellen, wo man bestimmte Sachen, wie Graphiken usw. herkriegen
kann. :)
Mailt einfach an mbrueckn@informatik.hu-berlin.de
Naechste Woche Montag schreibe ich dann in die Zeitung, wer mitmachen will
(zur Absicung).
Ups,Absicherung.
Wer schon frueher irgendwie mitmachen will, schreibt mir das auch am besten,
ich guck jeden Tg mehrmals nach. :)

Nastrowje !
Birdy

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



www-seiten der gilde (Birdy, 29. Okt 1997, 14:08:59):

Also bisher hat mir Silvana ne Materialquelle gesagt und li hat sich angeboten
etwas text zu schreiben.

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



Re: www-seiten der gilde (Aurian, 30. Okt 1997, 12:42:56):
~#! rn=Birdy rt=878130539 rg=gilden.zauberer
~#! tid=878130539

naja, ausserdem hast du meine erlaubniss, meine liste der
zauberzutaten-fundorte ebenfalls ins www zu stellen ...

aurian, birdy korrigieren wollend

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



Re: Re: www-seiten der gilde (Birdy, 30. Okt 1997, 17:29:27):
~#! rn=Aurian rt=878211776 rg=gilden.zauberer
~#! tid=878130539

mal als frage an alle zauberer : soll ich das wirklich ? 

Birdy

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



Re^3: www-seiten der gilde (Hangover, 30. Okt 1997, 17:33:11):
~#! rn=Birdy rt=878228967 rg=gilden.zauberer
~#! tid=878130539
Moin Birdy!

Ich denke die Komponenteninfos haben auf solchen Seiten nix zu suchen...

Hangover,
fuer seinen Zweiti sprechend.

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



Re^4: www-seiten der gilde (Morgar, 30. Okt 1997, 17:34:16):
~#! rn=Hangover rt=878229191 rg=gilden.zauberer
~#! tid=878130539
Hm, ich glaub auch nicht, dass das eine gute Idee ist.

Morgar

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



Re^5: www-seiten der gilde (Birdy, 31. Okt 1997, 12:21:00):
~#! rn=Morgar rt=878229256 rg=gilden.zauberer
~#! tid=878130539

Ich danke euch, dass ihr mir Arbeit erspart. ;)
Aber irgendwo muessten wir das schon unterbringen, ne idee ?
Birdy

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



Re^6: www-seiten der gilde (Teddy, 31. Okt 1997, 18:05:08):
~#! rn=Birdy rt=878296860 rg=gilden.zauberer
~#! tid=878130539
Machs wie die Chaotenliste in ein typisches Zauberergebiet, z.B. Warok oder so

Teddy


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



Re^6: www-seiten der gilde (Trekan,  1. Nov 1997, 22:12:03):
~#! rn=Birdy rt=878296860 rg=gilden.zauberer
~#! tid=878130539
jo birdy -> mail trekan ;)
->/dev/null

Die Idee ist im Prinzip gut, aber ich wuerde empflehen, ueber www die 
laeden aufzulisten/verweisen, in denen man komponenten finden kann.
Also die ganz regulaeren ladenhueter, sowie das syste, wonach mach jetzt
(nichts) kaufen kann. ;)
Trekan

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



Re^7: www-seiten der gilde (Key,  1. Nov 1997, 22:25:49):
~#! rn=Trekan rt=878418723 rg=gilden.zauberer
~#! tid=878130539
Hmm joo, haengen wir auch gleich Komplettloesungen ins WWW?

Key

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



Re^8: www-seiten der gilde (Trekan,  1. Nov 1997, 22:26:20):
~#! rn=Key rt=878419549 rg=gilden.zauberer
~#! tid=878130539
aber bitte so, dass ich sie mit tf laden kann
Trekan -> furchbar ernst heute

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



Re^8: www-seiten der gilde (Bloodyharry,  1. Nov 1997, 22:33:05):
~#! rn=Key rt=878419549 rg=gilden.zauberer
~#! tid=878130539
Das hatten wir schon mal gehabt. Obwohl es wohl nicht so schlimm sein muss -
man kann naemlich immer noch RM danach werden - sollte man das besser doch
sein lassen.

bh

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



Re^9: www-seiten der gilde (Teddy,  2. Nov 1997, 00:24:14):
~#! rn=Bloodyharry rt=878419985 rg=gilden.zauberer
~#! tid=878130539
Koennten wir dann bitte die FPs in die KLs einbauen?

Teddy
->schmarrn

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



Re^9: www-seiten der gilde (Morgoth,  3. Nov 1997, 11:23:33):
~#! rn=Bloodyharry rt=878419985 rg=gilden.zauberer
~#! tid=878130539
Jaja, ich wars. Ich bekenne mich oeffenlich dazu, mal alle (damaligen) KLs auf
meiner Webseite gehabt zu haben.
nach nem kraeftigen Arschtritt von Boing waren sie aber fix wieder runter.
M*

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



Re^10: www-seiten der gilde (Key,  3. Nov 1997, 12:22:44):
~#! rn=Morgoth rt=878552613 rg=gilden.zauberer
~#! tid=878130539
Alle? .)
Tsts schaem Dich ,)
Am besten auchnoch die von Deiner Quest samt fps? .))

Key

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



samurai (Li,  4. Nov 1997, 13:07:45):
hi!
Lieder habe ich in den Samurai ein Bug gefunden, den ich ausbauen musste.
Es war vorgesehen, dass die Samurai ein paar Edelsteine bekamen. Leider hatte
ich ihnen aber ganze Saeckchen mit edelsteinen gegeben. die habe ich nun
ausgebaut.
Ich werde mir zu hause passenden Ersatz ueberlegen und morgen frueh einbauen.
Li

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



Samurai (Li,  5. Nov 1997, 12:21:26):
Hi!
die Samurai haben wieder Edelsteine, aberdeutlich weniger ( die Haelfte,
sozusagen)
Li

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



Re: Samurai (Key,  5. Nov 1997, 12:30:22):
~#! rn=Li rt=878728886 rg=gilden.zauberer
~#! tid=878728886
Hmm da da die Edelsteine derartig reduziert sind ... Koennte mal ein anderer
Magier welche dranhaengen? Es sind EINDEUTIG zuwenig.

Key i.A. Tui

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



Re: Re: Samurai (Legas,  5. Nov 1997, 14:10:08):
~#! rn=Key rt=878729422 rg=gilden.zauberer
~#! tid=878728886
Ich weiss nicht Key, aber ich find es sehr sinnvoll und gut, dass die
Edelsteine jetzt wieder etwas knapper sind. Gerade wenn ein Spruch wie
verletze so verdammt maechtig ist, kann es doch nicht Sinn machen, dass man
immer in sovielen Komponenten schwimmt, dass man ihn immer (und ohne Zwang)
einsetzt. Versuch es doch auch mal mit Herzen und Blutsteinen (die machen zwar
etwas weniger Schaden, aber immer noch mehr als viele Sprueche in anderen
Gilden)
               Legas ist fuer ein gesundes Mass an Komponentenknappheit.

P.S.: Ich geb ja zu, dass ich kein aehm "ganz normaler" zauberer bin :), aber
jetzt mal im Ernst, was sollen denn Komponenten ueberhaupt wenn Du sie ohne
irgendwelche Probleme in beliebieger Anzahl bekommen kannst? Aber nun mal
einen anderen Vorschlag: wie waere es denn mit Reinheit von Komponenten
(Edelsteinen) die "schlechten" machen halt etwas weniger Schaden als bisher
(sind dafuer aber leicht zu bekommen (z.b. fuer kleine Gegner und zum ueben)
es gibt dann aber auch ganz reine Edelsteine die halt dann wie bisher Schaden
machen (entweder sind davon halt nur wenige in jedem Saeckchen oder man
versteckt sie woanders). Nur mal so eine Idee....

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



Re^3: Samurai (Key,  5. Nov 1997, 20:20:08):
~#! rn=Legas rt=878735408 rg=gilden.zauberer
~#! tid=878728886
Und was bitteschoen bringt mit son Spruch wenn ich stundenlang auf edelsteine
warten muss????

Und kaufen ... weisste ueberhaupt wie teuer die dinger sind?

Key

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



Re^4: Samurai (Orktoeter,  5. Nov 1997, 20:25:38):
~#! rn=Key rt=878757608 rg=gilden.zauberer
~#! tid=878728886
Es gibt doch einen von euch, der Nur zap sagen muss und der gegner faellt tot
um, stell dir mal vor, der wuerde dein Argument benutzen...

OrkT

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



Re^5: Samurai (Sharia,  5. Nov 1997, 20:26:05):
~#! rn=Orktoeter rt=878757938 rg=gilden.zauberer
~#! tid=878728886
nein gibt es nicht Orktoeter.....


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



Re^6: Samurai (Key,  5. Nov 1997, 20:26:29):
~#! rn=Sharia rt=878757965 rg=gilden.zauberer
~#! tid=878728886
Hmpf wollte ich gerade schreiben ;)

Key

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



Re^7: Samurai (Sharia,  5. Nov 1997, 20:26:41):
~#! rn=Key rt=878757989 rg=gilden.zauberer
~#! tid=878728886
tus doch :-)

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



Re^3: Samurai (Silvana,  6. Nov 1997, 07:41:43):
~#! rn=Legas rt=878735408 rg=gilden.zauberer
~#! tid=878728886
1) Die Edelsteine waren zu leicht zu kriegen, daher werden auch die 
   Gardewaechter demnaechst weniger haben - aber erst, wenn es an anderer
   Stelle dafuer Ersatz gibt. Die erreichbare Menge ist schon OK, aber
   es ist derzeit _etwas_ leicht.
2) Die Idee mit der 'Qualitaet' der Komponenten ist nicht ganz neu - aber 
   trotzdem schoen. Leider heisst das, dass ich das halbe Spellbook
   umschreiben muesste - und dazu fehlt mir sowohl die Lust als auch
   die Zeit. Abgesehen davon: Hast Du eine Vorstellung, wie lange es
   dauert, dann unterschiedlich gute Komponenten zu verteilen? Wir haben
   auch so Monate gebraucht, um wenigstens ein paar Komponenten im MG zu
   verteilen...

   Silvana

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



Re^5: Samurai (Hangover,  6. Nov 1997, 08:36:47):
~#! rn=Orktoeter rt=878757938 rg=gilden.zauberer
~#! tid=878728886
Hi Orkt*

Das ist meiner Meinung nach KEIN sinnvolles Argument. Nur weils einer kann -
der laeuft (hoffentlich) nciht andauernd als skript rum um fuer den rest 
kram ranzuschaffen ;)

Ansonsten finde ich das auch recht arg, dass die edelsteine so knapp geworden
sind...aber es geht meinung nach so gerade eben noch...muss sich auch mal
jeder ueberlegen, ob er mit 50 steinen pro sorten im inventar rumlaufen
muss oder nicht...

-Hangover


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



Magisterposten (Silvana,  6. Nov 1997, 09:58:44):
Hi.
Nochmal fuer alle zum mitmorsen:
Die Magisterposten sind und bleiben begrenzt. Aufbegrenzten Posten will
ich keine Magierzweities sehen. Bisher ist das friedlich zu regeln gewesen,
aber derzeit macht sich mal wieder ein Magierzweitie auf einem begehrten
Platz breit. 
Um es deutlich zu sagen: Padreic, mach Deinen Zweitie da weg, sonst mach
ich ihn weg.

  Silvana (findet sowas nicht in Ordnung)

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



Re: Magisterposten (Sharia,  6. Nov 1997, 11:06:58):
~#! rn=Silvana rt=878806724 rg=gilden.zauberer
~#! tid=878806724

Ich empfehle in diesem Zusammenhang vielleicht gleich ne Abfrage fuer
Magierzweitis oder sowas ??? dann kommt sowas garnicht erst vor.

senf aehm Sharia

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



Re: Re: Magisterposten (Silvana,  6. Nov 1997, 12:25:45):
~#! rn=Sharia rt=878810818 rg=gilden.zauberer
~#! tid=878806724
Bisher wars nicht moeglich, jemanden als Magierzweitie zu klassifizieren.
Das wir erst mit der Markierungspflicht mit Namen moeglich - und auch da
kompliziert.

  Silvana - baut das irgendwann auch mal ein.

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



phlyaken (Silvana,  6. Nov 1997, 12:50:30):
Hi.

Ich wurde gebeten, Phlyaken den Erdbebenzauber auszureden, da zu oft
unschuldige Anfaenger an ihm gestorben sein sollen... Naja, er hat sich 
schwer gewehrt... Ich musste ihm eine Eigenschaft versprechen, die Euch
nicht eben gefallen wird...
Ausserdem hat sich sein Angebot etwas veraendert. Einiges gibt es oefter,
anderes weniger. Viel Spass - und VORSICHT!

  Silvana

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



Magisterposten (Birdy,  6. Nov 1997, 13:30:27):

Hmmm, Magisterposten also limitiert...
Wie wird man dann jemals Magister seines Wunschzweiges ?
Muss man darauf warten, dass einer der Magister dieses Zweiges geloescht
werden oder die Gilde wechseln ? :( Oder wie ?
Ich warte jetzt schon seit 2 Monaten und seh keinen Silberstreif am Horizont
:(.


Birdy resigniert langsam

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



Re: Magisterposten (Silvana,  6. Nov 1997, 13:34:46):
~#! rn=Birdy rt=878819427 rg=gilden.zauberer
~#! tid=878819427
Und auch das noch mal zum mitmorsen:
Geduld, wir arbeiten dran.

  Silvana

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



Re: Magisterposten (Key,  6. Nov 1997, 18:08:20):
~#! rn=Birdy rt=878819427 rg=gilden.zauberer
~#! tid=878819427
Wart das ein gewisser Magier der zwar immer rumlabert von Regeln aber diese
net selber befolgt platz macht ... :)

Key

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



Spielerbeirat (Silvana,  6. Nov 1997, 19:18:31):
Lange angekuendigt, jetzt wirds was:
Im Spiegelsaal steht ab sofort wieder eine Wahlmaschine, mit der ihr
die Spieler, die sich fuer den Spielerbeirat zur Wahl gestellt haben,
waehlen koennt. Es kommen in den Beirat 2 Spieler und 1 Magier - die 
Magier stehen dann im naechsten Wahlgang zur Wahl. Also erst mal die 
Spieler - die beiden mit den meisten Stimmen gewinnen. (logisch, oder?)

  Silvana

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



Re: Spielerbeirat (Silvana,  6. Nov 1997, 19:23:43):
~#! rn=Silvana rt=878840311 rg=gilden.zauberer
~#! tid=878840311
Ach ja, bevor noch mehr Missverstaendnisse aufkommen: Es handelt sich
'nur' um einem Gilden-Beirat. Hat also nix mit Nicht-Zauberern zu tun.

  Silvana

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



Re^3: Magisterposten (Babs,  7. Nov 1997, 05:49:26):
~#! rn=Silvana rt=878815545 rg=gilden.zauberer
~#! tid=878806724
Ich versteh nicht, was da dran kompliziert sein soll. Mit
if
(file_size("/players/"+lower_case(to_string(this_player()->QueryProp(P_SECOND)
))==-2)
kann man feststellen, ob der Erstie ein homedir hat und somit Maggi ist.
Jedenfalls in zivilisierten MG-Nachkommen ;-)

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



Struv (Birdy,  7. Nov 1997, 13:08:59):
Ein "RACHE !" schreiender Zauberer begann gestern die Belagerung des Struv.
Ohne Vorwarnung drang er in die Festung ein und toetete einen Kaempfer nach
dem anderen.
Mit jedem Toten erscholl ein Jubeln aus des Zauberers Kehle und auf einer
Liste, die er mit sich herumtrug, wurde ein Name ausgestrichen.
Die einbrechende Dunkelheit bewahrte den Struv vor der endgueltigen Demontage,
aber ausser 3 Namen, waren schon alle von der Liste gestrichen.
Am naechsten Morgen vollendete der Zauberer dann sein Vernichtungswerk und
wischte diese 3 mit einem Strich weg.
Mit einem Freudentaenzchen verabschiedete der Zauberer sich dann breit
grinsend und empfahl sich. 

Aus: "Mein Leben als Zauberer" von Birdy

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



Re: Struv (Orktoeter,  7. Nov 1997, 14:22:13):
~#! rn=Birdy rt=878904539 rg=gilden.zauberer
~#! tid=878904539
Zauberer abwerten !

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



Re: Re: Struv (Hangover,  7. Nov 1997, 14:22:31):
~#! rn=Orktoeter rt=878908933 rg=gilden.zauberer
~#! tid=878904539
Kaempfer abwerten

Hangover -> schmarrn

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



Re^4: Magisterposten (Silvana,  7. Nov 1997, 22:47:42):
~#! rn=Babs rt=878878166 rg=gilden.zauberer
~#! tid=878806724
Ad 1: Es  gibt Magier ohne eigenes Players-Verzeichnis (Level15-Neumagier)
Ad 2: Es gibt - auch wenn ich das fuer illegal halte - Magier, die als
      Zweitie eines Sehers (auch Zauberer) sind. Was macht man mit denen?

  Silvana

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



Re^5: Magisterposten (Cheasy,  7. Nov 1997, 23:20:49):
~#! rn=Silvana rt=878939262 rg=gilden.zauberer
~#! tid=878806724
Silvana hat Ad 3: vergessen.
 Es gibt Zweiteis die anonym markiert sind.
-Cheasy

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



Re^6: Magisterposten (Ringor,  7. Nov 1997, 23:21:39):
~#! rn=Cheasy rt=878941249 rg=gilden.zauberer
~#! tid=878806724
Silvana hat das nicht vergessen. Silvana ist Magierin und sieht den Erstie
trotzdem.

Ringor

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



Re^6: Magisterposten (Hangover,  8. Nov 1997, 10:03:08):
~#! rn=Cheasy rt=878941249 rg=gilden.zauberer
~#! tid=878806724
Hm...
Ich dachte Magierzweities oder Zweitimagir MUESSEN mit Namen markiert werden?
Ansonsten wuerde ich doch drum bitten das mal einzufuehren :)

-Hangover


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



Restriktionen (Anacrion,  8. Nov 1997, 15:49:10):

Moin auch...

Nur mal so..ich weiss ja nicht, wie lange es noch dauert, bie es wieder Regeln
zur Besetzung von limitierten Posten gibt, aber koennte man vielleicht bis zu
diesem Zeitpunkt das 'Aeltestenrecht' abschaffen, das besagt, dass diejenigen,
die halt anno kampfabhaengung den Posten hatten, ihn behaben, und andere nur
durch Ruecktritt in die Zweige koennen ?

Ich meine, es sollte ein gleiches Recht fuer alle da sein (auch in dieser
vertrackten Situation)...es waere zwar sinnlos, etwas zu aendern, wenn die
neuen Besetzungsregeln kurz vor dem Abschluss der Programmierung stuenden, da
dies aber glaube ich nicht der Fall ist:
Koennte man nicht einfach die limitierten Posten fuer ALLE Magister oeffnen,
d.h. bis dato die limitierung aussetzen ?

Anac* - mal wild drauflosdenkend...

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



Re: Restriktionen (Ringor,  8. Nov 1997, 19:57:09):
~#! rn=Anacrion rt=879000550 rg=gilden.zauberer
~#! tid=879000550
Au ja .. Zardoz, koenntest Du den Gildenlevel 12 der Chaoten nicht auch mal ne
Weile abhaengen, um ihn dann zwei Monate spaeter aus Zeitmangel fuer alle
Meister des Chaos zugaenglich zu machen?

Waer doch viel gerechter und einfacher ... :-)

-> schmarrn()

Ringor. Sieht schon alle Zauberer mit Todeszauber und Zauberschild rumrennen.

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



Re: Restriktionen (Laurin,  8. Nov 1997, 20:04:01):
~#! rn=Anacrion rt=879000550 rg=gilden.zauberer
~#! tid=879000550
Du hofft wohl, so billig an einen Posten zu kommen ?
So haben wir nicht gewettet, fuer den hoechsten Level muss
man schon was tun ...

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



restriktionen (Birdy, 10. Nov 1997, 13:58:09):

Ich glaube, Ana* meinte die limitierten MAgisterposten und nicht die
Erzmagisterposten.

Birdy

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



Re: restriktionen (Anacrion, 11. Nov 1997, 11:04:11):
~#! rn=Birdy rt=879166689 rg=gilden.zauberer
~#! tid=879166689

Danke Birdy.

Allerdings meinte ich die MAGISTERPOSTEN, nicht die Erziposten...
Defacto ist es doch so, dass die limitierten Magisterposten von denen bis
ultimo gehalten werden, die ohnehin schon da waren, d.h. kein Wechsel moeglich
ist...wir wollen doch wohl kein Aeltestenrecht einfuehren, oder ?  Wenigstens
sollte man Newbies ne Chance geben...

Anac* - Birdy immer noch dankbar weiend.

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



kaempfergilde (Birdy, 11. Nov 1997, 12:22:30):

Ich haette den Ausszug aus meinen Memoiren ueber die Belagerung des Struvs
wohl nicht veroeffentlichen sollen !
Denn jetzt wird das Tor von Spielern bewacht.
Da gibts bestimmt ne Loesung fuer. Schliesslich kann es nicht angehen, das die
haerteste Gilde im Morgengrauen vor den Zauberern zittert. ;)

Birdy

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



Re: kaempfergilde (Gnome, 11. Nov 1997, 12:45:14):
~#! rn=Birdy rt=879247350 rg=gilden.zauberer
~#! tid=879247350
noe, wir zittern nicht... :)
es ist bloss ein bissel bloed, wenn die leute was lernen oder wissen
wollen und keine briesel oder kein hogo steht da, wo er hingehoert.
besonders anfaenger sind dadurch irritiert...
also raeumt das struv aus, wenn nicht so viele da sind, sprich nachts oder
so... aber ich rate sowieso davon ab, denn bis jetzt haben das nur wenige
ueberlebt :)

gnOme
p.s. arg, briesel ist natuerlich ein ER :)

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



Re: Re: kaempfergilde (Mango, 11. Nov 1997, 13:12:32):
~#! rn=Gnome rt=879248714 rg=gilden.zauberer
~#! tid=879247350
Jammerlappen.

Ob Funakoshi getoetet werden darf oder nicht fragt doch auch niemand ...

Mango.


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



Re^7: Magisterposten (Acrimon, 11. Nov 1997, 15:46:22):
~#! rn=Hangover rt=878979788 rg=gilden.zauberer
~#! tid=878806724
Liest du keine Zeitung und keine Loginmeldungen?

Auch anonym markierte Zweities sind mit Namen markiert, obwohl der Name (und
oft auch die Zweitiemarkierung selbst) erst ab einem bestimmten Magierlevel
sichtbar sind.

Wo ist eigentlich dieser bestimmte Magierlevel? Weisz das jemand?

Acrimon der Rote Ritter

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



Re^8: Magisterposten (Ringor, 11. Nov 1997, 20:52:24):
~#! rn=Acrimon rt=879259582 rg=gilden.zauberer
~#! tid=878806724
Dieser Magierlevel, ab dem man die Erstie-Namen unsichtbar markierter Zweities
sieht, ist Level 21.

Ja, ich halte das auch fuer viel zu niedrig, dann kann man es eigentlich auch
gleich sichtbar lassen. Aber die offizielle Begruendung: 'wenn ein Magier den
Namen des Ersties verraet, ist das ja Spielerhilfe und damit verboten'.

Ringor. Findet diese Einstellung 'etwas' naiv.

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



Re^9: Magisterposten (Yantro, 12. Nov 1997, 08:47:51):
~#! rn=Ringor rt=879277944 rg=gilden.zauberer
~#! tid=878806724
Es ist aus vielerlei Gruenden nicht gewuenscht, dass der Erstiename erst ab
einem hoeheren Magierlevel zu sehen ist. Zum einen sollte JEDER Magier wissen,
dass es verboten ist, den Namen an Spieler weiterzugeben und ich denke, das so
ein Verbot reicht. Zum anderen ist es so, dass der ein oder andere Magier mit
Level 21 vielleicht mal was proggen will, in dessen Code Zweitis
beruecksichtigt werden, sie es als Sperre oder Feature oder was weiss ich. So
eine Sache koennte dann auch nur ein hoeherer Level proggen, weil er ja in der
Lib aufgrund der Sicherheitsabfrage keinen Zugang auf den Erstienamen hat.
Solch eine proggeinschraenkung ist aber auch nicht gewuenscht und somit bleibt
es, wie es ist: Magier, die Erstienamen weitergeben an Spieler werden im
Erstfall verwarnt, dann gespielpaust und beim dritten Mal sind die Historie.

Yantro

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



Re^9: Magisterposten (Patryn, 12. Nov 1997, 11:55:07):
~#! rn=Ringor rt=879277944 rg=gilden.zauberer
~#! tid=878806724
immer sprich allen und jedem dein misstrauen aus. am besten, alle rechte
ausserhalb eines em-direkt-accounts werden abgeschafft und wer was geprogt
hat muss es halt bei einer person mit solchigem abliefern...
man kann es auch irgendwie uebertreiben, mir zumindest sind saemtliche
zweitieflags oberschnuppe und das duerfte auch den meisten anderen magiern
und spielern so gehen.

------
patryn hat grad schlechte laune

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



Re^10: Magisterposten (Rantanplan, 12. Nov 1997, 12:20:10):
~#! rn=Patryn rt=879332107 rg=gilden.zauberer
~#! tid=878806724

*lach*

Und wer als Magier ne fackel cloned wird beim ersten mal verwarnt
beim zweiten mal gepaused und beim dritten mal geloescht.

Und natuerlich wer beim stehend Pinkeln erwischt wird ebenso, und wenn man
onaniert sowieso, und ganz wichtig, wer beim anschauen von
Nachmittagstalkshows
erwischt wird, und ueberhaupt jeder, der was falsches sagt.

Und das von Yantro, der soweit ich mich erinnern kann mehrfach, durch 
die obskuren Gnaden netter Erzies vor der Loeschung gerettet wurde.

Meiner unbescheidenen Meinung nach, ist das hier ein richtig nettes
Beamtenmud.


Mir gefaellt das irgendwie ;-)

Aber arm isses schon...

Oe*

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



Re^3: kaempfergilde (Janitze, 12. Nov 1997, 14:16:00):
~#! rn=Mango rt=879250352 rg=gilden.zauberer
~#! tid=879247350
warum fragen, ob man den Funakoshi plaetten darf ? Der ist doch sowieso
nur nen bloeder karateka, da muss man net fragen.

Janice sagt: Tot den Karatekas !

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



Re^10: Magisterposten (Teddy, 14. Nov 1997, 17:53:44):
~#! rn=Patryn rt=879332107 rg=gilden.zauberer
~#! tid=878806724

Koennte dieses Misstrauen evtl. gerechtfertigt sein oder warum reagierst du so
verbittert?

Anscheinend gibt es ja hier genug Magier, die Ihre Moeglichkeiten illegal
nutzen, also finde ich es nachvollziehbar, das man da eine etwas hoehere
Schranke vorschlaegt, auch wenn ich Yantros Argument mit den Features
akzeptiere, vielleicht kommt ja mal eins ;)

Teddy

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



Re^11: Magisterposten (Wurzel, 14. Nov 1997, 19:53:14):
~#! rn=Teddy rt=879526424 rg=gilden.zauberer
~#! tid=878806724
dieses misstrauen ist teilweise gerechtfertigt, und das nervt. dadurch 
werden leute, die wirklich was tun, in ihrer arbeit behindert. wenn es nach
mir ginge... tut es aber nicht *schulterzuck*
anscheinend kann man ein mud nicht anders betreiben, weil es immer wieder
idioten gibt. eine huerde ist ja schon geschaffen, indem nicht jeder, der die
kriterien zur magierwerdung erfuellt, sofort vollstaendigen zugriff hat. ob
das reicht, ist allerdings eine andere frage. es gibt muds, wo inaktive
wurstmagier, die nichts programmieren, nach einer "schonfrist" geloescht
werden...

nur so ein paar ideen
wurzel

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



Re^12: Magisterposten (Ringor, 14. Nov 1997, 23:18:33):
~#! rn=Wurzel rt=879533594 rg=gilden.zauberer
~#! tid=878806724
Das mit dem nicht vollstaendigen Zugriff fuer Neumagier finde ich persoenlich
noch immer eine sehr gute Idee.

Was ich aber wohl nie dadran verstehen werde, ist Folgendes: wenn diese
Einschraenkung doch genau aus dem Grund eingefuehrt wurde, weil mehrere alte
Level-21 Magier ihre Moeglichkeiten illegal eingesetzt haben, warum wurden
nach der Einfuehrung des Level 15 nicht alle Level-21 Magier auf eben diesen
Level zurueckgestuft?

Bei Magiern, von denen man weiss, dass sie programmieren (wollen), kann man
die Abstufung ja genauso leicht wieder rueckgaengig machen. So wie es bisher
geloest ist, trifft es aber auf jeden Fall nur den Nachwuchs - die bisher
unentdeckten Clone-, Trans-, Heil- und Wasweisich-Level-21-Magier bleiben
weiterhin erhalten.

Ringor. Ist nur kleiner dummer Zwerg und muss nicht alles verstehen.

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



Re^13: Magisterposten (Wurzel, 15. Nov 1997, 00:00:01):
~#! rn=Ringor rt=879545913 rg=gilden.zauberer
~#! tid=878806724
das war eigentlich das, was ich sagen wollte. fuer die masse der level-21
magier ist m.e. die schonfrist abgelaufen, auch fuer einen grossen teil der
level-25er. wer was angeschlossen hat, ist normalerweise level 26.
ist fuer mich nicht ganz einsehbar, warum jemand, der eh nix macht, magier
sein sollte.

wurzel

p.s. ja, das gilt auch fuer grimmborn :)

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



It's time to flame again... (Pyro, 20. Nov 1997, 13:22:55):
Hi Zauberers,
nach metzeln des Tempeldrachen musst ich feststellen: 
Wo ist das Erz?? Nach etwas Rumfragen erfuhr ich, dass auch andere
Zauberkomponenten einfach abgehaengt wurden. Spaetestens bei der
Begruendung dafuer wurd ich dann doch etwas sauer...
Para streitet sich mit Silvana und Patryn wegen der Komponenten (worums 
genau ging ist mir letztlich Wurscht) und weil er nu sauer auf Patryn ist, 
haengt er uns unsere Komponenten ab. Da frag ich mich: Muss man als Magier
seine Streitereien auf Ruecken der Spieler austragen? Mich erinnert das Ganze 
an Leute, die, wenn sie Streit mit dem Nachbarn haben, dafuer dann ihren Hund 
treten.
Mit feuriger Wut im Bauch
           Pyro


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



Re: It's time to flame again... (Patryn, 20. Nov 1997, 13:39:22):
~#! rn=Pyro rt=880028575 rg=gilden.zauberer
~#! tid=880028575
das mit den komponenten tut mir ehrlich leid und ich hoffe, wir koennen das
irgendwie wieder in ordnung bringen. dass nicht jeder machen kann, was er
will, ist eigentlich logisch und ich bin selbst etwas verwundert, dass
_ausgerechnet_ paracelsus damit nicht zurecht kommt. schliesslich tanzen
sonst wir alle nach seiner pfeife...
da das erz sonst recht schwer zu besorgen waer, hab ich es voruebergehend
einem anderen lebewesen verpasst, in der bibo nachlesen, wie ueblich.
es kommen auch noch ein paar andere gebiete in zukunft, sodass sich da
wahrscheinlich nochmal etwas aendern wird.

------
patryn

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



Re: Re: It's time to flame again... (Key, 20. Nov 1997, 16:16:46):
~#! rn=Patryn rt=880029562 rg=gilden.zauberer
~#! tid=880028575
Hmm dass nicht jeder machen kann was er will ....
Also hab da was von laeuten hoeren das para bescheid gegeben hat aber keiner
genau nachgesehen ;)
Naja und scheinbar hat wer einen gewissen Code net richtig gelesen ... denn
die zahl die gemeint war ist astronomisch hoch, aber nie dagewesen ;)

So wers versteht weiss was ich mein ;))

Key
,

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



Wahlauswertung (Silvana, 20. Nov 1997, 16:52:41):
So, die zwei Wochen sind rum, die Wahl wurde ausgewertet. Hier das Erbegnis:

Auf den Plaetzen 1-3 nahezu stimmgleich:
  Dhojakt, Murmel und Pyro.
Der Rest vollkommen abgeschlagen.

Aus diesem Grund werd ich mal die Groesse des Rates auf drei erhoehen.
(Es ging da nur um eine Stimme) Anschliessend wird nun der Magier 
gewaehlt, der mit in die Vertretung kommt. Zur Wahl stehen:

  Li
  Paracelsus
  Patryn

Rein kommt einer, bei Stimmgleichheit 2.

  Silvana

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



Wahlausgang (Silvana, 30. Nov 1997, 00:30:34):
Hi.

Ich hab soeben die Wahl fuer den Magier im Gildenrat ausgewertet.
Gewonnen hat Li mit mehr als 50% der Stimmen. Der Gildenbeirat besteht
also aus:
  Dhojakt, Li, Murmel und Pyro (alphabetisch um keine Praeferenzen 
                                auszudruecken...)

Ich hoffe, die vier werden sich irgendwie absprechen... 

  Silvana

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



Re: Wahlausgang (Hadra,  1. Dez 1997, 19:43:19):
~#! rn=Silvana rt=880846234 rg=gilden.zauberer
~#! tid=880846234
damit bringst du eine ausgesprochene praeferenz fuers alphabet zum ausdruck.

hadra - schreibt einzeiler die nach schmarrn gehoeren

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



bibliothek (Patryn,  3. Dez 1997, 21:41:05):
wegen kleiner syntaktischer erweiterungen lohnt es sich, nochmals die
bucher zu erschaffe, gefaehrte und selbstverwandlung zu lesen.

------
patryn

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



Re: bibliothek (Key,  3. Dez 1997, 21:42:38):
~#! rn=Patryn rt=881181665 rg=gilden.zauberer
~#! tid=881181665
Du samma Patrynchen ...
Isses eigentlich schlimm wenn man noch nie son Teil gelesen hat? :)

Key

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



Re: Re: bibliothek (Silvana,  3. Dez 1997, 22:05:58):
~#! rn=Key rt=881181758 rg=gilden.zauberer
~#! tid=881181665
Ui, Patryn ist ja schneller als Highlander erlaubt. :) 
Die Aenderung bei 'gefaehrte' ist NOCH nicht aktiv... Kommt aber
- ja nach Streik - naechste Woche spaetestens.

  Silvana

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



Re^3: bibliothek (Key,  3. Dez 1997, 22:06:48):
~#! rn=Silvana rt=881183158 rg=gilden.zauberer
~#! tid=881181665
STREIK???
Auf das Wort reagiere ich allergisch!

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



Re^3: bibliothek (Silvana,  4. Dez 1997, 08:05:30):
~#! rn=Silvana rt=881183158 rg=gilden.zauberer
~#! tid=881181665
So, die Aenderung bei 'gefaehrte' ist aktiv. Ebenso ein kleiner Bugfix bei
'daemonenfratze'. Viel Spass damit... :)

  Silvana

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



Combat-Verbesserungsvorschlag (Taragon,  6. Dez 1997, 08:53:46):
Ich wusste nich genau wohin damit, also dachte ich mir, dies gehoert hier
nach Zauberer...
Die Kampfmeldungen wurden meines Wissens insofern verbessert, dass man nur
noch die Treffermeldungen bekommt ohne das ewige 'Du greifst Blah mit Blubb
an.'
Wieso ist dies nicht auch fuer die brennenden Haende eingebaut worden ?
Ich schaetze, das duerfte doch kein Problem sein, denn es ist schon ein
bischen
nervig, immernoch alles zweizeilig zu kriegen.

Taragon

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



Re: Combat-Verbesserungsvorschlag (Key,  7. Dez 1997, 14:03:42):
~#! rn=Taragon rt=881394826 rg=gilden.zauberer
~#! tid=881394826
Es ist eingebaut ... vielleicht sollteste es nurnoch einstellen? .)

Key

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



Re: Re: Combat-Verbesserungsvorschlag (Taragon, 12. Dez 1997, 19:28:37):
~#! rn=Key rt=881499822 rg=gilden.zauberer
~#! tid=881394826
Jo, Key... vielleicht isses eingebaut. Aber ich habe mich totgesucht, wo man
das 'einstellen' koennen soll, und nix gefunden.
Ich kriege immernoch diese nervigen messages... und wenn man hauptsaechlich 
mit 'hand' und 'schnell' kaempft kann das gewaltig laestig sein.
Wenn Du es doch weisst, schreib mir einfach, wie ich das einstellen soll.

Taragon

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



Re^3: Combat-Verbesserungsvorschlag (Randal, 13. Dez 1997, 21:05:04):
~#! rn=Taragon rt=881951317 rg=gilden.zauberer
~#! tid=881394826
angriffsmeldung war der befehl glaube ich ,)

Ran

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



Re^4: Combat-Verbesserungsvorschlag (Taragon, 15. Dez 1997, 00:31:51):
~#! rn=Randal rt=882043504 rg=gilden.zauberer
~#! tid=881394826
Merci... aber woher soll man das wissen ?
Nix in der 'hilfe' und unter 'hilfe angriffsmeldung' steht auch nix :(

Taragon

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



Gildenbrett in der Kneipe (Taragon,  5. Jan 1998, 03:27:33):
Hi 

Das Brett in der Kneipe, das 'noch nicht funktioniert' ...
Wird das _irgendwann_ mal wirklich funktionieren oder ist das schon in
Vergessenheit geraten ?

Taragon - nur mal so gefragt

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



Re: Gildenbrett in der Kneipe (Patryn,  5. Jan 1998, 08:39:38):
~#! rn=Taragon rt=883967253 rg=gilden.zauberer
~#! tid=883967253
mir ist leider noch nicht eingefallen, was man damit sinnvolles tun koennte,
schliesslich steht in der mpa bereits genuegend muell der mich annehmen
laesst, dass man probleme mit sinnvollen beitraegen hat. dem sogenannten
schwarzen brett wuerde es wohl auch kaum besser ergehen...
vorschlaege und aenderungsankuendigungen zur gilde koennen auch in die
zeitung denk ich mal, der gildenbeirat sei hier uebrigens mal angesprochen,
etwas transparenter fuer ihre mitspieler zu arbeiten.

------
patryn

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



Re: Re: Gildenbrett in der Kneipe (Key,  5. Jan 1998, 12:54:41):
~#! rn=Patryn rt=883985978 rg=gilden.zauberer
~#! tid=883967253
Der arbeitet? :)

Key

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



Webseiten der Zauberergilde... (Anatol,  8. Jan 1998, 19:46:37):

Gelungen.

Anatol


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



Stammtischnachlese.. (Pyro,  8. Jan 1998, 20:26:29):
Was klein Pyro so im Laufe des letzten Stammtischs lernte...

HOW TO BECOME SOUCERER IN TWO SIMPLE DAYS...
1. Man lege sich mal eben 1.mill. Muenzen bereit zum Zauberberg tanken.
2. Stelle man sich mal lieb und dumm an und erfrage alle Uebe-Tips
...die 'alten Hasen' sind alle daemlich genug fleissig zu helfen.
3. Starte man nun 2 Tage lang seine Uebescripte.
4. Wo es einem nicht schnell genug geht, helfe man dann mit seinem Magier 
(wie, solltest du etwa nicht Magierzweiti sein oder ueber einen Magier 
verfuegen??)von Hand nach.
5. Danach schreibe man einen Beschwerdebrief an Silvana, in dem man sich 
darueber beschwert, dass die zauberer ja wohl viel zu schnell hochuebbar sind.

Schon hat man seinen Zauberermagister mit dem man sich auf Stammtischen 
als 'in nur 2 tagen hochgespielt' ruehmen kann.


*kein Kommentar*
           Pyro


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



Re: Stammtischnachlese.. (Patryn,  8. Jan 1998, 20:30:48):
~#! rn=Pyro rt=884287589 rg=gilden.zauberer
~#! tid=884287589
du wirst dir doch das alte stammtisch-problem nicht zu sehr zu herzen nehmen:
 schliesslich werden nach dem 5. bier schnell 20 tage zu zweien und aus
einer hydra werden 100. ich liebe es einfach zuzuschaun, wenn mudder
wild mit den armen rudernd und fuerchterlich ausdrucksstark gestikulierend
von ihren letzten abenteuern berichten :)

------
patryn


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



Re: Re: Stammtischnachlese.. (Anatol,  8. Jan 1998, 20:33:23):
~#! rn=Patryn rt=884287848 rg=gilden.zauberer
~#! tid=884287589
Ich finde das typische "Ist ja interessant"-Schmunzeln des einen oder 
anderen Magiers viel schoener - vergleichsweise eindrucksvoll ist dann 
der Schrei des betroffenen Spielers, der bemerkt, dass sich in seiner
virtuellen Welt wieder eine Kleinigkeit veraendert hat...

Filzt den Muensteraner Filz,
Anatol


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



Webseiten (Birdy,  9. Jan 1998, 15:30:46):
Erstmal ein Dankeschoen :).
Dann fuer alle, die es noch nicht wissen, die Webseiten der Zauberer sind
jetzt von der allgemeinen Gildenseite auf der MG-Homepage erreichbar.

Viel Spass ! Birdy

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



Re^3: Stammtischnachlese.. (Key, 11. Jan 1998, 17:36:57):
~#! rn=Anatol rt=884288003 rg=gilden.zauberer
~#! tid=884287589
Also ich mag dann mehr die Mags die dann schwere Sachen versprechen und
hoellisch schwere proggen :))

Oder die die wirkliche alle Ideen (auch witze) aufgreifen ;))

Key

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



Giledenseiten (Shorkan, 13. Jan 1998, 08:15:04):
Hi Zauberers

Danke Birdy, fuer die Gildenseiten. Absolut gelungen !!

Shorkan

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



Idee (Birdy, 14. Jan 1998, 12:21:54):
Koennte man fuer die Zauberer nicht auch sowas wie einen Zauberstabkampfskill
einrichten ?

Birdy ,vor Ideen spruehend ;)

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



Re: Idee (Aline, 14. Jan 1998, 14:28:22):
~#! rn=Birdy rt=884776914 rg=gilden.zauberer
~#! tid=884776914

hmmm ich dachte sowas haetten wir. Am Anfang hab ich kaum mit dem
Ding getroffen und Llystrathe sagte mir auch auf Nachfrage, dass
ich kaum damit umgehen kann.

Aline

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



Re: Re: Idee (Silvana, 14. Jan 1998, 16:13:37):
~#! rn=Aline rt=884784502 rg=gilden.zauberer
~#! tid=884776914
Korrekt, Aline. Die Fertigkeit im Umgang mit dem Zauberstab beeinflusst
auch den Schaden, den man damit anrichten kann.

  Silvana

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



Re^3: Idee (Birdy, 14. Jan 1998, 16:30:07):
~#! rn=Silvana rt=884790817 rg=gilden.zauberer
~#! tid=884776914
GUUUT. :)))))
Birdy, hocherfreut

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



Re^4: Idee (Morgoth, 15. Jan 1998, 07:53:35):
~#! rn=Birdy rt=884791807 rg=gilden.zauberer
~#! tid=884776914
Ist ja nett, dass Du das auch schon merkst ;-)
Hm. Wie war das...Zauberer kennen verletze und schutz...das reicht doch ;-) 
M*

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



Re^5: Idee (Teddy, 15. Jan 1998, 15:42:18):
~#! rn=Morgoth rt=884847215 rg=gilden.zauberer
~#! tid=884776914
Schattenkaempfer, Hand und Extrahand nicht zu vergessen.
Ach ja, fluchtrichtung teleport natuerlich noch.

Teddy

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



Re^5: Idee (Trekan, 20. Jan 1998, 14:32:33):
~#! rn=Morgoth rt=884847215 rg=gilden.zauberer
~#! tid=884776914
Aber so n ork mit zauberstab waere doch ne feine sache ;)

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



Zweigseiten (Birdy, 21. Jan 1998, 17:38:02):

Hiho :)

Fuer alle, die stolz darauf sind, Magister eines Zweiges geworden zu sein.
Sie duerfen ab heute ihre Namen auf den Zweigseiten bewundern und all ihren
Freunden zeigen. :)

Sorry, dass das solange gedauert hat, hatte zuviel um die Ohren.

Birdy, sich jetzt auch bewundern lassend

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



Komponentennamen (Therin, 24. Jan 1998, 23:08:40):
Mir ist aufgefallen, dass man im Laden in der Gilde mit einem

kaufe federn

nicht mehr wie "frueher" Raben- sondern Sturmvogelfedern kauft.

Was haltet ihr davon, das wieder umzuaendern, oder andersherum gefragt:

moechte die Mehrheit lieber "Schattenkaempfer" oder "Schnell" zaubern und
dabei natuerlich den kuerzeren Befehl benutzen?

Therin,
kauft lieber Komponenten fuer Schattenkaempfer

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



Re: Komponentennamen (Key, 26. Jan 1998, 13:15:52):
~#! rn=Therin rt=885679720 rg=gilden.zauberer
~#! tid=885679720
Hmm ich tipp immer zkaufe ;) das reicht :)

Key

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



Re: Komponentennamen (Patryn, 28. Jan 1998, 07:26:42):
~#! rn=Therin rt=885679720 rg=gilden.zauberer
~#! tid=885679720
mir ist das prinzipiell wurscht...nur genuegend fuersprecher musst du
finden, sonst ruehr ich da nix an :)

------
patryn, der rabenschwungfedern lieber woanders besorgt

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



Re: Re: Komponentennamen (Obermotz, 28. Jan 1998, 10:00:35):
~#! rn=Patryn rt=885968802 rg=gilden.zauberer
~#! tid=885679720
Direkt befragt wuerde ich auch den Schattenkaempfer vorziehen. Man wird ja
doch eher mal gebeten einen Schatten in den Uebungsraum zu stellen, als den
Schnall-Zauber zu sprechen.

OM, immer noch schreibfaul

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



Re^3: Komponentennamen (Birdy, 28. Jan 1998, 15:32:18):
~#! rn=Obermotz rt=885978035 rg=gilden.zauberer
~#! tid=885679720
Also ich bin dafuer, dass so zu lassen.
Ich tippe lieber "kaufe federn" als "kaufe sturmvogelfedern".
Ist mir ein bisschen zu lang.

Birdy

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



Re^4: Komponentennamen (Therin, 28. Jan 1998, 16:29:56):
~#! rn=Birdy rt=885997938 rg=gilden.zauberer
~#! tid=885679720

es steht nun 2:1 fuer rabenfedern
andere meinungen?

T.

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



Re^5: Komponentennamen (Hangover, 28. Jan 1998, 16:30:29):
~#! rn=Therin rt=886001396 rg=gilden.zauberer
~#! tid=885679720
Tach!

3:1 fuer Rabenfedern.

Hangover, im Auftrage seines Zweitis.

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



Re^6: Komponentennamen (Zorro, 28. Jan 1998, 16:41:50):
~#! rn=Hangover rt=886001429 rg=gilden.zauberer
~#! tid=885679720
ich bin fuer ne zombieharpyiefeder

zorro 

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



Re^7: Komponentennamen (Ancalagon, 30. Jan 1998, 10:06:40):
~#! rn=Zorro rt=886002110 rg=gilden.zauberer
~#! tid=885679720
Knuddels! :)

3:2 ! *grins*

Ancalagon (winkt 'hallo' zu birdy!)

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



Komponentennamen (Therin,  1. Feb 1998, 22:25:10):

Und der Rest hat keine Meinung zu dem Thema?

Rabenfedern zu sturmfedern steht 3:2


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



Re: Komponentennamen (Mingo,  1. Feb 1998, 22:59:15):
~#! rn=Therin rt=886368310 rg=gilden.zauberer
~#! tid=886368310
Ich bin fuer Sturmfedern. Deuce.

Gloin

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



Re: Re: Komponentennamen (Dhojakt,  1. Feb 1998, 23:06:39):
~#! rn=Mingo rt=886370355 rg=gilden.zauberer
~#! tid=886368310
Wenn das mal so geaendert wird, dass man die Sturmvogelfedern mit Sturmfedern
kaufen kann isses mir egal, ansonsten bin ich fuer die Sturmvogelfedern.
3:3.5 macht das dann wohl (und bald ne verlegung nach schmarrn).
Dhojakt.

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



Re^3: Komponentennamen (Trekan,  2. Feb 1998, 11:56:38):
~#! rn=Dhojakt rt=886370799 rg=gilden.zauberer
~#! tid=886368310
4:3 Rabenschwungfedern brauch der mensch
Trekan

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



Re^4: Komponentennamen (Zarniya,  2. Feb 1998, 12:06:47):
~#! rn=Trekan rt=886416998 rg=gilden.zauberer
~#! tid=886368310
Hmm kann mir mal einer erklaeren, was diese Abstimmung bezwecken soll? Will
dann nachher einer hingehen und die Zauberermagier, also Silvana und Patryn
ZWINGEN, dass dann gefaelligst umzuaendern? Ich versteh die Aufregung nicht..
hier ist ein nettes Mud, in dem die Anzahl der erlaubten aliases nicht mal
limitiert ist... also macht euch eins, wenns sein muss.. alles andere hier
wird zu einem Kropf und ich bin sicher, dass Silvana ziemlich egal ist, was
ihr hier abstimmt.

Zarniya

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



Re^4: Komponentennamen (Acrimon,  2. Feb 1998, 12:07:11):
~#! rn=Trekan rt=886416998 rg=gilden.zauberer
~#! tid=886368310
Schreibfedern will ich haben!
4:3:1

Acrimon

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



Re^5: Komponentennamen (Mingo,  2. Feb 1998, 12:37:14):
~#! rn=Zarniya rt=886417607 rg=gilden.zauberer
~#! tid=886368310
Es ist ein schoener Schmarrn-Thread. Oder die Leute meinen es tatsaechlich
ernst ... dann empfehle ich: hilfe alias

Mahatmu stimmt auch fuer Schreibfedern: 4:3.5:1.33

Gloin

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



Re^5: Komponentennamen (Key,  2. Feb 1998, 12:41:33):
~#! rn=Zarniya rt=886417607 rg=gilden.zauberer
~#! tid=886368310
Zarnblabla ... wenn ich net irre hat Patryn ausdruecklich geschrieben er
aendert es so wie es die Spieler haben wollen.
Und hier entscheidet sich gerade wie sie es haben wollen.

Irgendein Problem damit?
Key

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



Re^5: Komponentennamen (Patryn,  2. Feb 1998, 13:06:05):
~#! rn=Zarniya rt=886417607 rg=gilden.zauberer
~#! tid=886368310
in der tat werde ich mich in solchen nichtkonzeptionellen dingen
tatsaechlich nach den spielern richten und ich seh da ausnahmsweise mal
nichts schlechtes bei ;)
trotzdem ist diese abstimmungsgeschichte (wirklich so wichtig?) hier falsch
am platz, gerade solche dinge sollte der gildenbeirat (noch existent?)
ausdiskutieren und dann an uns weiterleiten.

------
patryn

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



Ein Vorschlag zu "werte" (Obermotz,  4. Feb 1998, 11:00:51):
Der Werte-Spruch wurde je etwas besser, nachdem man die Lehrlingspruefung
abgelegt hat und seinen zauberstab bekommen hat. Ich habe mal nach gefragt:
leider gibt "werte" keinen genaueren Angaben, wenn ein Magister (oder
Erzmagister) ihn spricht. Oder sind das (halbwegs) genaue Gewicht oder der
Preis solche grossen geheimnisse, dass die Spieler das nicht wissen duerfen.
Zumindestens den Preis erfaehrt man ja in jedem Laden.
Was haltet Ihr davon? Ich wurde diese Infos gerne vom Werte-Spruch bekommen
(falls ich in absebarer zeit Magister werde).

Obermotz, der alles genau wissen will

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



Freundliche Warnung (Bendeigid,  8. Feb 1998, 17:40:01):
Ich verweise auf Artikel 10, gilden.kaempfer.

Kein besonderer Anlass nur zur Kenntnisnahme. :))

Z'par Servu,
             Bendeigid

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



Re: Freundliche Warnung (Therin,  8. Feb 1998, 17:46:35):
~#! rn=Bendeigid rt=886956001 rg=gilden.zauberer
~#! tid=886956001

       * grummel *



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



Re: Re: Freundliche Warnung (Hangover,  8. Feb 1998, 22:00:52):
~#! rn=Therin rt=886956395 rg=gilden.zauberer
~#! tid=886956001
Wieder typisch, dass die Schuettler und Chaoten nicht gewarnt
wurden... *grummel* Dafuer kann es nur eine Antwort geben:
Alle umhauen :-)

-Hangover

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



Re^3: Freundliche Warnung (Sting,  8. Feb 1998, 22:02:28):
~#! rn=Hangover rt=886971652 rg=gilden.zauberer
~#! tid=886956001
Nicht typisch... 
Welcher Chaot oder meinetwegen Schuettler metzelt die schon ?
Ohne Teleport war das bisher sauschwer

Sting

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



Re^4: Freundliche Warnung (Therin,  8. Feb 1998, 22:03:20):
~#! rn=Sting rt=886971748 rg=gilden.zauberer
~#! tid=886956001

Und TP wuerde es einfacher machen? fr s ist doch genauso gut...


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



Re^4: Freundliche Warnung (Ringor,  8. Feb 1998, 22:03:30):
~#! rn=Sting rt=886971748 rg=gilden.zauberer
~#! tid=886956001
Falsch. Die Fluchtrichtung "schlafe ein" war bisher noch sicherer, als
"teleport".

Ringor. Freut sich ueber den frischen Wind im Struv.

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



Re^5: Freundliche Warnung (Sting,  8. Feb 1998, 22:04:42):
~#! rn=Ringor rt=886971810 rg=gilden.zauberer
~#! tid=886956001
Naja... Schlafe ein war ok, das stimmt... aber aushalten tuts ein Chaot da eh
nicht lange :) und fluchtrichtung sueden ist nicht gerade optimal, Therin :))


Sting

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



Re^5: Freundliche Warnung (Hangover,  8. Feb 1998, 22:05:31):
~#! rn=Ringor rt=886971810 rg=gilden.zauberer
~#! tid=886956001
Mir fliehen nach sueden ist nix, wenn Briesel Dich nicht mehr
gehen lassen will...sowas hat Bende* wohl nicht ausgebaut :(

Hang*

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



Re^6: Freundliche Warnung (Ringor,  8. Feb 1998, 22:05:35):
~#! rn=Sting rt=886971882 rg=gilden.zauberer
~#! tid=886956001
Doch doch, Fluchtrichtung sueden ist da optimal. Fuer die Wachen. :-)

Ringor. Freut sich schon auf die naechsten Angreifer.

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



Re^7: Freundliche Warnung (Sting,  8. Feb 1998, 22:06:12):
~#! rn=Ringor rt=886971935 rg=gilden.zauberer
~#! tid=886956001
Ist mir eh egal, ich hab die Kills :)


Sting

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



Re^8: Freundliche Warnung (Ringor,  8. Feb 1998, 22:07:48):
~#! rn=Sting rt=886971972 rg=gilden.zauberer
~#! tid=886956001
Eigentlich sollten die NPCs dich dann ja auf ne schwarze Liste setzen. So mit
Kopfgeld fuer jeden Kaempfer, der deinen Kopf bringt oder so ... ]:->

Ringor. Findet, dass PKs manchmal doch recht reizvoll waeren.

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



Re^8: Freundliche Warnung (Felagund,  9. Feb 1998, 00:22:37):
~#! rn=Sting rt=886971972 rg=gilden.zauberer
~#! tid=886956001
Stimmt, der Fairness halber sollte man bei einer Verstaerkung des
entsprechenden NPCs die Erstkillstupse dafuer wieder abziehen..in diesem Falle
die fuer das Struv, auch wenn da kein NPC an sich verstaerkt wurde ;)

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



Besaufen... (Anacrion, 14. Feb 1998, 04:36:58):

Also ich nehme an, dass da schon mal so dies und das in den kneipen geaendert
wurde, sonst wuerde es mir nicht passieren, nach einem herforder pils
sternhagelvoll zu sein, dieses voellegefuehl aber in 20 sec abzubauen....

Es mag zwar in ordnung sein, dass elfen weniger vertragen....aber der
momentane zustand ist abolut katastrophal, da man nicht mehr unter
kontrolliertem alkoholeinfluss ueben kann :((

Anac* - seine Silbernadeln fuer gelungene Zauber verschleudernd..

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



Re: Besaufen... (Sting, 14. Feb 1998, 10:55:15):
~#! rn=Anacrion rt=887427418 rg=gilden.zauberer
~#! tid=887427418
Ich behaupte jetzt einfach mal, dass das ein Bug ist, da ich auch Elf bin und
keine Veraenderung bemerken kann...
Auch bei anderen Rassen merke ich nix, ausserdem hiesse es ausdruecklich am
_Montag_ kommen die neuen Kneipen


Sting

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



Re: Re: Besaufen... (Geordi, 14. Feb 1998, 13:04:19):
~#! rn=Sting rt=887450115 rg=gilden.zauberer
~#! tid=887427418
Also das mit dem Alk ist mir gestern abend auch schon aufgefallen.
Eben hat mich uebrigens der Bettler in PV angehaucht, und mein Alkoholpegel
stand bei 'Dein Blut fliesst auf Ethanol-Basis'.
Wenn sich da bitte mal JEMAND drum kuemmern koennte.

Geordi

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



Re^3: Besaufen... (Mingo, 14. Feb 1998, 13:04:49):
~#! rn=Geordi rt=887457859 rg=gilden.zauberer
~#! tid=887427418
Der ist so gedacht. Wurst. Geniess es.

Gloin

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



Re^4: Besaufen... (Sting, 14. Feb 1998, 14:15:12):
~#! rn=Mingo rt=887457889 rg=gilden.zauberer
~#! tid=887427418
Ich kann immer nur wieder staunen ueber die perfekte Ausdrucksweise von Gloin.

Sting
PS: Vielleicht sollte sich manche endlich mal ueberlegen sich in der MPA zu
maessigen...

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



Besaufen... (Lou, 14. Feb 1998, 14:22:24):

Gloin halt...

Mr. Lou Cyfer


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



Aloholbug (Silvana, 14. Feb 1998, 20:09:49):
Dank Nachtwinds Unterstuetzung habe ich jetzt die Stelle gefunden,
an der das maximale Alkoholniveau reduziert wurde. Die Stelle ist
korrigiert, der Verursacher 'informiert'. War nur nen Typo im Code,
aber nen hoechst unschoener. Los werdet ihr die reduzierte 
Trinkfestigkeit mit 'ende' oder der Hilfe durch einen freundlichen
Magier. 

  Silvana

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



Re: Besaufen... (Asmodis, 14. Feb 1998, 20:24:28):
~#! rn=Anacrion rt=887427418 rg=gilden.zauberer
~#! tid=887427418
Pfft, wer sagt denn, dass du unter Alk-Einfluss ueben musst ??
Ist auch nicht viel effektiver und ausserdem sicher nicht so gedacht ...

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



Neues (Silvana, 16. Feb 1998, 12:14:27):
Hi.

Es gibt wieder mal ein Update des Spellbooks und damit ein paar kleine
Aenderungen:

1) Die Hellsicht-Magister haben einen neuen Spruch. Magieaura hingegen
   gibts nicht mehr.
2) Es gibt ein paar kleine Aenderungen beim Lernen. Ihr werdet es
   selbst merken... :) Nur ein kleiner Tip: Ueben in voller Ruestung
   solltet ihr lieber sein lassen...
3) finde kann mit 'ignoriere finde' bzw. 'ignoriere finde.spieler'
   ignoriert werden.
4) Gefaehrte sollte jetzt wirklich funktionieren.
5) Phlyaken hat nach zaehen Verhandlungen zugestimmt, keine
   angezogenen oder gezueckten Dinge mehr einzukaufen. :)
6) Da es inzwischen auch bei Spielern Resistenzen gibt, werden diese
   auch von 'identifiziere' angezeigt.
7) Seltsame magische Stoerungen fuehren in letzter Zeit immer wieder
   zu vorzeitig verschwindenden Schutz durch 'rueste'. Weiss Jof, was
   da schief laeuft... Scheint was mit zu viel Metall zu tun zu haben...

Sorry, ist etwas ungeordnet. Ich habs halt einfach mitprotokolliert,
in der Reihenfolge, in der ichs gemacht hab...

  Have Fun - Silvana

PS: Um die Zauberer-Kneipe kuemmer ich mich nachher noch.

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



Re: Neues (Patryn, 16. Feb 1998, 12:18:23):
~#! rn=Silvana rt=887627667 rg=gilden.zauberer
~#! tid=887627667
wenigstens der neue spell ist erstmal in der bibo beschrieben,  andere
ergaenzungen muessen noch etwas warten, bis ich meine pruefungen endlich
hab :)

------
patryn

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



Re: Neues (Taragon, 16. Feb 1998, 16:57:21):
~#! rn=Silvana rt=887627667 rg=gilden.zauberer
~#! tid=887627667
Hmmm...
> ) finde kann mit 'ignoriere finde' bzw. 'ignoriere finde.spieler'
Da sehe ich keinen Sinn darin... ausser den Spruch so ziemlich fuer den ***
zu machen ...

Taragon

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



Re: Re: Neues (Key, 16. Feb 1998, 17:50:35):
~#! rn=Taragon rt=887644641 rg=gilden.zauberer
~#! tid=887627667
Wieso keinen sinn?
Finde war nie zum ausspionieren gedacht ... und wenn man keinen bock hat das
einer einem staendig nachspioniert ist es nicht anderst moeglich :)

Ausserdem ... es kommt bestimmt nur selten vor das jemand das ignoriert,
ausser er hat allen grund dazu.

Key

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



Re^3: Neues (Anatol, 16. Feb 1998, 18:33:03):
~#! rn=Key rt=887647835 rg=gilden.zauberer
~#! tid=887627667
Ich finde es allerhoechstens inkonsequent.
An Seherkugel und Kristallkugel erinnernd,
Anatol


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



Re: Neues (Acrimon, 16. Feb 1998, 19:02:11):
~#! rn=Silvana rt=887627667 rg=gilden.zauberer
~#! tid=887627667
*grins* die zaehen Verhandlungen mit Phlyaken kann ich mir lebhaft vorstellen:

Silvanas Arbeitsraum.
Es gibt keine sichtbaren Ausgaenge.
Silvana.
Silvana macht eine magische Bewegung und Phlyaken erscheint.
Phlyaken schaut ganz verdattert und orientierungslos umher.
Silvana sagt: Ab sofort wirst Du Spielern keine angezogenen oder gezueckten
Gegenstaende mehr abkaufen.
Phlyaken grummelt.
Silvana fummelt am MGTool herum.
Phlyaken kauft Silvana das MGTool ab.
Silvana grummelt.
Silvana sucht nach ihrer Knopfleiste.
Phlyaken kauft Silvana die Knopfleiste ab.
Silvana zueckt eilig ihren Zauberstab.
Phlyaken kauft Silvana den Zauberstab ab.
Silvana aergert sich.
Silvana gruebelt eine Weile herum.
Phlyaken kauft Silvana eine Magiershell ab.
Silvana laeuft rot vor Zorn an.
Silvana ruft: ROCHUS!!!
Phlyaken erschrickt.
Rochus erscheint.
Phlyaken kauft Rochus das MGTool ab.
Phlyaken kauft Rochus die Knopfleiste ab.
Phlyaken kauft Rochus den Zauberstab ab.
Phlyaken kauft Rochus die Magiershell ab.
Rochus wundert sich sehr.
Phlyaken grinst siegesbewuszt.
Rochus denkt . o O ( Das muessen wir auf konventionelle Weise machen )
Rochus greift Phlyaken mit blossen Haenden an.
Rochus zerfetzt Phlyaken in unendlich viele unendlich kleine Atome.
Phlyaken faellt seltsamerweise trotzdem tot zu Boden.
Silvana freut sich.
Silvana dankt Rochus.
Silvana nimmt eine Magiershell.
Silvana nimmt ein MGTool.
Silvana nimmt eine Knopfleiste.
Silvana nimmt einen Zauberstab.
Rochus nimmt eine Magiershell.
Rochus nimmt ein MGTool, einen Zauberstab und eine Knopfleiste.
Silvana fummelt eine Weile an ihrem MGTool herum.
Silvana richtet ihr MGTool auf den toten Phlyaken und ein magisches Summen
ertoent.
Silvana sagt: So, Phlyaken ist ueberredet.


Sogar mit Nicht-Rueckfall-Garantie :-)

Acrimon, der Rote Ritter

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



Re: Re: Neues (Shorkan, 17. Feb 1998, 08:31:55):
~#! rn=Acrimon rt=887652131 rg=gilden.zauberer
~#! tid=887627667
Hm, neuerdings muesste es heissen:
Rochus zerfetzt Phlyaken in unendlich viele unendlich kleine Atome.
Phlyaken faellt seltsamerweise trotzdem tot zu Boden.
Du siehst einen Fehler im Raum-Zeit-Gefuege
Phlyaknen.
Rochus zerfetzt Phlyaken in unendlich viele unendlich kleine Atome.
Phlyaken faellt seltsamerweise trotzdem tot zu Boden.

Shorkan =:)

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



Dem Lag sei dank (Shorkan, 17. Feb 1998, 10:04:10):
Hi
Das neue Tanksystem ist zwar etwas gewoehnungsbeduertftig, aber ich denke es
ist nicht mal so uebel.
Ich musste aber feststellen, dass ich mit Lag besser ueben kann als ohne, da
ich mit einem puren Telnet arbeite und noch alles von Hand eingebe.
Ich kann mir aber vorstellen, dass mancher Spieler auf einen intelligenten
Client umsteigt, und sich da Trigger etc. setzt
, was durch Aktionen wie entsoren nur noch einmal pro Hardbeat oder Lernen
ohne das Tragen von stark behindernder Ruestung noch verstaerkt wird.

Ich kann nur sagen ein Hoch auf das LAG.

 Leider laesst sich mit LAG nicht gut metzeln, aber man kann ja nicht alles
haben.

Shorkan

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



Elfenzauberer (Birdy, 17. Feb 1998, 11:20:43):

Nachdem ich mich heute schon etwas beruhigt habe, moechte ich heute meine
Meinung zu den Aenderungen in unserer Gilde aeussern.
Meine erste Aeusserung betrifft Elfen bei uns: Als Elf kann man sich als
Zauberer wegwerfen, ich glaub ich werde Zwerg oder wechsel die Gilde, wenn
sich nix am Rassenkonzept fuer uns Elfen aendert.
Als zweites moechte ich mich hier darueber beklagen, dass uns Zauberern mit
dem Random-Verschwinden von Rueste und dem Alkeintrichtern in Paras Haus
wieder einmal eins auf die Muetze gegeben wird. Ich dachte, dass die Balance 
schon an uns vorruebergegangen ist, aber anscheinend habe ich mich da wohl
geirrt.

Unsere Gilde war mal so schoen, und ich dachte mir, dass ich als Elf hier am
besten aufgehoben waere, inzwischen hat sich das aber so sehr geaendert, dass
es schon keinen Spass mehr macht.
Nach einem Gespraech heute morgen mit anderen Zauberern, hatte ich mich
entschlossen, diesen Brief hier zu verfassen, um unserer gemeinsamen Meinung
Ausdruck zu verleihen.

Das war erstmal das wichtigste dazu.

Auf Aenderung hoffend : Birdy
*

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



Re: Elfenzauberer (Patryn, 17. Feb 1998, 11:38:15):
~#! rn=Birdy rt=887710843 rg=gilden.zauberer
~#! tid=887710843
deine meinung zu den elfen ist recht vieldeutig, was genau meinst du denn
mit: "Als Elf kann man sich als Zauberer wegwerfen,..."
ich kann dieser aussage keine konstruktive kritik abgewinnen.
das mit dem rueste finde ich zugegebenermassen auch nicht so toll, aber
man kann durchaus damit leben, wenn man erstmal etwas erfahrung mit
dem wann und warum gesammelt hat.

------
patryn

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



Re: Re: Elfenzauberer (Hangover, 17. Feb 1998, 13:24:23):
~#! rn=Patryn rt=887711895 rg=gilden.zauberer
~#! tid=887710843
Moin!

Als Echtspieler, der ja auch einen Elfenzauberer versorgen muss:
Sooo schlimm ist das alles nicht. Das alken in paras haus ist
in weniger als einer minute weggeidelt - selbst schuld also wer
meint, durch die gilde zu skripten.
Und so wie ich Silvana verstanden habe, wird am ruesten noch ein
bisschen modifiziert werden, also empfehle ich da einfaches 
Abwarten.

Hangover,
heute mal geduldig optimistisch

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



Re: Elfenzauberer (Sting, 17. Feb 1998, 18:35:10):
~#! rn=Birdy rt=887710843 rg=gilden.zauberer
~#! tid=887710843
Anatol wuerde sagen: Heul doch!

Ich schliesse mich an...


Sting

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



Re: Re: Elfenzauberer (Key, 17. Feb 1998, 21:20:24):
~#! rn=Sting rt=887736910 rg=gilden.zauberer
~#! tid=887710843
Hmm Du verlaesst die Zauberer?
Cool :)

Birdy wie waers erstmal mit genauen ausprobieren?
Und das schafft man nicht in der kurzen Zeit!

Key

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



Ueben (Anacrion, 17. Feb 1998, 22:15:36):

Aehem. *raeusper*

Also ich finde nicht, dass das Uebesystem, wie es vorher war, das gelbe vom Ei
war....ich haette ein System, das darauf basiert, das man spielt dem
Uebungsraum-besaufdich-Spiel vorgezogen. Allerdings muss ich sagen, dass das
mit dem langsamer lernen wohl eher einSchuss nach hinten ist...

Zum einen kann man nun nicht mehr durchgaengig ueben...mag sein, dass dies RL
etwas stumpfsinnig ist (sowohl, sich mehrere Stunden hinzusetzen und monoton
die selben Tastenkombinationen einzuhacken als auch, dass man 1000mal
hintereinander den gleichen Zauber machen koennte und sich dabei totlernt.
Zum anderen ist es jedoch so, dass Skripter durch ein kleines repeat -1 1
/weiterfunk nicht abgehalten werden, normale Spieler jedoch den (ohnehin nur
ansatzweise durch das anschliessende 'ausserordentlich gut' vorhandenen)
uebespass komplett verlieren.

Vielleicht sollte man ueber eine totalreform des trainingswesens nachdenken,
aber der eingeschlagene Weg ist in meinen Augen nur Skriptfoerdern und dem
Spielspass abtraeglich. (Nur die Telekom freut sich).


Anac* - sinnierend und noch viel lernen muessend.

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



Re: Ueben (Anacrion, 17. Feb 1998, 22:25:23):
~#! rn=Anacrion rt=887750136 rg=gilden.zauberer
~#! tid=887750136

Huch. Da antworte ich mir ja selber....

Na ja..muss wohl daran liegen, dass Silvana _konstruktive_ Kritik fordert...
Hier also ein paar Vorschlaege:

Man lernt ab ca. 80% nur noch durch gelungene Zauber....aber nur dann, wenn er
BESONDERS gut gelungen ist (dem jeweiligen LVL entsprechend). Anhand der
Begrenzung dieses BESONDERS kann man ja festlegen, wie schnell dies gehen
soll. Damit haette auf jeden Fall die Uebskripterei ein Ende....jeder zaubert
halt so gut er kann....

Anac*

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



Re: Ueben (Silvana, 17. Feb 1998, 22:25:55):
~#! rn=Anacrion rt=887750136 rg=gilden.zauberer
~#! tid=887750136
Ich will Euch ja nicht Euren heissgeliebten Frust nehmen, aber 
NEU ist eigentlich nur die Meldung, nicht die Sperre... :)

Btw: Ist schon jemandem die Meldung 'Du lernst aus Deinem Erfolg'
begegnet? :)

  Silvana . o O (Erst ausfuehrlich testen, dann maulen!)

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



Re^3: Elfenzauberer (Sharia, 17. Feb 1998, 22:45:55):
~#! rn=Key rt=887746824 rg=gilden.zauberer
~#! tid=887710843
Zieh nen Rock an wenn du heulen willst .... 

Sharia mal 

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



Re: Ueben (Hangover, 18. Feb 1998, 08:36:50):
~#! rn=Anacrion rt=887750136 rg=gilden.zauberer
~#! tid=887750136
Moin!

Dass das Uebesystem geaendert werden musste, war meiner Meinung nach
wohl allen Zauberern klar - bisher war die Gilde als ganzes zu gut
skriptbar, und als Skript kam man einfach zu schnell auf Werte, die
vom Balancemagier nur genehmigt wurden, weil sie sauschwer zu erlangen
sein sollten (zumindest wurde das immer zur Verteidigung der Zauberer
gesagt). 
Jetzt ist es erst einmal sehr viel schwerer geworden, Faehigkeiten
zu ueben, was mit Sicherheit im Sinne des Spiels ist. Ich halte
das Uebesystem der Zauberer auch nicht fuer sonderlich schoen,
aber wie es aktuell laeuft, stellt es schonmal eine Verbesserung
dar.

-Hangover

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



Re: Ueben (Patryn, 18. Feb 1998, 10:25:41):
~#! rn=Anacrion rt=887750136 rg=gilden.zauberer
~#! tid=887750136
noch mal fuer alle, dies noch nich bemerkt hatten:
 die zeitliche uebesperre ist schon seit ewigkeiten drin. eigentlich sogar
 schon seit beginn der gilde. mit etwas uebeerfahrung haette man es
 eigentlich mitbekommen koennen, denn es spart millionen und ausserdem
 zu frueheren zeiten zahlreiche uebetode.
ich hab das jetzt nur mal geschrieben, damit sich nicht noch mehr leute
selbst laecherlich machen :)

------
patryn

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



Re: Re: Ueben (Anacrion, 18. Feb 1998, 13:53:08):
~#! rn=Patryn rt=887793941 rg=gilden.zauberer
~#! tid=887750136

Hmm. Ich hab jetzt doch viele Zauber auf 100% und das noch nicht
mitgekriegt.... Allerdings muss ich sagen, dass die neue loesung nix gegen das
skripten tut...Durch die Pause laesst sich sogar das neue Tanksystem
utilisieren....

Anac* - immer noch dafuer, dass man ab 80% nur noch durch gelungene Zauber
(sehr langsam und sehr wenig) lernt ('Ja, diese neue Handhaltung beim verletze
scheint echt was zu bringen' ;) ).

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



Re: Elfenzauberer (Taker, 18. Feb 1998, 16:38:25):
~#! rn=Birdy rt=887710843 rg=gilden.zauberer
~#! tid=887710843
Ja, ich als Elf habe seit Montag fast bei jedem zweiten Zauber das "So viel
kannst du nicht auf einmal lernen." gesehen.
Vorher wusste ich noch nicht mal, dass es sowas gibt, ich dachte, man lernt
bei jedem fehlgeschlagenen Spruch was dazu?
Wie erhoehe ich nun mein LErnvolumen? Int erhoehen? oder weiterueben?

Taker

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



Re: Re: Elfenzauberer (Ringor, 18. Feb 1998, 16:39:27):
~#! rn=Taker rt=887816305 rg=gilden.zauberer
~#! tid=887710843
Z.B. durch aufmerksames Lesen der MPA. Lesetip: diese Rubrik, Artikel von
Silvana und Patryn.

Ringor

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



Re^4: Elfenzauberer (Key, 18. Feb 1998, 16:41:50):
~#! rn=Sharia rt=887751955 rg=gilden.zauberer
~#! tid=887710843
Rock??? Ich???
Aber nur fuer Karolus :)

Ich glaub du hast da nen Artikel verwechselt Baertige =;)

Key rockt bestimmt nicht mit nem Rock ;)

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



Re: Re: Elfenzauberer (Therin, 18. Feb 1998, 16:56:37):
~#! rn=Taker rt=887816305 rg=gilden.zauberer
~#! tid=887710843

och, das man beim schnell hintereinander sprechen von missglueckten Zaubern
weniger lernt war mir bekannt. Ich hab mich auch schon immer zu "pausen"
gezwungen. Jedoch die Laenge dieser Sperre hatte ich zugegebener Massen auch
bislang immer unterschaetzt. 10 Sek. Pause machte ich immer, aber leider sinds
ja so 20 oder mehr...

Therin, nimmt die Gildenmagier etwas in schutz.

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



Re: Ein Vorschlag zu "werte" (Key, 18. Feb 1998, 17:29:50):
~#! rn=Obermotz rt=886586451 rg=gilden.zauberer
~#! tid=886586451
20 Sek Lernpause?
Uiui dann hab ich zu damaligen Zeiten ja einiges in den Sand gesetzt :)

Key 

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



Re: Re: Ein Vorschlag zu "werte" (Asmodis, 21. Feb 1998, 01:43:19):
~#! rn=Key rt=887819390 rg=gilden.zauberer
~#! tid=886586451
Hmm, war doch gut, dass ich meinen Zauberer kkaum besoffen ueben gelassen hab,
da ging nie soviel hintereinander schief :)

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



Kneipe (Silvana, 23. Feb 1998, 11:51:10):
Hi.
Im Zauberberg gibt es jetzt auch das eine oder andere zu Essen. Die
Ideen und Texte (einschliesslich Typos :) ) stammen von Therin und wurden
unter Wahrung des Copyrights unveraendert uebernommen. :)

  Silvana

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



Re: Kneipe (Therin, 23. Feb 1998, 18:28:43):
~#! rn=Silvana rt=888231070 rg=gilden.zauberer
~#! tid=888231070

Ideen und Texte (einschliesslich Typos :) ) stammen von Therin und wurden

Also, Du haettest mich wenigstens nochmal auf Kommasetzung pruefen lassen
koennen...

Ansonsten setze ich ein "OGAO" darunter, ein Ohne Gewaehr auf Ottograf Vieh...

Therin

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



Re: Re: Ueben (Trekan,  3. Mar 1998, 10:28:57):
~#! rn=Patryn rt=887793941 rg=gilden.zauberer
~#! tid=887750136
uebtode .. jaaa.. das kenne ich :)
Trekan -> frueher immer an komischen eissplittern verre**t

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



Mithilfe gesucht! (Ringor,  5. Mar 1998, 21:53:10):
Hallo meine lieben Zaubererfreunde! (aua, nicht schlagen ;-)

Es mag etwas eigenartig klingen, dass sich ein ueberzeugter Kaempfer an euch
wendet, aber es betrifft zumindest zum Teil auch euch.

Und zwar habe ich - wie vielleicht einige schon wissen - fuer TF einen
Kampfscrollreduzierer geschrieben. Der beachtet auch mittlerweile alle Gilden.
Bis auf die Zauberer, was vor allem an den eigenen Treffermeldungen liegt.

Und da ich das Paket (wer hat hier Skript gesagt? :) gerne erst
vervollstaendigen moechte, bevor ich es veroeffentliche, suche ich jetzt eben
diese Treffermeldungen.

Im Einzelnen geht es um "feuerball" und "verletze" mit allen Schadenarten. Und
zwar braeuchte ich die Meldungen, die a) der Zauberer sieht, b) sein Opfer und
c) die Leute, die unbeteiligt drumrum stehen.

Fuer Blitz saehe das z.B. so aus:

<Opfer> zuckt unter Deinem Blitz zusammen. (a)
Du zuckst unter <Zauberer>s Blitz zusammen. (b)
<Opfer> zuckt unter <Zauberer>s Blitz zusammen. (c)

Nein, ich erwarte nicht, dass mir jetzt jemand ne komplette Aufstellung
schickt. Naja, ablehnen wuerd ich sie auch nicht. ;-) Aber ich nehme auch jede
Art von Logfile an.

Also wenn ihr das naechste Mal metzeln geht, dann denkt bitte an mich und
lasst einfach ein Logfile mitlaufen. Die entsprechenden Meldungen such ich mir
schon selbst raus.

Achja, die Logfiles bitte per Mail an mich. Und falls sich jemand die Arbeit
machen sollte, die Meldungen selbst rauszuschneiden: ich braeuchte sie schon
buchstabengetreu und nicht aus dem Gedaechtnis zitiert bitte. ;-)

Ausser meinem Dank und evtl. einer Vorabversion kann ich euch leider nichts
weiter bieten. Ich bin also sozusagen ganz auf eure Hilfsbereitschaft
angewiesen. Enttaeuscht mich nicht :-)

Ringor

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



www (Birdy,  6. Mar 1998, 15:39:38):
Fuer alle, die Schwierigkeiten hatten, sich die Bilder auf den Zweigseiten
anzugucken: ich habe das Problem kurzerhand aus der Welt geschafft, nachdem
ich nach 2-woechigem Suchen nicht auf die Ursachen gestossen bin.

Birdy

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



rueste (Silvana, 15. Mar 1998, 18:31:26):
Der Bug in der Materialerkennung bei Rueste sollte behoben sein.

  Silvana (kurz und knapp)

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



Re: rueste (Therin, 15. Mar 1998, 18:32:28):
~#! rn=Silvana rt=889983086 rg=gilden.zauberer
~#! tid=889983086

Wenn ich jetzt wuesste, was das fuer ein Bug war? :)

T., auch einzeilig

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



Re: Re: rueste (Silvana, 15. Mar 1998, 18:52:34):
~#! rn=Therin rt=889983148 rg=gilden.zauberer
~#! tid=889983086
Dummerweise wurde alle Ruestungen als 100% Metall erkannt, was den Rueste-
Spruch nicht so gut bekam. Leider sind durch diese Aenderung eine Reihe
von Ruestungen aufgefallen, bei denen das Material syntaktisch falsch
gesetzt worden ist. Besonders davon betroffen davon ist Xian. Ich habe
schon ein paar Ruestungen debugt, aber es gibt natuerlich noch alte und
zudem habe ich vermutlich noch laengst nicht alle gefunden...

  Silvana

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



Aus gegebenem Anlass (Silvana, 16. Mar 1998, 13:49:53):
Hi.
Aus gegebenem traurigen Anlass muss ich wohl mal wieder auf ein paar
bisher ungeschriebene, aber trotzdem eigentlich hinreichend bekannte
Regeln der Gilde hinweisen:
1: Magierzweities haben in den Magisterraengen nichts zu suchen. Ausnahme:
   Wenn hinreichend Plaetze vorhanden sind, so dass noch ein weiterer
   Spieler den Zweig waehlen kann. Ist ein Zweig voll, wird von einem
   Magierzweitie erwartet, dass es unverzueglich von seinem Posten 
   zuruecktritt.
2: Es ist absolut nicht erwuenscht, dass sich ein RL-Spielern mit der
   halben Familie in den Raengen breit macht. EINEN Posten pro RL-Person,
   mehr nicht! Wer dagegen verstoesst, fliegt mit ALLEN Charakteren aus
   den Raengen - und zwar ohne weitere Vorwarnung.

Da es offenbar zuviel verlangt ist, einigen Leuten soviel gesunden 
Menschen-(Elfen...)-Verstand zuzutrauen, dass sie von selbst auf derart
uneigennuetzige Gedanken kommen, bitte ich hiermit Li, dies in die FAQ
aufzunehmen, sowie Birdy, die WWW-Seiten entsprechend zu ergaenzen.

  Silvana

PS: Nebenbei: dadurch sind 3 Magisterposten frei...

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



Re: Aus gegebenem Anlass (Key, 16. Mar 1998, 15:54:06):
~#! rn=Silvana rt=890052593 rg=gilden.zauberer
~#! tid=890052593
Hmm Silvana .... dann schmeiss auch bitte die raus die ewig nicht mehr da
waren aber auch noch posten besetzt halten.

Key, nur mal so am Rande

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



Re: Aus gegebenem Anlass (Aurian, 17. Mar 1998, 17:14:04):
~#! rn=Silvana rt=890052593 rg=gilden.zauberer
~#! tid=890052593
naja, einer der magister mit 2 leuten bin wohl ich. 
aber da zB hellsicht immer noch so uninteressant ist, das in diesem zweig noch
nie alle magisterposten besetzt waren sehe ich irgendwie nicht ein, 
warum da nicht auch zweit-magister friedlich ueben duerfen....

aurian

ps: wenn es die moeglichkeit gaebe wuerde ich meinen zweitmagister auch 
jedes mal vor dem schlafe ein aus dem magisterzweig abmelden ....
(nur wuerde ich schon gerne oefters als all 14 wieder in einen freien zweig
eintreten)

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



Abschied (Silvana, 20. Mar 1998, 19:39:06):
Hi.

Aufgrund privater Probleme sowie akutem Zeitmangel werde ich mir
jetzt eine Woche Urlaub vom Mud nehmen, um ein paar Dinge 
abzuschliessen, die ich noch fuer die Zauberer fertig machen
wollte. Anschliessend werde ich meine Arbeit an der Zauberergilde
endgueltig beende. Mit anderen Worten: die Gilde braucht einen
Magier, der sich drum kuemmert. Ich wuerde ja Patryn vorschlagen, 
aber ich bin natuerlich fuer Vorschlaege offen. Mailts mir halt
einfach oder besser: Sammelt und einigt Euch untereinander.

  Silvana (nimmt Abschied)

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



SILVANA VERLASS UNS NICHT ! (Birdy, 23. Mar 1998, 14:25:44):

Da bisher noch niemand protestiert hat, dass uns unsere Chefin verlaesst, tue
ich das jetzt, und zwar NACHDRUECKLICHST.
BITTE GEH NICHT !!!
Kannst Du Aufgaben nicht an andere Magier unserer Gilde verteilen, damit Du
nicht mehr so eingespannt bist ?
Es gibt bestimmt Mittel und Wege, Dich zu entlasten. :)

Hiermit richte ich einen Aufruf an alle Zauberer :
STIMMT UNSERE CHEFIN UM !

Auf jeden Fall reden wir auf der Party nochmal darueber !:)
Nichts wird so heiss gegessen, wie es gekocht wird. ;)

Gruss
Birdy

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



Re: SILVANA VERLASS UNS NICHT ! (Niete, 23. Mar 1998, 14:38:45):
~#! rn=Birdy rt=890659544 rg=gilden.zauberer
~#! tid=890659544
jau, ich faende es auch sehr schade, wenn silvana ihr amt als unsere chefin
niederlegt...vielleicht gibt es doch noch einen anderen weg?
auch niete sagt: bitte geh nicht

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



Re: Re: SILVANA VERLASS UNS NICHT ! (Anatol, 23. Mar 1998, 18:50:22):
~#! rn=Niete rt=890660325 rg=gilden.zauberer
~#! tid=890659544
Richtig toll wird es keiner finden, wenn Silvana den Gildenmagierzauberstab
abgibt. Aber ich habe das Gefuehl, dass sie a) weiss, was sie tut und b)
eben jenes nicht tun wuerde, wenn es eine angemessene bessere Loesung 
- fuer was auch immer - geben wuerde. Und falls sie dabei tatsaechlich
Hilfe brauchen sollte... sie hat ihre "Soul'n'Body"guards (==Freunde) und
muss nicht von uns bemuttert werden, oder?

Anatol


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



Magister (Anacrion, 24. Mar 1998, 01:44:25):

Hallo :)

Ich bin soeben von meinem Posten als Beherrschungsmagister zurueckgetreten, um
den Platz freizumachen fuer Leute, die etwas mehr mudden als ich (im Moment
und in diesem MUD).

Anac*


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



Re: SILVANA VERLASS UNS NICHT ! (Shorkan, 24. Mar 1998, 08:13:53):
~#! rn=Birdy rt=890659544 rg=gilden.zauberer
~#! tid=890659544
Ich schliesse mich an. BITTE Silvana verlass uns nicht. Irgend eine
Moeglichkeit
wird es schon geben.
Wen, wenn nicht Dich sollten wir mit Hi Chefin begruessen ?!

Lord of Illusion Shorkan, leicht desillusioniert.

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



Re: Re: SILVANA VERLASS UNS NICHT ! (Key, 24. Mar 1998, 10:07:57):
~#! rn=Shorkan rt=890723633 rg=gilden.zauberer
~#! tid=890659544
Na Patryn natuerlich ....
Sorg einfach bei ihm fuer ne Geschlechtsumwandlung und fertig ,)

Aber nochmal was anderes .... wenn silvana sagt das sie keine Zeit haette dann
akzeptiert das doch einfach mal!
Ihr nervt hier rum wie kleine Kinner.
Klar, es ist schade wenn sie geht, aber es gibt ein RL ... falls einige hier
das schon vergessen haben ... und das fordert ab und an auch seinen Preis.

Oder wollt ihr lieber das sie die Gilde behaelt aber nix mehr dran machen kann
weil sie keine Zeit hat? Ich hoer schon das gejaule wenn das passieren wuerde
..

Key

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



Kleine Frage (Lug, 25. Mar 1998, 00:56:46):

Aehem,

waere es moeglich, das der Guertel oder was Zauberer so haben (keine Ahnung)
das Wegstecken von edelsteinen automatisch gagt? Oder sonstwie unterdrueckt?
Wuerde ne Menge Scroll beenden ;)

Nur so als Nichtzauberer
Lug

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



Re: Kleine Frage (Therin, 25. Mar 1998, 01:39:08):
~#! rn=Lug rt=890783806 rg=gilden.zauberer
~#! tid=890783806

Wieso hab ich das Gefuehl, das das sich auf mich bezieht :)

T.

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



Re: Re: Kleine Frage (Lug, 25. Mar 1998, 01:41:23):
~#! rn=Therin rt=890786348 rg=gilden.zauberer
~#! tid=890783806

Hm,

Paranoia Therin?

FidKG
Lug

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



Re^3: SILVANA VERLASS UNS NICHT ! (Acrimon, 25. Mar 1998, 20:15:50):
~#! rn=Key rt=890730477 rg=gilden.zauberer
~#! tid=890659544
Wie waere es mit der Einfuehrung von Ehrentiteln?

Damit meine ich Titel fuer Magier, die etwas getan haben in diesem Mud, ihre
Aufgabe aber abgegeben haben.
Also:
Silvana die Chefin der Zauberer.
Zardoz der Feldherr der Trves.
Zardoz der Oberchaot.
Schrumpfi die Grufthexe.
Oetti der Platti.
Wargon der Goetterbote.
Wargon der Bausparbankier.

usw. usf., es gibt da bestimmt noch mehr Magier-Legenden.

Dann bleibt Euch die Chefin Silvana, und Silvana kann ihre Zeit trotzdem
anderen Dingen widmen!

Acrimon, der Rote Ritter

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



Re^4: SILVANA VERLASS UNS NICHT ! (Ark, 26. Mar 1998, 08:58:01):
~#! rn=Acrimon rt=890853350 rg=gilden.zauberer
~#! tid=890659544
Gute Idee :-) Bin dafuer ...


              *** ARK * the * Magnificent ***


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



Re^5: SILVANA VERLASS UNS NICHT ! (Birdy, 26. Mar 1998, 14:29:03):
~#! rn=Ark rt=890899081 rg=gilden.zauberer
~#! tid=890659544
Jepp !:)
SUPERIDEE !!

Birdy

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



Re^6: SILVANA VERLASS UNS NICHT ! (Srabi, 26. Mar 1998, 15:55:56):
~#! rn=Birdy rt=890918943 rg=gilden.zauberer
~#! tid=890659544
Das finde ich auch, ich bin zwar kein Zauberer, habe ich auch keinen
Zaubererzweitie (was nicht ist, kann aber noch werden), aber trotzdem finde
ich, da Silvana bleiben sollte. Sie hat wohl mit viel Mhe und groem
Zeitaufwand die Gilde programmiert und darf deswegen nicht gehen. Ich
schliesse mich auch als Chaot an : SILVANA, BITTE BLEIBE !!!

Srabi, der hoffende Chaot

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



Re^7: SILVANA VERLASS UNS NICHT ! (Sting, 26. Mar 1998, 19:09:31):
~#! rn=Srabi rt=890924156 rg=gilden.zauberer
~#! tid=890659544
Jetzt reichts mir aber, ich schreibe auf solche bloeden flames normalerweise
nicht gerne, aber das muss sein:

Glaubt ihr echt, das Silvana, wenn sie moechte und koennte noch an der Gilde
dranbleiben wuerde ??
Hoert endlich auf mit diesem "Bitte, Bitte"-Geflame, das bringt doch nix. Wenn
ihr unbedingt Silvana ueberreeden wollt dann macht das mit teile mit oder
mails, aber belastet die ohnehin schon schlechte MPA nicht auch noch mit
sowas!


Sting

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



Re^8: SILVANA VERLASS UNS NICHT ! (Wurzel, 26. Mar 1998, 21:09:37):
~#! rn=Sting rt=890935771 rg=gilden.zauberer
~#! tid=890659544
reg dich nicht auf, sting. kinder brauchen nun mal ihre idole.
warum erinnert mich das nur so vertrackt an die back street boys (wahlweise
auch spice girls) und den rummel drumherum?
nicht dass ich jetzt behaupten wollte, silvana sei ein spice girl :)

wurzel

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



Re^9: SILVANA VERLASS UNS NICHT ! (Gloinson, 27. Mar 1998, 09:45:30):
~#! rn=Wurzel rt=890942977 rg=gilden.zauberer
~#! tid=890659544
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIEEEEEEEEEEEEEEEEEEEEEEEEEEEEEHHHHHHHH!!!
*kreisch*
*sabber*
*Mit dem Nibelungen-Teddy nach Silvana werf*
SILVANA ICH LIIIIEEEEBBBEEE DICH !!! VERLASS UNS NICHT !!!
*heul* *trief*

Gloin ... der musste itzt sein ;-)

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



Re^8: SILVANA VERLASS UNS NICHT ! (Grimmborn, 27. Mar 1998, 15:49:48):
~#! rn=Sting rt=890935771 rg=gilden.zauberer
~#! tid=890659544
Ich weiss nicht was Du hast, dieses Gejammer passt doch gut zur Tatsache, dass
Zauberer Weicheier sind, die sich hinter der staerksten Gilde verstecken damit
ihnen auch nur ja nix passiert... ;-)

Grimmborn der Atheist

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



Re^9: SILVANA VERLASS UNS NICHT ! (Birdy, 27. Mar 1998, 16:45:48):
~#! rn=Grimmborn rt=891010188 rg=gilden.zauberer
~#! tid=890659544
Wem der Thread nicht passt, soll ihn ignorieren und hier nicht auf uns armen
Zauberern rumhacken. :)
Wer sich nciht mit seiner Gilde identifizieren kann und damit auch nicht mit
m/der zustaendigen Magier/in kann das vielleicht nicht verstehen, aber mit
Silvanas Austieg bei uns geht eine glorreiche Aera zu Ende. *schnief*
Silvana, Du wirst immer unsere Chefin bleiben ! :)

Ein trauriger Birdy

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



Re^10: SILVANA VERLASS UNS NICHT ! (Silvana, 28. Mar 1998, 12:22:04):
~#! rn=Birdy rt=891013548 rg=gilden.zauberer
~#! tid=890659544
Meine Guete, was fuer eine Reaktion... 

Aaaaalso: Anatol hat schon voellig recht, ich weiss, was ich tue. :) Es 
gibt letztendlich zwei Moeglichkeiten:
1) Ich bleibe, tu aber nix mehr fuer die Gilde - zumindest dieses Jahr.
2) Jemand anderes mit viel Lust und Zeit uebernimmt die Gilde.

Ich denke, im Sinne der Gilde waere die zweite Loesung besser, nur muss
jemand gefunden werden, der es tut. Also, wer reisst sich drum?

Nunja, bis sich jemand findet, werde ich noch bleiben und ein wenig
aufraeumen, die Dateien aus meinen Verzeichnissen auslagern usw. Es 
kann dabei zu ein paar Stoerungen kommen, aber ihr werdet es schon
verkraften. :)

  Silvana - raeumt auf.

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



Re^11: SILVANA VERLASS UNS NICHT ! (Key, 30. Mar 1998, 08:06:58):
~#! rn=Silvana rt=891084124 rg=gilden.zauberer
~#! tid=890659544
Hmm ich bestimme mal kurzerhand Patryn fuer den Posten ,)
*setz Patryn hin ohne ihn zu fragen (Der hat eh nix zu melden =;)) *

Key grinst zensiert

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



Patryn ist jetzt ein Gildenoberhaupt (Silvana, 30. Mar 1998, 15:49:40):
Hi.

Nach kurzer Absprache auf der Party uebergebe ich hiermit die
Verantwortung fuer die Zauberergilde an Patryn. Es wird einige
Zeit dauern, bis die Umbaumassnahmen abgeschlossen sind, aber 
danach obliegt ihm die einzige Verantwortung.
Fuer Fragen und Tips stehe ich ihm aber weiterhin zur Verfuegung.

Viel Glueck und kreative Ideen - wuenscht Silvana

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



Re: Patryn ist jetzt ein Gildenoberhaupt (Patryn, 30. Mar 1998, 16:06:44):
~#! rn=Silvana rt=891265780 rg=gilden.zauberer
~#! tid=891265780
nun ist es also geschehen und trotz eurer aller treuebekundungen uebergibt
silvana mir die gilde. was wird sich nun eigentlich genau aendern?
 also eigentlich nicht so viel, ausser dass ich meine vielen vielen
 vorschlaege an silvana nun selbst umsetzen muss :)
silvana bleibt nachwievor geistiges oberhaupt und ich werde ihr das letzte
wort bei merklichen aenderungsvorhaben ueberlassen. es bleibt nach aussen hin
somit eigentlich alles beim alten, ausser dass nun alle vorschlage und
anfragen zur gilde an mich gehen um silvana auch wirklich zu entlasten.
es gibt also ueberhaupt keinen grund zur panik :)
ich hoffe mal, das viele gute ideen, die bisher aus zeitgruenden auf eis
lagen, zur umsetzung kommen. deshalb bitte ich euch, mal eure vorschlaege
und kritiken zu sammeln und mir noch mal gebuendelt zukommen zu lassen.
desweiteren waere es nicht schlecht, wenn sich mal ein paar leute um die
texte in der bibliothek kuemmern koennten, es sind einige komponenten
noch nicht kommentiert und auch die zauberstab-doku fehlt dort voellig.
sowas koennen eingentlich die spieler machen, denk ich mal.
also dann auf gute zusammenarbeit

------
patryn

PS: abgewertet wird ab nun freiwillig nix mehr :)

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



Re: Re: Patryn ist jetzt ein Gildenoberhaupt (Lug, 30. Mar 1998, 23:41:30):
~#! rn=Patryn rt=891266804 rg=gilden.zauberer
~#! tid=891265780

Hihi,

Patryn sagt: Kein Grund zur Panik ;)

Jetzt bricht wohl eine Massenhysterie aus.

FidKG
Lug

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



Kann es schlimmer kommen? (Vidraj, 31. Mar 1998, 20:33:14):
Mein Kommentar dazu.....Zauberer sind bald wie Flaschen leer!

Ich denke das reicht auch schon.

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



Re: Kann es schlimmer kommen? (Grimmborn, 31. Mar 1998, 23:21:19):
~#! rn=Vidraj rt=891369194 rg=gilden.zauberer
~#! tid=891369194
Was errlaube diesse S-pieler?
Ich habbe fertig!

GdA

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



Abschiedsgeschenk (Silvana,  1. Apr 1998, 00:00:57):
Hi.

Zum Abschied gibt es nun doch noch ein kleines Geschenk: einen
siebten Zweig - der Zweig der Phantasie. Er enthaelt kleine
harmlose Zauber, die vielleicht ganz nuetzlich sein koennen.
Letztendlich also so ein nettes kleines Allerlei. Hier zunaechst
mal die Features:

belausche     20/15      Phantasie  1   Hoerrohr      Raum belauschen
anfangen      30/20      Phantasie  1   Zielscheibe   abfangen Waffen
folge         40/30      Phantasie  3   Angel         verfolgen NPC
reserviere    50/40      Phantasie  2   Handtuch      reservieren NPC
fp-zu-mir     70/20      Phantasie  0   Wuenschelrute Liste FP
reset         80/65      Phantasie  0   Radiergummi   reset des Raumes
antisnoop    120/80      Phantasie  2   Bleimantel    verhindert Snoop
reboot         234       Phantasie  3   Lebensver-    reboot des MG
                                        sicherung

Der <belausche> Spruch ist der erste Phantasiezauber. Damit kannst
die Gespraeche in einem Nebenraum belauschen.=20
Materialkomponente: Hoerrohr
freie Haende:       1
Verbotene Ruestung: Bleimantel
Kosten: 20 / 15

Der <abfangen> Spruch ist der zweite Phantasiezauber. Damit kannst
die Pfeile und sonstige geworfenen Waffen abfangen (z.B die Pfeile
von Robin).=20
Materialkomponente: Zielscheibe
freie Haende:       1
Verbotene Ruestung: Schild
Kosten: 30 / 20

Der <folge> Spruch ist der dritte Phantasiezauber. Du kannst einem=20
beliebigen Monster folgen. So duerften Etwas und Phlyaken auch fuer
Nicht-Profis besser zu haendeln sein.
Materialkomponente: Angel
freie Haende:       3
Verbotene Ruestung: Schild
Kosten: 40 / 30

Der <reserviere> Spruch ist der vierte Phantasiezauber. Du kannst
Dir ein noch nicht resettetes Monster in einem Raum bis zu maximal
15 Minuten nach dem Resett reservieren, wenn das Monster noch nicht
reserviert oder angegriffen wurde.
Materialkomponente: Badehandtuch
freie Haende:       2
Verbotene Ruestung: Ruestung, Panzer
Kosten: 50 / 40

Der <fp-zu-mir> Spruch ist der f=FCnfte Phantasiezauber. Sucht den
naechsten Raum, in dem sich ein FP befindet, den Du noch nicht
gefunden hast. Als Option kannst Du au=DFerdem zwei Listen abrufen:
-gesamt Liste aller von Dir gefundenen FP
-alt    Liste aller zu findenen FP, die sich in den Quests befinden,
        die Du bereits vor November 1995 gemacht hast.
Materialkomponente: Wuenschelrute
freie Haende:       0
Verbotene Ruestung: Schild
Kosten: 70 / 20

Der <reset> Spruch ist der erste Magisterzauber der Phantasie. Du
kannst den Raum, in dem Du Dich befindest, resetten, solange sich
dort und in den jeweils angrenzenden Nachbarraeumen kein anderer
Spieler befindet.
Materialkomponente: Radiergummi
freie Haende:       0
Verbotene Ruestung: Schild
Kosten: 80 / 65

Der <antisnoop> Spruch ist der zeite Magisterzauber der Phantasie.
Du bist fuer 15 Minuten von jeglichem ueblen Nachstellen befreit.
Deine Eingaben werden auch nicht mehr mitgeloggt. Wenn ein Magier
waehrend dieser Zeit versuchen sollte Dich zu snoopen bekommst Du
eine Meldung. Der betreffende Magier wird daraufhin ausgeloggt.
Wirkt auch dem Belausche-Spruch entgegen.
Materialkomponente: Bleimantel
freie Haende:       2
Verbotene Ruestung: Handschuhe
Kosten:120 / 80

Der <reboot> Spruch ist der Erzmagisterzauber der Phantasie. Du
kannst das ganze MG rebooten, wenn alle anwesenden Spieler, aus-
genommen Zweitis und Magier (bei eingeloggten Zweitis hat auch
der Erstie keine Stimme), innnerhalb einer Minute eintippen:
'reboot sofort'
Materialkomponente: Lebensversicherung
freie Haende:       3
Verbotene Ruestung: Kopfschutz
Kosten: 234

Nun, wo kann man das ganze lernen? Tja, das duerft ihr selbst
herausfinden. :) Viel Spass beim ueben...


    Silvana - verabschiedet sich damit.

PS: Die Ideen dazu stammen uebrigens von Skipper.

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



Re: Abschiedsgeschenk (Ark,  1. Apr 1998, 08:53:17):
~#! rn=Silvana rt=891381657 rg=gilden.zauberer
~#! tid=891381657
Mist, scheinbar wurde der Vorschlag fuer 'fessel' nicht beruecksichtigt:
Knebel einen Magier Deiner Wahl :-)


              *** ARK * the * Magnificent ***


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



Re: Re: Abschiedsgeschenk (Freund,  1. Apr 1998, 08:55:49):
~#! rn=Ark rt=891413597 rg=gilden.zauberer
~#! tid=891381657
Und "verdopple". 
Ein Objekt in Deinem Inventory oder Raum wird noch einmal gecloned. Waere echt
gut bei Monstern gekommen. :-)

Freund, hat lange mit Silvana darueber diskutiert.

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



Re^4: SILVANA VERLASS UNS NICHT ! (Trancefear,  1. Apr 1998, 20:22:11):
~#! rn=Acrimon rt=890853350 rg=gilden.zauberer
~#! tid=890659544
Acrimon der mit den Umlauten tanzt

tf

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



einstand :) (Patryn,  2. Apr 1998, 13:26:56):
fuer alle die es noch nicht gemerkt haben:
 die zauber 'stimme', 'illusion' und 'identifiziere' wurden leicht
 veraendert. naehere infos in der bibo...wie ueblich

------
patryn

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



Re: einstand :) (Swift,  3. Apr 1998, 23:25:59):
~#! rn=Patryn rt=891516416 rg=gilden.zauberer
~#! tid=891516416
cool. netter einstand :)

swift (im namen seines magisters darken)

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



Re: einstand :) (Swift,  3. Apr 1998, 23:43:48):
~#! rn=Patryn rt=891516416 rg=gilden.zauberer
~#! tid=891516416
ich habe die 3 aenderungen gleich mal auf meiner zauberer-seite eingetragen.

wer direkt hinwill: http://www.theoffice.net/walz/zauberer.html

swift aka darken

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



Meldungstexte (Therin,  5. Apr 1998, 19:03:03):
Tach auch....

Ihr habt sicher bemerkt, dass die Zauber zusaetzliche Textzeilen bekommen
haben und teilweise auch ein Raum-echo, wo vorher keines war.

Bislang waren aber allen Leuten, mit denen ich darueber gesprochen habe die
Meldungen entweder zu lang und/oder aber unschoen formuliert.

Daher moechte ich gerne zusammen mit euch andere Formulierungen erarbeiten,
respektive meine eigenen Vorschlaege erweitern/veraendern.
1. Konzentrationsphase

Me: Du konzentrierst Dich auf den Spruch 'X'.
Raum: Ich wuerde voellig auf eine Meldung verzichten.
Erlaeuterung: Man selber bekommt angezeigt, das der Spruch "beginnt". Die
bisherige Meldung ist durchaus stimmungsvoller, geb ich zu, aber genauso
meiner Meinung nach zu lang.

2. Identifiziere
Me: Du schaust X pruefend an.
echo: Y schaut X pruefend an.
Objekt: Y schaut Dich pruefend an.
Alternativ auch "hoch konzentriert" statt "pruefend"
zumindest sollte aber der zweite Halbsatz aus dem Raumecho genommen werden.

3. ID Material
Me: Du klopfst pruefend auf X Oberflaeche herum.
echo: Y klopft pruefend auf X Oberflaeche herum.
Objekt: ruhig so wie bisher.
Erlaeuterung: Die Meldung wird hauptsaechlich kuerzer.

4. sonstiges
- Allgemein die Frage, ob bei Illusion ein weiteres Raumecho kommen muss
- Die Konzentrationsphase bei finde und Anpassung und bei einigen
Magistersprueche finde ich durchaus korrekt, jedoch
- Die Konzentrationsphase bei Extrahand, welcher nunmal ein hauptsaechlich im
Kampf verwendeter Spruch ist, liegt mir nicht. Auch, wenn xHand vielleicht
laenger haelt, haette ich statt dessen lieber einen sofort wirkenden Spruch.

So, dies sind meine, etwas ins unreine gedachten Vorschlaege.
Vielleicht fallen ja einem von euch elegantere Texte ein (die dabei einzeilig
bleiben sollten :) ).

Therin
2.

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



Re: Meldungstexte (Patryn,  6. Apr 1998, 12:30:29):
~#! rn=Therin rt=891795783 rg=gilden.zauberer
~#! tid=891795783
also sind alle konzentrationspausen O.K. die DICH nicht stoeren und alle
anderen sind unlogisch und ueberfluessig? das kommt bei dir hier zwar nicht
so rueber, aber erweckten alle persoenlichen anfragen bisher den 
geschilderten anschein...sehr seltsame logik.
desweiteren bin ich durchaus bereit, bestimmte formulierungen stimmiger
oder atmosphaerischer zu gestalten, deine vorschlaege laufen jedoch
nur darauf hinaus, die infos moeglichst auf 3 worte zusammenzustreichen,
auch nicht grad so toll. viele andere spells erzeugen auch locker 2 zeilen.
raummeldungen bei illusion kommen nur, wenn man sich zu doof dabei anstellt,
kleiner ansporn, auch solche spells mal auf 100% zu lernen.
alle fragen beantwortet? hoffe mal ja :)
im uebrigen hab ich ausser moserei und auch etwas lobhudelei immer noch
keine _verwertbaren_ vorschlaege erhalten. muss ich halt meine eigenen
ideen weiter verwirklichen... ;)

------
patryn

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



Re: Re: Meldungstexte (Therin,  6. Apr 1998, 18:48:26):
~#! rn=Patryn rt=891858629 rg=gilden.zauberer
~#! tid=891795783

Das letzte was ich will ist einfach nur rummosern, daher habe ich mich
bemueht, konstruktive Kritik zu aeussern und nicht einfach ein "was Du machst
ist Mist" zu sagen.
(was so gar nicht mal stimmt (extra fuer die Abteilung Lobhudelei :) )

Nein, die grundsaetzliche Notwendigkeit einer Meldung streite ich ja nicht ab,
da (fast?) alle Gilden eine Meldung beim ID erzeugen, nur sollte nicht ganz so
- und hier verzeih bitte das Wort - laecherlich sein.
Ich moechte ja in irgendeiner Form zu einer Verbesserung beitragen, und habe
ja auch meine "Kollegen" zu einer Meinungaabgabe aufgefordert, aber wenn sich
keiner dafuer interessiert und nur in der gegend herummosert (wie Du so schoen
formuliert hast) und keine Artikel schreibt, kann ich ja auch nix tun.

Vorschlag zur Guete: Wenn wir mal gleichzeitig eingeloggt sind, das Thema zu
diskutieren. Entweder geschlossen auf tm/zruf oder offen auf -z.

Noch mal abschliessend: Ich habe keine Probleme mit Konzentrationsphasen vor
non-kampf-Spells, da zumindest ich (wenn vielleicht auch wenig andere) eine
weitere Veraenderung bemerkt habe.

(Und sollte meine andere Nachricht "genoelt" geklungen haben, so moechte ich
mich nochmals dafuer entschuldigen, es war keine Absicht)

T.

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



Re: Meldungstexte (Key,  7. Apr 1998, 17:27:48):
~#! rn=Therin rt=891795783 rg=gilden.zauberer
~#! tid=891795783
Hmm also xhand finde ih so oki wie es jetzt ist ...
Was mich mehr stoehrt ist das beim finden ...

Phly wartet auch keine ewigkeit ... wehrt den spruch ab und zusaetzlich noch
ne wartepause ..
Nur als kleines Beispiel :)

Key

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



Re: Re: Meldungstexte (Key,  7. Apr 1998, 17:29:09):
~#! rn=Patryn rt=891858629 rg=gilden.zauberer
~#! tid=891795783
Deine ... IDEEN? :)
Leute lasst euch schnellstens was einfallen!!! =;)

Key schmarrnend

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



aenderungen (Patryn,  7. Apr 1998, 19:47:58):
folgende spells sollte man noch mal in der bibo nachschlagen:
 zwingtanz, erzwinge, magieaura, wahrsagen
desweiteren werden jetzt unterbrochende auren, bann-spells, brennende haende
u.s.w. korrekt behandelt, das heisst, deren angebliches spaeteres ende nicht
mehr angezeigt.

------
patryn

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



Vorwarnung (Silvana, 11. Apr 1998, 11:22:27):
Ich werde heute im Laufe des Tages die Zauberergilde so umbauen, dass
Patryn uneingeschraenkten Zugriff auf alle Files hat. Dabei kann es 
zu Stoerungen kommen. Ich bitte um etwas Geduld.

  Silvana

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



Re: Vorwarnung (Asmodis, 11. Apr 1998, 14:16:02):
~#! rn=Silvana rt=892286547 rg=gilden.zauberer
~#! tid=892286547
Wieviele Crashs gibts denn heute ? :)

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



Re: Re: Vorwarnung (Silvana, 11. Apr 1998, 14:16:47):
~#! rn=Asmodis rt=892296962 rg=gilden.zauberer
~#! tid=892286547
Ich hoffe, wir kommen mit nem Dutzend hin... :)

  Silvana

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



Zauberstab (Silvana, 11. Apr 1998, 15:57:38):
Sorry.
Ich musste leider durch den Umzug bedingt alle Zauberstaebe einziehen.
Solltet ihr noch einen alten haben, entsorgt den bitte so bald wie
moeglich. Llystrathe teilt die neue Version aus.

  Silvana

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



Probleme mit Gildenkneipe (Dhojakt, 11. Apr 1998, 16:16:23):
Im Moment funktionieren leider nicht alle Getraenke der Zaubererkneipe.
Das kann aber erst Paracelsus beheben (der muss die Kneipe wieder als
Gildenkneipe eintragen).
Dhojakt.

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



Umzug (Silvana, 11. Apr 1998, 18:27:09):
So, der Umzug ist fast vollstaendig. Zwei Dinge fehlen noch:
1) Phlyaken zieht ins Gebirge um muss also erst in der EK-STP-Liste
   verschoben werden.
2) Die Magisterpruefung ist noch nicht vollstaendig umgezogen und
   daher derzeit deaktiviert.

Bitte noch etwas Geduld.

   Silvana

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



Re: aenderungen (Kuschelmaus, 13. Apr 1998, 00:11:40):
~#! rn=Patryn rt=891971278 rg=gilden.zauberer
~#! tid=891971278
Falls es nicht eingebaut ist: Wenn jemand zu applaudiere gezwungen wird,
sollte er zumindest auch seine Waffe wegstecken.

Nur mal so als Vorschlag.

Teddy

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



Re: Re: aenderungen (Grimmborn, 13. Apr 1998, 00:27:34):
~#! rn=Kuschelmaus rt=892419100 rg=gilden.zauberer
~#! tid=891971278
Das Waffenrasseln ist auch Applaus? Oder steht da was von "klatschen"?

Grimmborn der Atheist

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



Wieder einer, der nur meckert. (Obermotz, 15. Apr 1998, 15:20:02):
Nach lange Zeit, habe ich mich mal wieder entschlossen , mich in den
Uebungsraum der Gilde zu begeben. Das es eine Zeitbeschrenkung fuer das
Lernvolumen gibt war mir klar. Ich wusste aber nicht, dass die Begrenzung
generell ist und nicht an den Spruch gebunden (wie ich es erst dachte). Soweit
ich mich erinnern kann, wurde die Begrenzung eingefuerht, um zu verhindern,
dass man Stunden lang an einem Spruch uebt (kann mich aber auch irren) und es
somit Uebungsskripter schwerer gemacht werden sollten. Allerdings fuehrt mich
die Begrenzung eher dazu, mir endlich ein Client zu besorgen (bis jetzt hat
mir ein pures Telnet ausgereicht) und ein Skript zu schreiben, dass alle 30s
oder so einen Spruch loslaesst. Also eigentlich das entgegengesetzte Ziel, was
erreicht werden sollte. Okay, ich gehe ueber die Uni rein. Andere, die ein
Modem benutzen helfen auch, den Umsatz der telekom zu steigern.

Ach noch eins: kann die Vorbereitungszeit nicht wegfallen, wenn man eh den
Spruch nicht machen kann (weil die Komponente fehlt)?

OM, heute unzufrieden

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



Re: Wieder einer, der nur meckert. (Patryn, 15. Apr 1998, 15:23:55):
~#! rn=Obermotz rt=892646402 rg=gilden.zauberer
~#! tid=892646402
also die uebersperre existierte in der jetzigen form schon immer, nur dass
du es jetzt halt siehst. da du sie zuvor nie registriert hast, sollte
dieses problem somit behoben sein ;)
ich moechte waehrend der vorbereitungszeit nix abchecken, sonst koennte man
ja auch gleich schaun, ob genug haende frei sind, der angesprochene gegner
auch da ist, die komps da sind u.s.w.,
aber diese dinge koennen sich waehrend der vorbereitung ja aendern. deshalb
frage ich das da auch nich ab.

------
patryn

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



Re: Re: Wieder einer, der nur meckert. (Obermotz, 15. Apr 1998, 15:26:32):
~#! rn=Patryn rt=892646635 rg=gilden.zauberer
~#! tid=892646402
Was den ersten Teil angeht: Okay, ueberzeugt.
Was den zweiten Teil angeht: waere eine Komponentenpruefung nicht doch
moeglich? Ich Aergere mich immer, wenn cich mir im Kampf eine Extrahand
zaubern will und nichts kommt, weil mir die Haende ausgegangen sind.

OM, schon wieder freundlich gestimmt

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



Re^3: Wieder einer, der nur meckert. (Patryn, 15. Apr 1998, 15:27:52):
~#! rn=Obermotz rt=892646792 rg=gilden.zauberer
~#! tid=892646402
wie waers, wenn als ersatz deine eigenen haende genommen werden. die meldung:
 instinktiv saebelst du dir eine hand ab, um die noetigen komponenten
bereitzustellen...sollte eine entsprechende warnung sein ;)

------
patryn schmarrt herum

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



Re^4: Wieder einer, der nur meckert. (Obermotz, 15. Apr 1998, 15:29:28):
~#! rn=Patryn rt=892646872 rg=gilden.zauberer
~#! tid=892646402
Aber immer. Solange ich nach dem geglueckten zauber 3 Haende habe ;-)

OM, jetzt wieder ganz aufgeheitert

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



Re^5: Wieder einer, der nur meckert. (Teddy, 15. Apr 1998, 15:47:33):
~#! rn=Obermotz rt=892646968 rg=gilden.zauberer
~#! tid=892646402
Aber nur, wenn du ne Waffe mit Schnittschaden hast, was meist ja nicht der
Fall sein duerfte.
Teddy ;-)

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



Re^6: Wieder einer, der nur meckert. (Ringor, 15. Apr 1998, 15:48:56):
~#! rn=Teddy rt=892648053 rg=gilden.zauberer
~#! tid=892646402
Och, Kaempfer "schneiden" sich auch mit ner Keule mal ne Hand ab.

Gleiches Recht fuer alle. ;-)

Ringor

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



zauberstab (Patryn, 15. Apr 1998, 17:42:41):
irgendwie hab ich dem zauberstab 2 neue funktionen verpasst, die angeblich
jeder braucht...nun ja, ich fands ja immer ganz lustig, so wie es war :)
nun ja egal...ach ja: *offiziell verkuend*
 schnell und schmerzen arbeiten nun erfolgsabhaengig, steht auch in der bibo

------
patryn

PS: fuer neue funktionen auch neuen zauberstab besorgen :)

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



Re^3: Wieder einer, der nur meckert. (Silvana, 15. Apr 1998, 20:31:45):
~#! rn=Obermotz rt=892646792 rg=gilden.zauberer
~#! tid=892646402
Zu den von Patryn angemerkten Schwierigkeiten kommt ein rein technisches
Problem: Die Komponentensuche im Spieler ist nicht eben als schnell
zu bezeichnen. Eine doppelte Abfrage, die zur Vermeidung von Bugs
dann noetig waere wuerde nur unnoetig Zeit kosten.

  Silvana

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



zauberstab (Patryn, 15. Apr 1998, 20:36:59):
der zauberstab greift nun auf die hilfetexte aus der bibo zurueck.
das klappt noch nich alles so ganz hundertprozentig, aber ich arbeite dran.
leider kann man nur die spruchhilfen zu den zaubern einsehen, welche man
auch beherrscht, ansonsten muss man dann doch in die bibo.
auch die zusammenfassungen zu den zweigen und so sind vorerst nich im stab.

------
patryn

PS: noch mal nen neuen stab holen :)

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



Zaubererteams (Birdy, 16. Apr 1998, 16:42:07):
Hiho :)

Heute habe ich den Vorschlag gemacht, aus den Zauberern der einzelnen Zweige
und den Zauberern, die spaeter mal in diesen Zweig eintreten wollen, Teams zu
bilden.
Meine Motivationwar dabei, dass Neulinge in unserer Gilde sich bei speziellen
Problemen nicht mehr einem Schweigen auf -zau gegenueber sehen, sondern ein
Teammitglieder des Zweiges fragen koennen, den ihr Problem betrifft.
Ausserdem koennen wir uns somit nach aussen hin besser profilieren. Und damit
wichtige, wie Patryn schon gut formulierte, Oeffentlichkeitsarbeit leisten.
Natuerlich muss man nicht in einem Team sein und mann muss auch nicht fuer
immer dabei sein, Magister wechseln z.B. auch oefter mal die Zweige. :)
Da ich z.Z. im Zweig Angriff bin, habe ich gerade das Team Angriff ins Leben
gerufen, andere Teams sind auch grad im entstehen. Bei mir haben ab jetzt
natuerlich Anfragen von Zauberern meines Teams Vorrang und ich mach auch schon
mal Vorfuehrungen der
Sprueche, die ich gelernt habe. Trotzdem helfe ich weiterhin auch anderen. :)

Eine Bedingung fuer die Aufnahme in ein Team ist nur, dass man Seher ist.
Die Syntax, um sein Presay zu aendern ist dann einfach nur : presay [Team:
Hier Namen des gewuenschten Teams eingeben.]

Dis waers :)
Viel Spass !
Birdy

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



Re: Zaubererteams (Hardil, 17. Apr 1998, 13:42:48):
~#! rn=Birdy rt=892737727 rg=gilden.zauberer
~#! tid=892737727

Hab ich das jetzt richtig gemacht, Birdy? :-)

Hardil ist anwesend,
und zwar von: Deutschland.
Eingeloggt seit: Die,  7. Apr 1998, 09:05:56
Voller Name: [Team:Hier Namen des gewuenschten Teams eingeben.] Hardil 
Rasse: Elf,  Gilde: Zauberer,  Geschlecht: maennlich

Sieht etwas komisch aus, aber wenn es hilft...

[Team:Rentner] Hardil

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



Re: Re: Zaubererteams (Patryn, 17. Apr 1998, 13:44:18):
~#! rn=Hardil rt=892813368 rg=gilden.zauberer
~#! tid=892737727
huelfeee...ein DAU-Zauberer :)

------
patryn

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



Re^3: Zaubererteams (Hardil, 17. Apr 1998, 13:48:15):
~#! rn=Patryn rt=892813458 rg=gilden.zauberer
~#! tid=892737727

Heisst das dann nicht DAZ ?
Dann sollte ich mal mein Team in [Team:DAZ] umbenennen.

[Team:Rentner] Hardil

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



hilfe von einem karateka (Smarte, 20. Apr 1998, 15:39:59):
wie waere es ein objekt zu proggen das euch anzeigt welche zauber ihr wie oft
mit eurem inv zaubern koennt.
ciao 
Smarte

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



soll das so sein ? (Nairolf, 27. Apr 1998, 00:15:50):
finde
Du machst Deine Gedanken frei von allen weltlichen Dingen und konzentrierst
Dich auf die Ausfuehrung des Spruchs 'Finde'.
> Wen moechtest Du finden?


ist es nicht sinnvoller direkt abzufragen ob ich jemand finden will ?

Nai

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



Re: soll das so sein ? (Asmodis, 27. Apr 1998, 00:16:28):
~#! rn=Nairolf rt=893628950 rg=gilden.zauberer
~#! tid=893628950
Beschwoeren geht eh schneller :)

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



Re: Re: soll das so sein ? (Therin, 27. Apr 1998, 00:17:16):
~#! rn=Asmodis rt=893628988 rg=gilden.zauberer
~#! tid=893628950

finde wird ja auch hauptsaechlich fuer NPCs eingesetzt, da klappt beschwoere
nicht.

(Jedenfalls sollte es dafuer eingesetzt werden...)

T.

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



Re: Re: soll das so sein ? (Kilar, 27. Apr 1998, 00:17:57):
~#! rn=Asmodis rt=893628988 rg=gilden.zauberer
~#! tid=893628950
Beschwoere geht aber nicht bei NPCs

Kilar (schon wieder Einzeilig)

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



Re^3: soll das so sein ? (Therin, 27. Apr 1998, 00:18:33):
~#! rn=Kilar rt=893629077 rg=gilden.zauberer
~#! tid=893628950
Therin, schneller :)

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



Re^3: soll das so sein ? (Asmodis, 27. Apr 1998, 00:19:17):
~#! rn=Therin rt=893629036 rg=gilden.zauberer
~#! tid=893628950
Pfft, was hat man davon, wenn man einen NPC finden will ?
Wenn sie sich bewegen sind sie eh wieder weg, bis du dort
bist und ansonsten gibts einfachere Moeglichkeiten,
festzustellen, ob es welche momentan im MUD gibt.

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



Re^4: soll das so sein ? (Therin, 27. Apr 1998, 00:23:00):
~#! rn=Asmodis rt=893629157 rg=gilden.zauberer
~#! tid=893628950
Na, man findet den Aufenthaltsort.
Da fallen mir Phlyaken, Etwas, Hippe/Andy (wg. Postquest), Sun-Para ein.

Ansonsten wuesste ich zu finde keine Alternative, oder klappen die Kugeln auch
auf NPCs?

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



Re^5: soll das so sein ? (Jasonrigid, 27. Apr 1998, 12:18:57):
~#! rn=Therin rt=893629380 rg=gilden.zauberer
~#! tid=893628950
Nein !

Sogar nur ein-woertig, Jason Rigid.

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



feuerball (Patryn,  4. Mai 1998, 21:59:41):
es lohnt sich durchaus, diesen spell in der bibo noch mal naeher zu
durchleuchten. es wird eh jeder im kampf bemerken, dass er sich irgendwie
veraendert hat...
nen neuer zauberstab ist ebenfalls sehr sinnvoll...wieder mal :)
 . o O(irgendwann hab ich das mit dem gimmicks wohl im griff *grins*)

------
patryn

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



blutstein (Patryn,  5. Mai 1998, 09:16:26):
damit keiner umsonst an den ratten verreckt:
 der dort befindliche blutstein spielt noch nicht in der angegebenen weise
 mit, da muss ich noch was aendern...wenns fertig ist, kommt noch mal nen
 kurzer hinweis

------
patryn

PS: danke nachtwind

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



Re: blutstein (Patryn,  5. Mai 1998, 18:22:01):
~#! rn=Patryn rt=894352586 rg=gilden.zauberer
~#! tid=894352586
der blutstein geht jetzt...auf sie mit gebruell :)

------
patryn

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



teleport (Patryn,  6. Mai 1998, 18:23:28):
fluchtteleport kann nicht mehr unmittelbar hintereinander ausgefuehrt werden,
sondern es muss eine gewisse zeit verstreichen. das ganze bewegt sich im
sekundenbereich: somit sollte es keine allzugrossen probleme bereiten.

------
patryn

PS: meckerein werden ignoriert. das ganze ist noetig, um eine kleine
     erweiterung vorzunehmen, die noch in arbeit ist.

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



Re: teleport (Anatol,  6. Mai 1998, 18:27:29):
~#! rn=Patryn rt=894471808 rg=gilden.zauberer
~#! tid=894471808
Dann schlage ich spontan vor, dass "fluchtteleport" nie dorthin fuehrt, 
wo man gerade ist :-). Denn DAS koennte dann unter Umstaenden richtig
ekelhaft werden...

Anatol, stirbt - im Gegensatz zu vielen Supersehern - sehr ungern


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



Re: teleport (Asmodis,  6. Mai 1998, 18:36:24):
~#! rn=Patryn rt=894471808 rg=gilden.zauberer
~#! tid=894471808
Wieviele Sekunden? 6000 ? :)

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



Re: Re: teleport (Grimmborn,  6. Mai 1998, 21:16:28):
~#! rn=Asmodis rt=894472584 rg=gilden.zauberer
~#! tid=894471808
Hmm? Die Sekunde ist die SI-Einheit fuer Zeit. Insofern sind saemtliche
Zeitraeume im Sekundenbereich.

Grimmborn der Atheist

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



Rueste Ziel (Arelion, 13. Mai 1998, 12:55:44):
Hi Zauberer,

kann man rueste vielleicht so aendern, dass bei mehrdeutigen Angaben die
getragene Ruestung geruestet wird. Ich rueste in letzter Zeit naemlich dauernd
irgendwelche Panzer, die irgendwo rumliegen. :)

- i.V. Arelion


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



Wieder mal nen neuen Zauberstab? :) (Patryn,  2. Jun 1998, 09:45:41):
Dem einen oder andren duerfte es schon aufgefallen sein:
 Es ist nicht mehr sonderlich angebracht, zu kaempfen, wenn man nichts
 sieht. Dies hat zum einen den Nachteil, dass man nicht mehr kaempfen sollte,
 wenn man nichts sieht und es ist ebenfalls unsinnig, wenn man nichts sieht,
 zu kaempfen. haben das jetzt alle kapiert und verarbeitet? :)
na ja, ihr werdet schon merken und meckern :)
 wie es der zufall so wollte, habe ich mal die nachtsicht-dokumentation
 nebst dem eigentlichen zauber leicht veraendert, sodass man den nachteil
 wirkungsvoll beseitigen koennte, wenn man denn wollte. wer dies nicht will,
 der meckere dann auch nicht.

------
patryn, gegen rechtschreibung und ueberhaupt... :)

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



Re: Wieder mal nen neuen Zauberstab? :) (Patryn,  2. Jun 1998, 09:47:30):
~#! rn=Patryn rt=896773541 rg=gilden.zauberer
~#! tid=896773541
ach ja, zum beenden der nachtsicht braucht man...na?...richtig, einen
niegelnagelneuen zauberstab! 'ende' ist dabei recht erfolgreich, nicht dass
ihr wieder alle einzeln fragt... :)

------
patryn

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



Re: Wieder mal nen neuen Zauberstab? :) (Asmodis,  2. Jun 1998, 16:53:19):
~#! rn=Patryn rt=896773541 rg=gilden.zauberer
~#! tid=896773541
Sollte man das nicht allgemein einbauen, dass man schlechter kaempft, wenn man
nichts sieht ? Waere mal ne logische Veraenderung im Kampfsystem ...

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



Re: Re: Wieder mal nen neuen Zauberstab? :) (Patryn,  2. Jun 1998, 19:46:28):
~#! rn=Asmodis rt=896799199 rg=gilden.zauberer
~#! tid=896773541
bis das fertig ist, ist im himmel jahrmarkt...oder so :)
kraft meiner wassersuppe konnte ich dem ganzen halt schon mal etwas
(1 - 2 jahrhunderte?) vorgreifen.

------
patryn

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



Re: Wieder mal nen neuen Zauberstab? :) (Ratz,  2. Jun 1998, 20:42:07):
~#! rn=Patryn rt=896773541 rg=gilden.zauberer
~#! tid=896773541
Ist auch in erwaegung gezogen worden, dass auch npc's im dunkeln nichts sehen
koennen und daher schlechter kaempfen? Oder haben die alle eine automatische
Nachtsicht eingebaut.
Das Orks im Dunkeln besser sehen als Menschen kann ich nachvollziehen, aber
das muss ja nicht fuer alle Monster gelten. 
Allerdings wuerde dann die "licht aus", "nachtsicht" an Kombination sehr
maechtig. 
Dies ist als Idee fuer weiter Aenderungen gedacht und nicht als Kritik an dem
Istzustand!
gruss Ratz Fatz

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



Re: Re: Wieder mal nen neuen Zauberstab? :) (Hood,  2. Jun 1998, 20:43:44):
~#! rn=Ratz rt=896812927 rg=gilden.zauberer
~#! tid=896773541
manchmal hilft es, erst die doku zu lesen und danach zu schreiben.
allerdings ist die auswirkung nicht grad maechtig...aus wohl verstaendlichen
gruenden. probiern geht ueber vorher-labern :)

------
patryn

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



verwandlung (Darken,  6. Jun 1998, 14:36:42):
da ich jetzt magierzweitie bin gebe ich meinen magisterposten frei.
viel spass! :)

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



Alleine ? ! (Aline, 12. Jun 1998, 08:10:04):

zwer
Folgende Zauberer sind derzeit eingeloggt:
----------------------------------------------------------------------
Aline die Meisteranwaerterin

:(
kwer gilde zauberer

   Liste der Mitspieler vom Fre, 12. Jun 1998, 08:08:32 (2 Teilnehmer)

Aline............S Dhojakt........j.z

Puh doch nicht einsam :)


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



Spielerlevel 10 und schon Erzmagistra! (Lyra, 12. Jun 1998, 08:14:43):
Gestern habe ich HPGril getroffen. Sie hat Spielerlevel 10 und ist wie der
Titel sagt laut Beschreibung Erzmagistra. Komisch! :-) Und ausserdem ist sie
noch Bierschuettler. Ich will auch in 2 Gilden sein!
Die Loesung: wenn ein Nicht-Zauberer mal sein Spielerlevel in der
Zauberer-Gilde erhoeht, wird seine Beschreibung (Titel) umgewandelt in den
Entsprechenden Titel der Zauberer. Ne Lustige Sache.

Lyra, schreibt fuer Obermotz

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



Re: Spielerlevel 10 und schon Erzmagistra! (Jasonrigid, 12. Jun 1998, 16:18:35):
~#! rn=Lyra rt=897632083 rg=gilden.zauberer
~#! tid=897632083
Hey, sowas kommt nicht in die mpa *grins* jetzt wird das ausgebaut, und die
anderen spieler haben keinen spass mehr dran ;)

Jason -> Schmarrn

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



schwarzes brett (Patryn, 18. Jun 1998, 12:06:40):
wer das schwarze brett kennt, weiss, dass es bisher nicht eben viel machte.
dies hat sich im grossen und ganzen nicht geaendert, denn der einzige der
da was ranschreiben kann, das bin ich :)
wen meine notizen interessieren, der kann ja mal dort vorbeischaun, sind
aber nur daten darueber, was in der letzten zeit so in der gilde gemacht
wurde: nix interessantes also :)

------
patryn

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



Re: schwarzes brett (Key, 18. Jun 1998, 12:37:57):
~#! rn=Patryn rt=898164400 rg=gilden.zauberer
~#! tid=898164400
Hmm kannste das mal als Mail an mich schicken? :)

Key zu faul hinzulaufen ;)

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



Re: schwarzes brett (Therin, 19. Jun 1998, 21:15:23):
~#! rn=Patryn rt=898164400 rg=gilden.zauberer
~#! tid=898164400

Ahhhh.... jetzt weiss man wenigstens, was "hier kann man in kuerze..." in der
Zauberergilde heisst. :)

Wie war das noch? Ein-Wort-Witz der Zauberer? Taramis.

T.

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



komponententransfare :) (Patryn, 26. Jun 1998, 13:52:25):
man sollte llystrathe noch mal nach stichworten fragen, es ist was neues
hinzugekommen: sollte sogar fuer nichtzauberer gehen! (fuer die ist
es eigentlich auch gedacht),
also aus der ferne 'teile llystrathe mit information' oder so und dann lesen
und kombinieren. zauberern rate ich in dieser hinsicht zu vorsicht :)
sie bekommen noch ne nutzbare version als zauberstabsgimmick.

------
patryn

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



Re: komponententransfare :) (Sting, 26. Jun 1998, 16:37:58):
~#! rn=Patryn rt=898861945 rg=gilden.zauberer
~#! tid=898861945
SUPER, grosses Lob an Patryn.

Sting

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



Re: komponententransfare :) (Anatol, 26. Jun 1998, 17:01:15):
~#! rn=Patryn rt=898861945 rg=gilden.zauberer
~#! tid=898861945
Was Patryn sagen moechte: Probiert folgendes bitte _NICHT_, wenn ihr nicht
eure Komponenten wieder aus dem Pentagramm holen wollt:

                 "teile llystrathe mit komponenten"

Anatol, sieht die Komponenten nur so an sich vorbeisausen :)


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



Re: Re: komponententransfare :) (Sharia, 26. Jun 1998, 23:41:31):
~#! rn=Anatol rt=898873275 rg=gilden.zauberer
~#! tid=898861945
sollte man vielleicht dahingehend aendern, dass Llystrathe den Zauberern NUR
komponenten abnimmt, wenn diese nicht in einem Guertel stecken :-))

nur so als dummer vorschlag

sharia

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



Re: Re: komponententransfare :) (Trekan, 26. Jun 1998, 23:59:51):
~#! rn=Anatol rt=898873275 rg=gilden.zauberer
~#! tid=898861945
tolle sache, dass sie gnaedigerweise auch den guertel nimmt.
so is das was ueberfluessig. wenn, dann soll sie doch das nehemn, was im IVN
is, aber nicht was im guertel ist.

Trekan

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



Re^3: komponententransfare :) (Sharia, 27. Jun 1998, 00:00:43):
~#! rn=Trekan rt=898898391 rg=gilden.zauberer
~#! tid=898861945
hmm das hab ich doch schon geschrieben oder ? :-)
ausserdem schrieb Patryn doch dass es vorallem fuer NICHTZAUBERER ist :-)

Ich finds gut.

Sharia

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



Re^4: komponententransfare :) (Trekan, 27. Jun 1998, 00:01:40):
~#! rn=Sharia rt=898898443 rg=gilden.zauberer
~#! tid=898861945
jaja .. hab ich danach erst gelesen. ich war erstma empoert, dass mein
heiliger schmarotzter guertel weg war.
Also bin ich erstma zu gilde gerannt und musste dann gleich meinen suelz
loswerden.
Trekan

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



entsorge (Sharia, 27. Jun 1998, 16:40:19):

Im Rahmen der Speicherschonung sollte man vielleicht die Verzoegerung von
entsorgen wieder herausnehmen, denn MIT dieser Verzoegerung ist es einfach nur
nervig herumliegende Ausruestung zu vernichten .....


nur so als Idee :-)


Sharia im Auftrag des Herrn aehm des Ersties ...

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



Re: entsorge (Bierchen,  1. Jul 1998, 05:23:27):
~#! rn=Sharia rt=898958419 rg=gilden.zauberer
~#! tid=898958419
nur wird dann keine ausruestung vernichtet, sondern dinge, die einfach und
schnell zu bekommen sind. handbuecher, irgendwelche steine.. und was es sonst
noch ohne grenzen gibt. lag laesst gruessen.
  - Bierchen -

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



Re: Re: entsorge (Nachtwind,  1. Jul 1998, 05:27:39):
~#! rn=Bierchen rt=899263407 rg=gilden.zauberer
~#! tid=898958419
Handbuecher, Zeitungen und dergl. kann man schon lange nicht mehr entsorgen.
Stellen, an denen das noch geht, muessen halt geaendert werden, sowas
ist eh immer Mist.

Nachtwind.

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



Re^3: entsorge (Sharia,  1. Jul 1998, 08:57:57):
~#! rn=Nachtwind rt=899263659 rg=gilden.zauberer
~#! tid=898958419
zudem gibt es moeglichkeiten WESENTLICH schneller und weniger Aufwand mehr
Stabmagiepunkte zu erreichen als mit entsorgen ...

Sharia

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



Re: Re: entsorge (Patryn,  1. Jul 1998, 09:35:31):
~#! rn=Bierchen rt=899263407 rg=gilden.zauberer
~#! tid=898958419
also buecher werden von zauberern verschont...wissen vernichten gibts nicht,
im uebrigen finde ich die wartezeit da ganz gut, es wurde einfach zu viel
mist gebaut und ihr seid mehr oder weniger selbst schuld.
sicherlich konnte man damals noch keine anzahl bei unit-objekten angaben,
aber ich meine eher solche dinge wie
'/repeat -0 1000 nimm kohlestueck aus ofen%;entsorgen kohlestueck'

------
patryn

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



Re: Re: entsorge (Key,  1. Jul 1998, 10:18:14):
~#! rn=Bierchen rt=899263407 rg=gilden.zauberer
~#! tid=898958419
Der einzigste Grund warum das gemacht wurde war das man pro Gegenstand einen
Stabmagiepunkt bekam.
Und einige der Objs die du da aufzaehlst kann man nimmer entsorgen.

Key teilt Sharias Meinung

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



Re^3: entsorge (Therin,  1. Jul 1998, 14:12:24):
~#! rn=Patryn rt=899278531 rg=gilden.zauberer
~#! tid=898958419
Ich denke, fast jeder zumindest aeltere Zauberer hat mal mit nimm
buch/entsorge Buch (oder wars doch die Zeitung?) gegen Anfang seinen
Zauberstab geuebt und nicht so sehr um unbedingt Spellpoints in den Stab zu
bekommen. 
Nachdem einige Gegensaende (die man eben so mit vorliebe entsorgte) nicht mehr
gingen, ist die Zeitsperre bei entsorge ja eigentlich dann doppelt gemoppelt,
zumeist es wie Nairolf bereits andeutete, bessere Moeglichkeiten zum aufladen
gibt.

T.

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



Re^4: entsorge (Gloinson,  1. Jul 1998, 14:50:30):
~#! rn=Therin rt=899295144 rg=gilden.zauberer
~#! tid=898958419
Es gibt aber noch genug Gegenstaende, die auch unendlich vorhanden und
entsorgbar sind. Schaetze genau deshalb gibt es aber auch die Moeglich-
keiten zur besseren Aufladung.

PS: Moechte mal jemanden sehen, der seinen Stab wirklich zum Muellent-
    sorgen nutzt. Die meisten erzeugten dafuer doch erst Objekte.

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



Re^5: entsorge (Therin,  1. Jul 1998, 14:53:56):
~#! rn=Gloinson rt=899297430 rg=gilden.zauberer
~#! tid=898958419
Hier wos leuchtet :)
Hier wos leuchtet. fuer was anderes wuerd ich entsorgen gar nicht nehmen
wollen...

Paradebeispiel: entsorgen leiche, entsorgen saeckchen, entsorgen mokasssins
(gardi) 
(bzw. hab ich da alis drauf)


T.

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



Re^5: entsorge (Anatol,  1. Jul 1998, 15:21:52):
~#! rn=Gloinson rt=899297430 rg=gilden.zauberer
~#! tid=898958419
Ueberlasse DAS bitte den Zauberern, die _wissen_, was sie tun und womit
sie ihren Zauberstab aufladen. Jemand, der es mit Buechern o.ae. tut, hat
weder das Prinzip des Muds noch den Zauberstab verstanden.

Und Ja, ich weiss, dass "entkraefte" ein _Magister_spruch ist. Aber das ist
nicht wirklich das Problem, glaubt's mir einfach.

Anatol, fasst sich an den Kopf


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



Re^5: entsorge (Aline,  1. Jul 1998, 15:38:27):
~#! rn=Gloinson rt=899297430 rg=gilden.zauberer
~#! tid=898958419

Aeh auch wenn ich mich jetzt vielleicht als unsagbar dumm
oute: Ich benutze "entsorgen" nur zum Edelsteinsaeckchen
loswerden oder aehnliches (also Klartext: zum Muellentsorgen!).

Aline

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



Re^6: entsorge (Therin,  1. Jul 1998, 16:26:10):
~#! rn=Aline rt=899300307 rg=gilden.zauberer
~#! tid=898958419

Danke, Aline :)

T.

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



Re^7: entsorge (Sharia,  7. Jul 1998, 01:23:58):
~#! rn=Therin rt=899303170 rg=gilden.zauberer
~#! tid=898958419

Noch eine Idee zum entsorgen:

wenn man schon nichtmehr das beschleunigte Entsorgen einbauen moechte, so
koennte man vielleicht das entsorgen leiche dahingehend aendern, dass alle
ausruestungsgegenstaende gleich mit vernichtet werden ... man muss dafuer ja
dann nicht extra stabmagie bekommen, aber ich denke halt immernoch an die
objektreduzierung :-)

Sharia, will Speicher schonen

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



Re^8: entsorge (Sharia,  7. Jul 1998, 01:24:35):
~#! rn=Sharia rt=899767438 rg=gilden.zauberer
~#! tid=898958419
aehm ich meine natuerlich die Ausruestungsgegenstaende die sich IN einer
leiche befinden die entsorgt wird :-)

Sharia

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



Re^9: entsorge (Teddy,  7. Jul 1998, 01:25:45):
~#! rn=Sharia rt=899767475 rg=gilden.zauberer
~#! tid=898958419
Dafuer, aber bitte auch fuer andere Gilden.

Teddy

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



Re^10: entsorge (Sharia,  7. Jul 1998, 01:29:00):
~#! rn=Teddy rt=899767545 rg=gilden.zauberer
~#! tid=898958419

Ja das ist mein Gedanke:
Es wurde mal vorgeschlagen, begrabe als Skill(oder Spell ? :-) *grins
Silvana*) fuer alle zu machen .. halte ich persoenlich nicht soo gut ...
Vielleicht waere dann fuer die Chaoten ein "fledder leiche" oder "schaende
leiche" sinnvoller ...wobei dann der charakter geringfuegig sinken wuerde.....

vielleicht koennte man sowas auch gleich in die lib einbauen ... wer weiss
....:-) ich persoenlich halte begrabe so mit weihwasser und leichentuch eher
fuer eine Sache die wirklich zu Klerikern passt.....

Sharia

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



Re^11: entsorge (Dieder,  7. Jul 1998, 01:40:29):
~#! rn=Sharia rt=899767740 rg=gilden.zauberer
~#! tid=898958419
"fledder leiche" bzw. "schande leiche" fuer chaoten??


als chaot muss ich sagen: dafuer :)))

Dieder, als Chaot empfindlich gegen Weihwasser, Leichentuch etc :)))

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



Re^11: entsorge (Key,  7. Jul 1998, 10:07:14):
~#! rn=Sharia rt=899767740 rg=gilden.zauberer
~#! tid=898958419
Yeah :)
*nasch an einer Weghier-Leiche*
*schleck*
Hmm das tut gut :)

Key will auch ne Klerikerleiche anknabbern ;)

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



Re^12: entsorge (Schoko,  7. Jul 1998, 11:30:58):
~#! rn=Key rt=899798834 rg=gilden.zauberer
~#! tid=898958419
Allerdings isses fuer mich voellich uneinsichtig, warum das ein Spell is.
Allerhoechstens noch ein Skill aber das waers dann auch ...

cu
Schoko
P.S.: was machen denn dann Kamepfer? Zerlege Leiche um die lebenswichtigen
Organe zu identifizieren und dann treffen sie beim naechsten mal gleich ne
Stange besser? ;))

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



Re^13: entsorge (Lyra,  7. Jul 1998, 11:32:00):
~#! rn=Schoko rt=899803858 rg=gilden.zauberer
~#! tid=898958419
Das waere doch auch mal interessant.

Lyra, wollte immer schon mal Medizin studieren

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



Re^13: entsorge (Zephyr,  7. Jul 1998, 11:32:54):
~#! rn=Schoko rt=899803858 rg=gilden.zauberer
~#! tid=898958419

Och.. mit den Einzelteilen kann man den Ausbildern sicher gute 
streiche spielen.. Ich sehe schon Edelmir von Botanos wie am Spiess
lispeln weil er nen frisches Drachenherz unterm Kopfkissen gefunden
hat

*gemein grinsend*
                     Zephyr

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



Re^14: entsorge (Teddy,  7. Jul 1998, 12:27:43):
~#! rn=Zephyr rt=899803974 rg=gilden.zauberer
~#! tid=898958419
Tststs und sowas ist nun Offizier ;-)


Teddy

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



Re^15: entsorge (Key,  7. Jul 1998, 12:36:17):
~#! rn=Teddy rt=899807263 rg=gilden.zauberer
~#! tid=898958419
Hmm und wenn es Berufe gibt werden alle Kaempfer Metzger? :)

Key

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



Re^8: entsorge (Birdy,  7. Jul 1998, 16:08:50):
~#! rn=Sharia rt=899767438 rg=gilden.zauberer
~#! tid=898958419

Die Ausruestungsgegenstaende gleich mit zu entsorgen halte ich fuer schlecht,
meist entsorgt man doch erst die Leiche, um sich dann einfach die Sachen zu
nehmen, die man haben will. Besonders wenn man mehrere Leichen rumliegen hat,
dann braucht man nicht immer extra alles einzeln rausklauben.
Also gegen deinen Vorschlag Sharia.

Birdy

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



komponenten (Patryn,  7. Jul 1998, 21:02:09):
hi zauberer

bei einigen komponenten koennte es nun entschieden weniger geben, als zuvor.
sollten einige anzahlen zu extrem abgespeckt worden sein, so bitte ich darum,
mich darauf hinzuweisen.

------
patryn

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



Meldungen von Llystrathe (Mtv, 22. Jul 1998, 22:31:41):
Ich finde Llystrathe sollte nicht nur bestandene Gildenquests kommentieren,
sonder auch wenn jemand seine Gildenstufe erhoeht, die Lehrlingspruefung oder
Magisterpruefung besteht und vielleicht auch noch wenn jemand einen
Magisterposten in einem Zweig antritt. Was haltet ihr davon??? Und wie steht
es eigentlich um die Erzmagister, weiss da jemand etwas darueber???

MTV

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



Re: Meldungen von Llystrathe (Anatol, 23. Jul 1998, 00:39:34):
~#! rn=Mtv rt=901139501 rg=gilden.zauberer
~#! tid=901139501
Als Meisteranwaerter koenntest Du bemerkt haben, dass Llystrathe sich
gelegentlich auch ueber "zruf" bemerkbar macht - zumindest bestandene
Magisterpruefungen werden bekannt gegeben. Und so nebenbei: Wieviele 
Gilden geben das _Nichtbestehen_ einer solchen Pruefung bekannt? Und falls
es solche gibt, wieviele ausser den Zauberern tun dies auf [Tod:]? :)

Anatol :)


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



Re: Re: Meldungen von Llystrathe (Silvana, 23. Jul 1998, 19:25:02):
~#! rn=Anatol rt=901147174 rg=gilden.zauberer
~#! tid=901139501
Ueber die Lehrlingspruefung liesse sich ja noch reden, aber
Stufenaufstiege? Das muss nicht sein. Llystrathe ist schliesslich
nicht mit Bruno verwandt. :) Das waere eher nen Job fuer Randar Tobis,
wenn der alte Duckmaeuser den Mund aufbekaeme... Aber man kann ihn
ja verstehen. Den ganzen Tag mit Llystrathe in einem Raum... Armer Kerl. :)

  Silvana

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



Erste (kleine) Abwertung (?) (Silvana, 26. Jul 1998, 20:18:31):
Also, den Anwesenden zu Erklaerung:

Ich habe gerade eine neue Version des Zauberer-Masters eingespielt, die
deutlich weniger Rechenzeit brauchen sollte. Der Nebeneffekt ist, dass
Magister und Erzmagister nicht mehr automatisch nach gewisser Zeit
rausfliegen, sondern erst, wenn jemand nachliest, wer denn noch seinen
Posten hat. Also: Schild lesen -> evtl jemand degradiert. Damit ist
klar, dass man mit permanentem Lesen der Schilder Lag machen kann, aber DAS
haettet ihr Euch dann selbst zuzuschreiben. :)
Somit: Die Lagkraft der Gilde duerfte empfindlich geschrumpft sein.
Ich hoffe, ihr kreuzigt mich nicht dafuer. :)

  Silvana

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



Erste Aenderungen (Silvana, 28. Jul 1998, 00:04:04):
Hi.

Da Patryn mit seinen Pruefungen schwer beschaeftigt ist, nehme
ich ihm mal ein wenig Arbeit ab und bau schon mal ein bisschen
um. Das folgende ist voellig unsortiert, ich hoffe, ihr findet
trotzdem durch.

1) Das Lernen ist voellig ueberarbeitet: Es gibt keine Zauber-
   bremsen mehr. Statt dessen lernt man auch bei besonders 
   gelungenen Spruechen hin und wieder etwas.
   Ob die Voreinstellungen so bleiben koennen, wie sie sind, wird
   sich zeigen muessen.

2) Auch perfekte Zauberer koennen misslingen und sogar uebel patzen.
   - wobei allerdings die uebelsten Patzer ausgeklammert wurden. 
   Ein perfekter Zauber ruft also kein die() auf. :)

3) Stille paralysiert nicht mehr. (Ich frage mich, wieso es das
   je tat...)

  Silvana (macht morgen weiter)

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



Re: Erste Aenderungen (Aline, 28. Jul 1998, 10:03:48):
~#! rn=Silvana rt=901577044 rg=gilden.zauberer
~#! tid=901577044
Hi Lieblingszaubermagierin,

>Auch perfekte Zauberer koennen misslingen und sogar uebel patzen.
Puh bin ich froh, dass ich weder perfekt bin, noch dass ich Zauberer bin. :)

Aline (patzt nicht gerne) :)

-----------------------------------------------------------------------------



erste aenderungen (Mtv, 28. Jul 1998, 11:51:25):
~#! rn=Silvana rt=901577044 rg=gilden.zauberer
~#! tid=901577044
Als Zauberer hat man doch nur die Sprueche zur Verfuegung, wieso darf man die
nicht mehr so beherrschen, dass sie nicht mehr schiefgehen.In jeder anderen
Gilde kann man sich auf die Waffen in diesem Sinne verlassen, das sie einem
nicht selber schaden. Damit zwingst du selbst hochstufige Zauberer, die
Casting und zb Verletze auf max haben, selbst beim kleinsten Gegner eine
Vorsicht von 150 zu haben, da ein normaler Zauberpatzer einen durchaus selbst
zerstaeuben kann. Ich kann mir keine _schlimmere_ Abwertung der Zauberer
vorstellen als diese.

Auch die Abschaffung der Zauberbremse finde ich bloede, aber wenn es sein
muss, kann ich mich damit abfinden. Ich habe aber noch eine Frage dazu: Heute
ist es mir mehrmals passiert, dass wenn mir ein Spruch endlich missglueckt
ist, ich nichts aus den Fehlern gelernt habe, zb habe ich erst beim vierten
mal missgluecken etwas gelernt. Ist das Absicht oder ein Bug.

MTV

-----------------------------------------------------------------------------



Re: erste aenderungen (Anatol, 28. Jul 1998, 11:56:21):
~#! rn=Mtv rt=901619485 rg=gilden.zauberer
~#! tid=901577044
AAAAAAAARGH :) Sag mal, Mtv, wie BLIND laeufst Du denn durch die
Gegend?! :) (a) Es ist in der Natur der Chaoten, dass sie sich auf nichts
wirklich verlassen koenen. (b) Auch Kaempfer koennen mit einem 100%-Skill
einen kleinen Strip hinlegen oder sich einen Hand abschlagen. Wie nennst
Du das? Scherzeinlage? _Ich_ nenne es Patzer :).

Fuer alles weitere tut es wohl ein allgemeines: "Heul' doch!" 

Anatol


-----------------------------------------------------------------------------



Re: erste aenderungen (Morgoth, 28. Jul 1998, 11:58:50):
~#! rn=Mtv rt=901619485 rg=gilden.zauberer
~#! tid=901577044
Also wenn Du mit einem verletze zerstaeubst, ist die Gilde definitiv zu
stark...
Silvana, weiter abwerten 

M*

-----------------------------------------------------------------------------



Re: erste aenderungen (Silvana, 28. Jul 1998, 12:33:07):
~#! rn=Mtv rt=901619485 rg=gilden.zauberer
~#! tid=901577044
Ich meine geschrieben zu haben, dass ich die ultraharten Patze
explizit ausgenommen habe. Bei einer Ameise sollt also eine 
Vorsicht von 30 locker reichen. :)

  Silvana

-----------------------------------------------------------------------------



Lernen (Silvana, 28. Jul 1998, 12:42:44):
Um es nicht jedem einzeln zu erklaeren: Das Lernen ist so geaendert,
dass man unter unsinnigen Umstaenden, also wenn man den Erfolg
kuenstlich verhindert, nix mehr lernt. Wer also zu Lernen sich
betrinkt oder schwere Ruestungen anzieht, ist selbst schuld.

  Silvana

-----------------------------------------------------------------------------



Re: Re: erste aenderungen (Key, 28. Jul 1998, 12:44:25):
~#! rn=Silvana rt=901621987 rg=gilden.zauberer
~#! tid=901577044
*kicher*
Das passt :)

Zauberewr sind solch grosse Feiglinge das sie selbst bei einer Ameise
vorsichtig sind =;))

Key

-----------------------------------------------------------------------------



erste aenderungen (Mtv, 28. Jul 1998, 13:20:10):
~#! rn=Morgoth rt=901619930 rg=gilden.zauberer
~#! tid=901577044
jepp einen zerstaeube habe ich bei mir selbst schon 2 mal geschafft ==> 2 tode

leider habe ich einen solchen schaden noch _nie_ bei einem gegner erreicht

mtv

-----------------------------------------------------------------------------



Re: Lernen (Teddy, 28. Jul 1998, 13:30:23):
~#! rn=Silvana rt=901622564 rg=gilden.zauberer
~#! tid=901622564
na endlich ;)

Teddy

-----------------------------------------------------------------------------



Zweite Runde. (Silvana, 28. Jul 1998, 19:41:18):
Hi.

So, zweite Runde.
Folgendes ist heute geaendert worden:

1) Lernrate:
   Da erste Feldversuche heute gezeigt haben, dass die Lernrate doch
   ein wenig _sehr_ gering war, ist diese jetzt etwas besser.

2) Noch mal Lernen:
   Eine Reihe von Spruechen ist nur noch bei 'sinnvoller Anwendung'
   zu lernen. Im Falle von Angriffsspruechen bedeutet das, dass ein
   angemessener Gegner zu waehlen ist - je besser den Spruch, desto
   staerker sollte der Gegner sein.

3) Schutz:
   - Es werden jetzt _alle_ mechanischen Schadenstypen als mechanisch
     erkannt. :)
   - Schutz hilft ausschliesslich gegen den mechanischen Anteil des
     Angriffs, bei Mischschaden anteilig.

4) Schutzhuelle:
   - Schutzhuelle hilft sehr gut gegen nichtmechanischen (und nicht 
     klerikalen) Schaden, schlecht gegen den Rest. Der Uebergang
     bei Mischschaden ist anteilig. (War bisher hart.)
   - Schutzhuelle auf sich selbst bleibt zwar an besten, wurde jedoch
     schwaecher, auf andere wurde sie deutlich besser. Schutzhuelle
     auf einen Kaempfer sollte sich damit sogar lohnen. 

5) Teleport:
   Hier wurde etwas zur Lagverminderung getan.

6) Werte:
   Zeigt nur an, OB ein NPC evtl EK-Stufenpunkte gibt, aber nicht mehr,
   ob es auch mehrere sind.

(Jetzt wirds bitter...)
7) Befriede:
   Es werden nur noch die Lebewesen befriedet, die auch tatsaechlich
   kaempfen.

8) Rueste:
   Haelt jetzt 3mal so lang. (bitter? NOCH nicht, ABER...)
   Rueste schuetzt nur noch gegen den magischen Anteil des Schadens
   und auch das nur bis zur Ruestungsklasse der Ruestung... *autsch*!

So, mehr mag ich Euch heute wirklich nicht mehr zumuten...

  Silvana (macht morgen weiter)

-----------------------------------------------------------------------------



ich will auch mal :) (Patryn, 28. Jul 1998, 20:49:30):
es lohnt sich durchaus, nochmal den spruch teleport nachzuschlagen.
da das ganze system recht komplex ist, bitte ich um fehlermeldungen, ideen
u.s.w., nich das die meute wieder schweigt, wenn das teil mist baut.
getestet ist es zwar, aber viele augen sehen mehr :)

------
patryn

PS: ach ja, erst ab level 9 interessant

-----------------------------------------------------------------------------



Lernen (Shorkan, 29. Jul 1998, 09:28:47):
Hi Zauberers

Wie waers mit einer Datenerfassung ?
Ich habe gestern ca. 30 mal den Schnell- Spruch gesprochen und nix gelernt.
Heute das gleiche in einer zuversichtlicheren Gemuetslage.
Tja undd auch heute nix ...
Ich hab den Spruch auf gut ausreichend

Ich wuerde vorschlagen wir versuchen zu erfassen, wie lange wir fuer eine
Lernstufe ueben.
Dabei sollte man sich an die folgenden Regeln halten:
  - Nuchtern sein
  - Keine stoerende Ruestung tragen
  - Einge gewisse Zeit (regelmaessig) zwischen den Spruechen warten
  - Nur den gleichen Spruch ueben (und sonst immer die gleiche Kombination
von Spruechen)
  - Uebungsort beibehalten (Uebungsraum bringt anschbeinend nix mehr)

Little Shorkan, der Bluemchenpfluecker

-----------------------------------------------------------------------------



Dritte Runde (Silvana, 29. Jul 1998, 14:53:55):
Hi.

So, dritte Runde.
Folgendes ist heute geaendert worden:

1) Hand:
  - hand ist etwas schwaecher geworden.
  - Dafuer gibts ein paar nette neue Features, die Patryn bekanntgeben
    darf, wenn er die Hilfe soweit umgeschrieben hat. :)

2) Verletze:
  Da Verletze ein sehr vielseitiger Spruch mit grosser Wirkung ist,
  benoetigt man dafuer etwas Ruhe um ihn mit voller Wirkung einsetzen
  zu koennen. Mit anderen Worte, wenn man gerade ein einen Raum 
  hereingehetzt kommt, ist verletze noch recht schwach, was sich aber
  in den ersten paar Sekunden wieder legt.

3) Schutzhuelle:
  Schutzhuelle auf andere wirkt deutlich besser, solange der Zauberer,
  der den Spruch wirkte, sich im gleichen Raum befindet, wie der
  geschuetzte Spieler, da es dem Zauberer so leichter faellt, den 
  Schutz der Huelle an die aktuellen Bedingungen anzupassen.

4) Identifiziere:
  Geringfuegige Resistenzen und Empfindlichkeiten werden nicht mehr
  erkannt. Resistenzen und Empfindlichkeiten fuer mechanische
  Schadensarten werden gar nicht mehr erkannt. Um Informationen
  hierueber zu erhalten, wende man sich bitte vertrauensvoll an
  den naechsten Trves, der versteht bestimmt mehr davon.


So viel zu den Aenderungen. Nun hab ich noch eine paar Bitten (Jaja,
ich weiss, ich bin unverschaemt, aber irgendwie muss man seinem EM-Ruf
ja gerecht werden):

1) Wir moechten die Schadensmeldungen von verletze und den anderen
   Angriffsspruechen um 2-3 Stufen erweitern und etwas anders
   skalieren, da wir der Meinung sind, dass die Meldungen derzeit
   nicht sooo informativ sind. Wenn ihr also Ideen fuer passende 
   Meldungen habt, her damit (bitte als Mail an Patryn und mich).

2) Es ist ein groesserer Umbau der Raeumlichkeiten der Gilde geplant.
   Wenn Euch irgendetwas einfaellt, dass die Gilde schon laengst haben
   sollte, mailt es mir.

3) Ich bin schwer daran interessiert, wie ihr mit dem Lernen derzeit
   klar kommt. Waere schoen, wenn sich ein paar Nachwuchs-Zauberer 
   die Muehe machen wuerden, mir dazu ein paar Zeilen zu mailen.
   Natuerlich nicht jetzt, sondern nach ausgiebigem Testen ist 2-3
   Wochen oder so.

  Schon mal schoenen Dank im Voraus:

    Silvana (macht morgen weiter)

-----------------------------------------------------------------------------



Re: Dritte Runde (Morgoth, 29. Jul 1998, 14:57:58):
~#! rn=Silvana rt=901716835 rg=gilden.zauberer
~#! tid=901716835
Ringor wird Dich fuer die neuen Schadensmeldungen wuergen. ;-)

M*

-----------------------------------------------------------------------------



Re: Re: Dritte Runde (Ringor, 29. Jul 1998, 15:46:51):
~#! rn=Morgoth rt=901717078 rg=gilden.zauberer
~#! tid=901716835
Ganz im Gegenteil. So kommen wenigstens die dummen "Rundungsfehler" weg. Und
man sieht endlich mal, wieviel die bisher unter den Maximum-Meldungen
zusammengefassten Meldungen wirklich an Schaden machen.

Eindeutig dafuer, 
Ringor

-----------------------------------------------------------------------------



Schmetterling! (Hasim, 29. Jul 1998, 16:53:51):
So... mit Hand kann man einen schmetterling nicht besiegen! Ich wuerde mal
sagen, das sollte zu denken geben!
Hasim, doch etwas erbost!

-----------------------------------------------------------------------------



Sorry (Silvana, 29. Jul 1998, 17:34:40):
Aehm... Bei Hand ist mir ein kleiner aber wirkungsvoller Fehler
unterlaufen. Ich hatte vor, die Wirkung von Hand staerker von der 
bereits vorhandenen Staerke des Angriffs mit blossen Haenden
abhaengig zu machen und das mit etwas weniger Staerke-abhaengigkeit zu
begleichen. Hab mich dabei um eine Zehnerpotenz vertan.
Well, ist (hoffentlich) behoben. :)

  Silvana

-----------------------------------------------------------------------------



neue faehigkeiten (Patryn, 29. Jul 1998, 19:00:37):
und es lohnt sich auch bei 'hand', noch mal in die doku zu schaun.
der beschriebene vulkan in der komphilfe existiert aber noch nicht, sucht euch
nicht dusslig und nehmt letztere fundstelle :)

------
patryn

-----------------------------------------------------------------------------



Re: neue faehigkeiten (Key, 29. Jul 1998, 19:01:54):
~#! rn=Patryn rt=901731637 rg=gilden.zauberer
~#! tid=901731637
Wag es nicht Zaubererkomps in Tillys Vulkan zu verstecken! ;)

Key

-----------------------------------------------------------------------------



Re: Re: neue faehigkeiten (Patryn, 29. Jul 1998, 19:03:57):
~#! rn=Key rt=901731714 rg=gilden.zauberer
~#! tid=901731637
also gegenueber dem vulkan aus der komphilfe ist das aber nen ferienparadies
:)

------
patryn

-----------------------------------------------------------------------------



Re: Re: neue faehigkeiten (Tilly, 29. Jul 1998, 22:00:11):
~#! rn=Key rt=901731714 rg=gilden.zauberer
~#! tid=901731637

Aehmmm Key, wieso denn nicht. Ich find den gemuetlich.... :)

[Team:Vulkanier] Tilly

-----------------------------------------------------------------------------



Lernen (Pake, 30. Jul 1998, 06:51:04):
Hallo,
sagt mal, ich hoffe das Lernen wird noch mal gruendlich ueberarbeitet.
Ich habe heute eine Stunde Giftpfeil geuebt und habe genau 2! mal etwas
gelernt. Der Zauber ist auf gerade noch mangelhaft, er reicht anscheind dafuer
aus, dass er gelingt (nix lernen am Misserfolg), aber ist bei weitem nicht gut
genug (nix Lernen am Erfolg).
Und was nuetzt mir nun ein Spruch, der sich in 70% der Faelle in den Boden
bohrt?

Pake (etwas gefrustet)

ps: Ist es immer noch so, dass man _automatisch_ beim Misslingen des Zaubers
etwas lernt? Ich bin mir da naemlich nicht mehr so sicher...

-----------------------------------------------------------------------------



lernen (Mtv, 30. Jul 1998, 09:27:49):
~#! rn=Pake rt=901774264 rg=gilden.zauberer
~#! tid=901774264
Ich wollte heute Schmerzen lernen und dachte mir probier es einfach. Ich habe
den Spruch auf aeusserst ungenuegend und habe am waechter geuebt. Nach 50
versuchen von denen 9 fehlschlugen und aus denen ich lernte, hatte ich den
spruch um eine stufe auf ungenuegend gesteigert, ich dachte mir nagut, damit
kann ich leben.

Doch was danach geschehen ist, frustet mich doch ziemlich stark. In weiteren
40 Versuchen habe ich genau noch 1 mal etwas gelernt!!!

Ich hoffe doch stark, dass das lernen noch einmal ueberarbeitet wird.

MTV

-----------------------------------------------------------------------------



Schnell- Spruch lernen aussichtslos ? (Shorkan, 30. Jul 1998, 16:07:00):
So, nachdem ich 100 mal den Schnellspruch gesprochen habe und
dabei nie etwas gelernt habe, gebe ich es auf.

Little Shorkan, der Bluemchenpfluecker.

-----------------------------------------------------------------------------



Lernen (Vincent, 31. Jul 1998, 10:52:21):
Der derzeitige Zustand bezueglich daes Lernens macht mich auch
nicht so ganz gluecklich. Gestern und am Wochenende habe ich
uebe den Daumen gepeilt etwa 3 Stunden NUR den Licht-Spruch
geuebt mit dem Hintergedanken meinen Umgang mit dem
Zauberstab zu verbessern. Im Schnitt bei jedem fuenftem
Spruch erschien die Meldung "Der Zauberstab unterstuetzt dich"
und etwa bei jedem zehnten Spruch die Meldung "Du hast Dich im
Umgang mit dem Zauberstab verbessert". Allerdings hatte ich es
erst nach den 3 Stunden geschafft, meine Faehigkeiten im
Umgang mit dem Zauberstab von "schlecht" um eine Stufe
zu erhoehen. Nebenbei bemerkt hat sich waehrend der gesamten
Zeit mein Licht-Spruch ueberhaupt nicht verbessert und
befindet sich immer noch auf "sehr befriedigend".

So, das ist die Situation, wie sie sich mir darstellt. Hoffe,
das hilft den Porgrammierern beim Feinjustieren der Parameter.

Gruss
Vincent

-----------------------------------------------------------------------------



Re: Lernen (Jasper, 31. Jul 1998, 11:54:56):
~#! rn=Vincent rt=901875141 rg=gilden.zauberer
~#! tid=901875141
evtl. ist 'sehr befriedigend' im zauberspruch licht, das maximum fuer deinen
jetzigen gildenlevel.

Gruntz kann auch zaubern

-----------------------------------------------------------------------------



Re: Re: Lernen (Lyra, 31. Jul 1998, 11:55:53):
~#! rn=Jasper rt=901878896 rg=gilden.zauberer
~#! tid=901875141
Dann bekommst Du aber auch die Meldung, dass man aus seinen Fehlern nichts
mehr lernen kann.

Lyra, schreibt fuer Obermotz

-----------------------------------------------------------------------------



Re^3: Lernen (Silvana, 31. Jul 1998, 12:38:50):
~#! rn=Lyra rt=901878953 rg=gilden.zauberer
~#! tid=901875141
Genau diese Meldung bekommt man NICHT mehr. Ich denk, die bau ich dann
doch mal wieder ein, muss aber erst mal sehen, wie. Das also heute Abend.

  Silvana

-----------------------------------------------------------------------------



Ein gute, eine schlechte Nachricht... (Silvana, 31. Jul 1998, 18:19:36):
Hoi, gibt was neues zum Lernen.

1) Ich hab den Fehler gefunden, wieso hand und schutz so schlecht zu
   lernen waren. Schon erstaunlich, was so ein kleines ! ausmachen kann... :)
2) Ein paar der Hellsichtsprueche sind nun auch nur bei sinnvoller
   Anwendung zu ueben...

  Silvana
PS: Wieso Birdy ploetzlich nicht mehr ueberall MaxSkills hat, kann
    ich allerdings beim besten Willen weder verstehen noch reproduzieren.
    Sollte also jemand, OHNE seine Gildenstufe verwaendert zu haben, bei
    Llystrathe ploetzlich schlechter dastehen, bitte sofort melden!

-----------------------------------------------------------------------------



Licht :) (Pake, 31. Jul 1998, 18:49:38):
Lustigerweise ist gerade Licht der Spruch, den ich in den vergangenen
Spielstunden am meisten verbessert habe (da ich Licht aus fuer Nachtsicht
benoetigte):
von "gut" auf "aussergewoehnlich gut" :)))

Pake (der findet, dass _das_ so bleiben kann :))

-----------------------------------------------------------------------------



Licht :) (Pake, 31. Jul 1998, 18:50:45):
Lustigerweise ist gerade Licht der Spruch, den ich in der vergangenen
Spielstunden am meisten durch Erfolg verbessert habe (da ich Licht aus fuer
Nachtsicht benoetigte):
von "gut" auf "aussergewoehnlich gut" :)))

Pake (der findet, dass _das_ so bleiben kann :))

-----------------------------------------------------------------------------



Hand (Silvana,  5. Aug 1998, 01:45:21):
Hi.

Da seit der letzten Umstellung die Staerke des Angriffs mit 
blosser Hand in die Staerke von Hand staerker eingeht, ist ein alter Bug
sehr deutlich geworden: Es gibt offenbar Objekte, die die Wirkung von 
blossen Haenden _heftig_ steigern. Diese haben ab sofort keine Wirkung
mehr auf den Hand-Spruch. Will sagen: StandardMonster mit hand 2mal die
Runde atomisieren ist nicht mehr.

  Silvana

-----------------------------------------------------------------------------



Re: Hand (Asmodis,  5. Aug 1998, 07:15:37):
~#! rn=Silvana rt=902274321 rg=gilden.zauberer
~#! tid=902274321
Ich muss sagen, Silvana versteht ihr Handwerk :-)

-----------------------------------------------------------------------------



Re: Hand (Songoku,  5. Aug 1998, 10:12:42):
~#! rn=Silvana rt=902274321 rg=gilden.zauberer
~#! tid=902274321
Und welche Gegenstaende sind das?

-----------------------------------------------------------------------------



Und weiter gehts (Silvana,  5. Aug 1998, 20:26:13):
Hi.

So, fuenfte Runde.
Folgendes ist heute geaendert worden:

1) Die Schadensmeldungen von Giftpfeil sind ueberarbeitet. Folgende
   Meldungen koennen kommen (in der Reihenfolg der Schadensstaerke):

     "Silvana schiesst einen Giftpfeil auf den Boden.", 
     "Silvana kratzt Dich mit einem Giftpfeil.", 
     "Silvana trifft Dich mit einem Giftpfeil.", 
     "Silvana trifft Dich mit einem Giftpfeil. Dir wird schlecht.",
     "Silvanas Giftpfeil laesst Dich gruen anlaufen.",
     "Silvanas Giftpfeil laesst Dich taumeln.", 
     "Silvana durchbohrt Dich mit einem Giftpfeil.", 
     "Silvanas Giftpfeil laesst Dich fiebrig gluehen.", 
     "Silvana trifft Dich mit einem Giftpfeil mitten ins Herz.",

  Alle Meldungen sind natuerlich aus Sicht des Opfers. :)

2) ALLE Sprueche, bei denen die Staerke der Wirkung von der Guete des
   Erfolgs abhaengt, wurden in ihrer 'normalen' Wirkung reduziert.
   Allerdings gibt es fuer die meisten dieser Sprueche Ruestungsteile,
   die den Zauberer bei den jeweiligen Spruechen unterstuetzen. Nach
   folgenden Ruestungsteilen solltet ihr Ausschau halten:
     fuer Angriffssprueche   : Ringe
     fuer Abwehrsprueche     : Panzer
     fuer Illusionsmagie     : Umhaenge
     fuer Beherrschungsmagie : Ringe
     fuer Hellsichtmagie     : Amulette
     fuer Verwandlungszauber : Amulette
   Mit 'schaetz <ruestung>' bekommt ihr zudem auch Informationen, bei 
   welchen Zaubern Euch welche Ruestung wie stark unterstuetzt. Wer
   den Spruch noch nicht beherrscht, muss dafuer zu Randar Tobis
   laufen und ihm die Ruestung geben. (Sorry, aber die Lehrjahre SIND
   hart und ungerecht...) Bevor ihr jetzt Kaempfer-Like Ruestungs-
   Wechsel-Skripts schreibst ein Hinweis: Die Magie der Ruestungen 
   muss sich erst mal der Euren anpassen. Der Unterstuetzungseffekt
   nimmt daher in den ersten 15sec des Tragens linear zu. Um die
   Unterstuetzung der Ruestung einzuschaetzen muss man sie natuerlich
   NICHT erst 15sec tragen. :) Die Einschaetzungen erfolgen nicht 
   linear, aber in folgender Reihenfolge:
     "nur minimal."
     "ein bisschen."
     "sehr maessig."
     "maessig."
     "halbwegs anstaendig."
     "recht gut."
     "sehr gut."
     "extrem gut."
     "unglaublich gut."
     "einmalig gut."

   Das ganze ist noch im Aufbau. Anfangs werden sicher noch jede Menge
   Ruestungsteile fehlen. Wenn ihr also Vorschlaege habt, was sinnvoll
   wobei unterstuetzen sollte/koennte, immer her damit - moeglichst
   aber gesammelt. :) Aber immer dran denken: NUR die oben genannten
   Ruestungsteile, also NUR Ringe fuer Angriffssprueche, etc!

3) Ruestungsteil: Panzer
   Da es ziemlich sinnlos ist, Panzer zu haben, die zwar den Spruch
   unterstuetzen, aber dann beim Zaubern behindern, behindern die 
   Panzer, bei denen man beim Einschaetzen (respektive Randar Tobis)
   festgestellt hat, dass sie Zauber unterstuetzen, nicht mehr. Man 
   MUSS (!) sie dafuer aber zumindest einmal eingeschaetzt haben!
   Dass aus eben diesem Grund keine auch nur annaehernd Max-Panzer
   Schutzsprueche unterstuetzen, sollte auch klar sein.

    Silvana (macht morgen weiter)

PS: Ich werde jetzt mit dem Eintragen von Ruestungen in den Master 
    beginnen, also bitte etwas Geduld, das ist etwas aufwaendig.
    Bevor ihr mir Ruestungsteile vorschlagt, guckt doch bitte nach,
    ob sie vielleicht schon Boni haben. Ein paar sind schon dabei.

-----------------------------------------------------------------------------



schaetz (Silvana,  5. Aug 1998, 23:33:36):
Mit schaetz ist derzeit etwas vorsicht geboten. Der Spruch geht naemlich
noch von den alten Schutz/Schutzhuellen-Staerken aus, was natuerlicj
etwas ueberzogene Werte liefert... :)

  Silvana

-----------------------------------------------------------------------------



Unterstuetzende Ruestungen (Silvana,  6. Aug 1998, 13:07:13):
Sorry, die Sache mit den Ruestungen hatte noch einen sehr kleinen,
aber sehr haesslichen Bug. Der sollte jetzt behoben sein.

   Silvanan . o O ("/&%"%"/ Vorzeichen!)

-----------------------------------------------------------------------------



hand-spell (Hood,  7. Aug 1998, 03:20:20):
da das besorgen von hand-komponenten beim skelett mit karatezweities
ausartete, hab ich mal die magieresistenzen des skelettzombies veraendert.
wie es veraendert wurde sollte man sich noch mal anschaun, wir haben
es zumindest getestet: es ist jetzt weitaus angenehmer fuer zauberer,
dort mal selbst hinzugehen.
(ich hab ihn selbst noch in der alten version zuvor gekillt und fand es
 einfach nur fuerchterlich schwer, ohne bugausnutzung :)

------
patryn

-----------------------------------------------------------------------------



hippe (Knurt, 11. Aug 1998, 06:03:01):
das kann ja wohl nicht angehen, das Hippe in das Pentagramm laeuft und es
leerraeumt, oder?
Geht das abzustellen, bitte?
Knurt

-----------------------------------------------------------------------------



Re: hippe (Aline, 11. Aug 1998, 10:04:45):
~#! rn=Knurt rt=902808181 rg=gilden.zauberer
~#! tid=902808181

Wie? Was? Hippe??
Wie kommt der ins Tal?
Wie in die Gilde?
Eingentlich benuzt Hippe doch nur Ausgaenge die sichtbar sind,
also wie kommt er dann ins Tal oder ins Pentagramm??

Aline (staunt nicht schlecht)

-----------------------------------------------------------------------------



Re: Re: hippe (Patryn, 11. Aug 1998, 10:50:19):
~#! rn=Aline rt=902822685 rg=gilden.zauberer
~#! tid=902808181
hippe verfolgt zeitweise spieler und taucht somit an allen moeglichen orten
auf. der typ ist echt nervig, vor allem, wenn er mitscriptet.

------
patryn

-----------------------------------------------------------------------------



Re^3: hippe (Nonne, 11. Aug 1998, 10:53:10):
~#! rn=Patryn rt=902825419 rg=gilden.zauberer
~#! tid=902808181
Sollen die Zauberer dich Hippe umhauen. Die kriegen soviele Komponenten
geschenkt, 'n bisschen koennen sie ja auch dafuer tun.

Nonne (zweizeilend)

-----------------------------------------------------------------------------



Zauberer sind friedlich ;) (Shorkan, 11. Aug 1998, 10:59:07):
Hiho
Da wir Zauberer ne friedliche Gilde sind hauen wir Hippe doch nicht gleich um.

Shorkan, der Bluemchenpfluecker schmarrend.

-----------------------------------------------------------------------------



Re: Zauberer sind friedlich ;) (Nonne, 11. Aug 1998, 11:55:28):
~#! rn=Shorkan rt=902825947 rg=gilden.zauberer
~#! tid=902825947
fuers bluemchenpfluecken brauchste keine komponente -> schmarrn

-----------------------------------------------------------------------------



Re^4: hippe (Bottom, 11. Aug 1998, 14:17:15):
~#! rn=Nonne rt=902825590 rg=gilden.zauberer
~#! tid=902808181

Urgs!
Bitee keinen Neid auf die Anhaenger eines Irrglaubens, Bruder Nonne!
Neid und Missgunst sind hoechst verachtenswerte Eigenschaften.
Moege Dich Lembold auf den Pfad der Tugend zurueckgeleiten!


-----------------------------------------------------------------------------



Re^5: hippe (Silvana, 11. Aug 1998, 18:19:59):
~#! rn=Bottom rt=902837835 rg=gilden.zauberer
~#! tid=902808181
Ich glaube kaum, dass Hippe sich noch mal dort sehen laesst...

  (Jemand)

-----------------------------------------------------------------------------



Re^6: hippe (Padreic, 11. Aug 1998, 21:38:19):
~#! rn=Silvana rt=902852399 rg=gilden.zauberer
~#! tid=902808181
Das glaub ich auch nicht, jedoch weil er ab jetzt keine Lust mehr hat Spieler
an solch langweilige Orte zu verfolgen... :)

                                    Padreic

-----------------------------------------------------------------------------



Re: hippe (Tarina, 12. Aug 1998, 01:27:42):
~#! rn=Knurt rt=902808181 rg=gilden.zauberer
~#! tid=902808181
Hippe verfolgt einen sogar in Seherhaeuser und greift sich dort Klamotten.
Ich habe selten so gestaunt.

Gruss,
Tarina

-----------------------------------------------------------------------------



urlaub (Patryn, 14. Aug 1998, 14:41:55):
hi zauberers

jetzt gehts also in den urlaub :)
fuer die naechsten 3 wochen oder so werde ich hier wohl nicht zu finden sein,
wer mich life bestaunen will, kann selbiges ja auf der party machen.
damit euch nicht zu lang wird, hab ich noch nen kleineres monster in
den drudenwald gestellt, der wuselt da irgendwie rum und will das
skelett etwas entlasten.

------
patryn

-----------------------------------------------------------------------------



anregung fuer zmessage (Therin, 16. Aug 1998, 04:31:12):

Wie waers, wenn das %FH Kommando den Typ der Hand (eis,saeure,feuer,feuer
"normal") anzeigen wuerde?

Nur so als Idee...

T.

-----------------------------------------------------------------------------



hand (Silvana, 20. Aug 1998, 21:57:18):
Ich habe gestern auf der Party ganz massive Beschwerden von Zauberern (!)
gehoert, dass die Komponenten fuer 'hand feuer' in Dutzend billiger
verschenkt und teilweise zum Stabaufladen benutzt werden. Eigentlich sollten
die _selten_ sein. Daher hab ich nach durchzaehlen der derzeit aktuell 
verfuegbaren Konponenten (ueber 1000) die Staerke des Spruches an die
Verfuegbarkeit angepasst. Sobald Patryn die Komponentenbeschaffung wieder in
normale Bahnen gelenkt hat, laesst sich das auch wieder aendern. :)

  Silvana

-----------------------------------------------------------------------------



Re: hand (Therin, 20. Aug 1998, 21:58:08):
~#! rn=Silvana rt=903643038 rg=gilden.zauberer
~#! tid=903643038
Verdammt, ich war mal wieder zur falschen Zeit eingeloggt. Mir hat keiner
sowas angeboten.

Therin schmollt

-----------------------------------------------------------------------------



Magisterrobe (Silvana, 20. Aug 1998, 22:25:02):
Im Zuge der Komponentenumbewertung hat es auch den Magisterguertel
getroffen. Der ist jetzt nach dem Crash nicht mehr sooo wertvoll...

  Silvana

-----------------------------------------------------------------------------



Zauberer jetzt wie Flasche leer (Therin, 21. Aug 1998, 00:47:00):
[Zauberer:Liliput faellt langsam vom Glauben ab. 00:42:04]
[Zauberer:Vincent] das klingt alles nicht sehr motivierend im moment. * seufz
[Zauberer:Anatol] Bei "3" jammern wir alle :) 00:42:52
[Zauberer:Anatol] 1 00:42:56
[Zauberer:Anatol] 2 00:43:00
[Zauberer:Therin jammert schonmal 00:43:00]
[Zauberer:Anatol] 3 00:43:02
[Zauberer:Matissen jammert 00:43:04]
[Zauberer:Therin] jammer! 00:43:04
[Zauberer:Rayek] jammer 00:43:04
[Zauberer:Anatol jammert. 00:43:08]
[Zauberer:Vincent] jammert 00:43:08
[Zauberer:MTV jammert 00:43:08]
[Zauberer:Seno] jammer! 00:43:12
[Zauberer:Matissen jammert nochmal 00:43:12]
[Zauberer:Anatol] Gut jetzt :) 00:43:16
[Zauberer:Fish] jammer 00:43:16
[Zauberer:Anatol] Jetzt sollen die Kaempfer nochmal sagen, wir Zauberer
[Zauberer:Anatol] wuerden nicht jammern ;) 00:43:34
[Zauberer:Vincent] hihi Geordi jammert auf dem falschen Kanal. ;-) 00:43:36
[Zauberer:Geordi] ok, jammere ich hier auch :(

T.

-----------------------------------------------------------------------------



Re: hand (Fish, 21. Aug 1998, 11:07:24):
~#! rn=Silvana rt=903643038 rg=gilden.zauberer
~#! tid=903643038
hi ... 
also ich hab noch keine flasche aus der naehe gesehen ...
desshalb frage ich mich :"Wo sind sie geblieben ..."
nu ja mal schaun 

fish

-----------------------------------------------------------------------------



53 (Xenon, 21. Aug 1998, 15:17:45):
~#! rn=Morgoth rt=901881771 rg=hardsoftware
~#! tid=901544376
Hi Silvana

Also ich kann dir erklaeren warum ich als Lev 8 Zauberer ein paar
Feuerwasserflaechschen dabei hatte.
Ich hab naehmlich einen netten Lev 22 Kaempfer gefragt ob er die mir mal
hohlen koenne.
Ich bin der Meinung das es wenig Sinn hat wenn Patryn da einen noch viel
schaerferen NPC hinstellt.
Nur den das Spieler mit niedrigeren Level nochmehr benachteiligt werden..
Warum muss schwer zu kriegen sein auch immer bedeuten starke NPCs umzuhaun
oder bloede Raetsel zu loesen?

Ansonsten haben mir die Aenderungen in der Gilde (vorallem mit den Ruestungen)
ganz gut gefallen.

Ach ja Silvana :) wie stehts mit dem Lernen? Findest du das wirklich unseren
Faehigkeiten angemessen?

Xenon

-----------------------------------------------------------------------------



Re: anregung fuer zmessage (Patryn, 21. Aug 1998, 15:28:18):
~#! rn=Therin rt=903234672 rg=gilden.zauberer
~#! tid=903234672
der vorschlag ist schon recht alt, nur zweifle ich noch an dessen sinn.
wenn ich eine hand einschalte, weiss ich fuer gewoehnlich, was ich da
gerade nutze, man sollte den stabreport wohl nicht unbedingt ueberfrachten.

------
patryn

-----------------------------------------------------------------------------



Re: hand (Patryn, 21. Aug 1998, 15:35:24):
~#! rn=Silvana rt=903643038 rg=gilden.zauberer
~#! tid=903643038
also bei mir hat sich bisher kein zauberer darueber beschwert und ich bin
im gegensatz zu silvana immerhin schon die ganze woche auf der party
ich kann deshalb derzeit schlecht nachvollziehen, ob sich nur wieder
irgendwer superwichtig machen wollte, oder ob es der tatsache entspricht.
immerhin ist es oftmals nutzbringend, sich an den zu wenden, der fuer
den bug (und solchiger waere es) auch wirklich verantwortlich ist.
danke also nochmal, unbekannter beschwerender zauberer...

------
patryn

-----------------------------------------------------------------------------



Ruestungen (Silvana, 21. Aug 1998, 22:19:01):
Hi.

Ruestungen, zweiter Anlauf:
Ich bin gerade dabei, die unterstuetzenden Ruestungen komplett zu
ueberarbeiten. Sinn der Uebung ist nicht primaer meine Telephonrechnung
ins unbezahlbare zu treiben, sondern 'Konzeptruestungen' zu schneidern. Also
Boni so zusammenzustellen, dass die Ruestungen fuer bestimmte Aufgaben
besonders gut geeignet sind. Ein Beispiel:

Fallbeispiel 6: Edler Ring fuer Angriffsmagister und andere 
Profilneurotiker (Einzelkampf, magisch gefuehrt)
(Gemeint ist der Anti-Feuer-Ring)
Konzept : Hol die Kiste mit den Edelsteinen raus, dann GIB IHM!
Angriffsmagister koennen dann mal so richtig um sich schlagen.
Schade dass das Feuerwalzen soviel Feuer haben, nix fuer nen
AFR :) "Hand"? Was ist "Hand"...?

Geben soll es Ruestungen natuerlich fuer verschiedene Zwecke, in verschiedenen
Staerken und Verbreitungsgraden etc. Well, I'm working on it.

  Silvana

PS: Dank an Nachtwind fuer nahezu endlos erscheinende Listen.
PPS: Ach ja, die Abstufungen der Einschaetzungen haben sich etwas geaendert.
     Ich denke, es ist so etwas aussagekraeftiger.

-----------------------------------------------------------------------------



Re: Ruestungen (Asmodis, 22. Aug 1998, 23:02:43):
~#! rn=Silvana rt=903730741 rg=gilden.zauberer
~#! tid=903730741
Hmm, eigentlich ein schlechtes Beispiel, gewhnlich sind Monster,
die Feuerschaden machen, auch gegen Feuer resistent.

-----------------------------------------------------------------------------



Re: Zauberer jetzt wie Flasche leer (Orktoeter, 27. Aug 1998, 15:18:46):
~#! rn=Therin rt=903653220 rg=gilden.zauberer
~#! tid=903653220
Also, wenn es vorher noch Zweifler gab..
spaetestens jetzt haben sich diese komischen Spitzhuete ja wohl entgueltig als
Warmduscher und Weicheier zu erkennen gegeben.

OrkT, Abenteurer.

-----------------------------------------------------------------------------



Tja, Titel... Weiss nicht... Egal. :) (Silvana, 28. Aug 1998, 01:34:22):
Tja, was gibts neues?

Zum einen ist die Hand jetzt _voellig_ neu. Technisch vollkommen anders
und hoffentlich sogar schneller.
Zum anderen hat sich einiges an den Anforderungen getan. Ich hoffe, die
geaenderten Anforderungen passen besser in den Spielablauf und
unterstuetzen so das Lernen durch Anwendung. Wie werden sehen...

Und noch was: Die Lerngeschwindigkeit bei sehr selten zu lernenden 
Spells wurde angehoben (vor allem bei den Magisterspells).

Wille ist technisch auch etwas anders. Falls was schief geht, schlagt
Patryn. :)
Es gibt (wegen Hand) nen neuen Skill, der aber niemandem erscheinen sollte.
Sollte er doch mal auftauchen, bitte melden.

  Mehr faellt mir jetzt nicht ein....  Silvana

-----------------------------------------------------------------------------



Autokampf scheint zu buggen (Shorkan, 28. Aug 1998, 11:19:34):
Hiho

Also der Autokampf scheint mit dem neuen Zauberstab leicht zu buggen.
Ich habe -a blitz -v hand -s schutz
Deine Haende sind bereits irgendwie verzaubert. Diesen Spruch
hatte ich heute morgen des oefteren.
Dafuer habe ich aber keinen Blitz gesehen !!!

Shorkan

-----------------------------------------------------------------------------



Lernen (Silvana, 28. Aug 1998, 19:04:19):
Hi.

Es gibt eine kleine Neuigkeit beim Lernen von Schutzspruechen. Wenn
man einen gewissen Level ueberstiegen hat, lernt man sie durch
blosses Sprechen GAR NICHT mehr. Dafuer Lernt man aber, wenn man mit
dem aktivierten Spruch in einen Kampf mit einem angemessenen Gegner
geraet (einmal je Spruch).
Betroffen sind davon: schutz, schutzhuelle, zauberschild, vorahnung
und rueste. Natuerlich lernt man nur etwas, wenn man auch anwesend ist. :)

  Silvana

-----------------------------------------------------------------------------



Re: Re: Zauberer jetzt wie Flasche leer (Hardil, 31. Aug 1998, 11:47:16):
~#! rn=Orktoeter rt=904223926 rg=gilden.zauberer
~#! tid=903653220

Orktoeter schrieb:

>spaetestens jetzt haben sich diese komischen Spitzhuete ja wohl entgueltig
>als Warmduscher und Weicheier zu erkennen gegeben.

Aehem.
Ich wollte nur mal kurz nachfragen, wer das war, der bei der Party auf dem
Zeltplatz mit einem Regenschirm herumgelaufen ist?

-Hardil.

-----------------------------------------------------------------------------



no name (Patryn,  2. Sep 1998, 11:00:32):
hi ihrs

wille, hand und finde haben leicht veraenderte dokus erhalten.
(erstere beiden sind nur fuer birdy interessant wegen der seiten)

finde hat dabei auch zusaetzliche funktionalitaet erhalten, viel spass beim
austesten. (der tip mit den komps ist ernst zu nehmen)

------
patryn

-----------------------------------------------------------------------------



Heilsprueche (Seno,  4. Sep 1998, 18:04:45):
Hallo Zauberer!

Die Zauberergilde ist ne tolle Sache (trotz mancher Verschlechterungen in
letzter Zeit), aber irgendwie vermisse ich Heilsprueche. Ich vermute, das
kommt daher, dass die den Klerikern vorbehalten sind. Was ich auch nicht so
gelungen finde ist,  dass man Hellsicht- und Beherrschungssprueche
gleichermassen ueben und beherrschen soll, obwohl die einen einen (eher)
guten, die anderen einen (eher) boesen Charakter voraussetzen. Ich wuerde mich
gern irgendwann in meiner Zaubererlaufbahn fuer weisse oder dunkle Magie
entscheiden koennen, wobei ein Heil- und der Hellsichtzweig dann weissen, der
Beherrschungs- und ein "Beschwoerungszweig", mit dessen Spruechen man
aehnliche Ergebnisse wie mit Hellsicht erzielen kann, nur mit einer anderen
Magie, dann dunklen Magiern vorbehalten sein koennten (wobei sich letzteres
mit der Chaosgilde ueberschneidet (?), ich weiss nicht, inwieweit das ein
Problem ist).

Ich moechte diese Gedanken einfach mal zur Diskussion stellen und bin gespannt
auf Eure Reaktion.

Seno

-----------------------------------------------------------------------------



Re: Heilsprueche (Gloinson,  4. Sep 1998, 18:12:55):
~#! rn=Seno rt=904925085 rg=gilden.zauberer
~#! tid=904925085
Zauberer, die sich auf Heilung verlegen? Ich glaube, dass Zauberer Magie viel
zu abstrakt sehen, als dass sie sich mit den Koerpern anderer Rassen in
diesem Sinne beschaeftigen wuerden. Die von Zauberern praktisch benutzte
Magie entspringt doch meist der Forschung auf dem Feld der Magie selbst,
oder?

Gloin

-----------------------------------------------------------------------------



Re: Re: Heilsprueche (Seno,  4. Sep 1998, 20:11:05):
~#! rn=Gloinson rt=904925575 rg=gilden.zauberer
~#! tid=904925085
Hallo Gloin!

Ja, da ist was dran. Aber es gibt auch rausch, giftpfeil, verletze. Ein
denkbarer Heilspruch koennte auch Lebensenergie in magische umwandeln, ... Es
ist vieles denkbar.

Seno

-----------------------------------------------------------------------------



Re: Heilsprueche (Patryn,  7. Sep 1998, 17:10:37):
~#! rn=Seno rt=904925085 rg=gilden.zauberer
~#! tid=904925085
ein schwarzmagie- und weissmagiezweig sind im aufbau und entsprechen
wietestgehend deinen vorstellungen. das dauert aber noch ne ganze weile,
bis die drankommen...ueb erstmal die anderen spells hoch ;)

------
patryn

-----------------------------------------------------------------------------



Re: Re: Heilsprueche (Mensana,  7. Sep 1998, 17:50:41):
~#! rn=Patryn rt=905181037 rg=gilden.zauberer
~#! tid=904925085
Wie? Ueben geht wieder?

Mensana *ganz unglaeubig*

-----------------------------------------------------------------------------



Re: Heilsprueche (Jasper,  8. Sep 1998, 09:55:38):
~#! rn=Seno rt=904925085 rg=gilden.zauberer
~#! tid=904925085
*rotfl*

-----------------------------------------------------------------------------



jaaaa dafuer zauberer muessen sich fuer einen zweig entscheiden und koennen anschliessend nur noch haelfte aller sprueche. wuerde ich mal annaeherung an kampfkraft anderen gilden nennen. gute idee und kamvon einem zauberer? oder habe ich was falsch verstanden... (Nonne,  8. Sep 1998, 10:48:00):
~#! rn=Jasper rt=905241338 rg=gilden.zauberer
~#! tid=904925085

Nonne

-----------------------------------------------------------------------------



Re: jaaaa dafuer zauberer muessen sich fuer einen zweig entscheiden und koennen anschliessend nur noch haelfte aller sprueche. wuerde ich mal annaeherung an kampfkraft anderen gilden nennen. gute idee und kamvon einem zauberer? oder habe ich was falsch verstanden... (Nonne,  8. Sep 1998, 10:48:56):
~#! rn=Nonne rt=905244480 rg=gilden.zauberer
~#! tid=904925085
mmpf
das mit dem artikel schreiben klappte auch mal besser...

-----------------------------------------------------------------------------



Re: Re: Heilsprueche (Seno,  8. Sep 1998, 20:26:02):
~#! rn=Patryn rt=905181037 rg=gilden.zauberer
~#! tid=904925085
Ist ja Klasse! :) Da macht das Ueben ja schon FAST wieder Spass! ;)

Seno

-----------------------------------------------------------------------------



Re: Re: jaaaa dafuer zauberer muessen sich fuer einen zweig entscheiden und koennen anschliessend nur noch haelfte aller sprueche. wuerde ich mal annaeherung an kampfkraft anderen gilden nennen. gute idee und kamvon einem zauberer? oder habe ich was falsch verstanden... (Grimmborn, 10. Sep 1998, 15:17:31):
~#! rn=Nonne rt=905244536 rg=gilden.zauberer
~#! tid=904925085
Jetzt ist nur die Frage: Liegts an der mpa oder liegts an Dir? 

Grimmborn der Atheist

-----------------------------------------------------------------------------



Re^3: jaaaa dafuer zauberer muessen sich fuer einen zweig entscheiden und koennen anschliessend nur noch haelfte aller sprueche. wuerde ich mal annaeherung an kampfkraft anderen gilden nennen. gute idee und kamvon einem zauberer? oder habe ich was falsch verstanden... (Gando, 10. Sep 1998, 15:19:14):
~#! rn=Grimmborn rt=905433451 rg=gilden.zauberer
~#! tid=904925085
. "" vor diesem satz wollte ich einfach mal n Re: sehen ;)
Gando

-----------------------------------------------------------------------------



Re^3: jaaaa dafuer zauberer muessen sich fuer einen zweig entscheiden und koennen anschliessend nur noch haelfte aller sprueche. wuerde ich mal annaeherung an kampfkraft anderen gilden nennen. gute idee und kamvon einem zauberer? oder habe ich was falsch verstanden... (Patryn, 13. Sep 1998, 18:48:59):
~#! rn=Grimmborn rt=905433451 rg=gilden.zauberer
~#! tid=904925085
die naechste frage koennte lauten: meintest du den inhalt (zweifelhaft) oder
                                   die form (fragwuerdig)?

------
patryn

-----------------------------------------------------------------------------



aenderungen (Patryn, 17. Sep 1998, 02:28:27):
wille hat jetzt ne art blacklist, schnellhaerter und schuettelbier wird
nicht mehr weggefangen, aber ersteres objekt scheint eh zu spinnen.

portal-teleport, man kann nu durch die dinger durchschaun:
 schau durch portal, ist aber evtl. auch unsicher, wenn der zauber
schiefging

befehle mit richtungsangaben, wie schutzzone, feuerwalze und wahrsagen-zeug
geht jetzt von para in para, nich in normal. war noch son bug.

------
patryn

-----------------------------------------------------------------------------



teleport (Patryn, 17. Sep 1998, 03:31:42):
alle defender eines zauberers werden absofort mit dem zauberer bei
einem fluchtteleport mitgerissen. das gilt also insbesondere fuer
die netten rueckendecker der kaempfergilde.
schutzzonen und so bleiben natuerlich, wo sie sind :)
ach ja: ignorieren kann man das gimmick auch:

 ignoriere teleport oder ignoriere teleport.zaubererId

na ja, mehr verraet wie ueblich die bibo der zauberer

------
patryn

-----------------------------------------------------------------------------



Re: teleport (Ringor, 17. Sep 1998, 09:29:47):
~#! rn=Patryn rt=905995902 rg=gilden.zauberer
~#! tid=905995902
Wirklich nette Idee eigentlich. 

Aber ich haette doch gerne noch ein "ignoriere fehlteleport". ;-)

Ringor. Will nicht in den Schacht "gerettet" werden. 

-----------------------------------------------------------------------------



Re: Re: teleport (Lyra, 17. Sep 1998, 09:31:27):
~#! rn=Ringor rt=906017387 rg=gilden.zauberer
~#! tid=905995902
Der Schacht ist doch nett. Weiss garnicht, wass Du da hasst ;-)

Lyra heute nicht ernst zu nehmen
,
,

-----------------------------------------------------------------------------



Re: teleport (Acrimon, 17. Sep 1998, 16:35:46):
~#! rn=Patryn rt=905995902 rg=gilden.zauberer
~#! tid=905995902
schreib das bitte auch in "hilfe ignoriere" rein, sonst weisz das wieder
keiner ...

Danke
Acrimon, der Rote Ritter

-----------------------------------------------------------------------------



Re: Re: teleport (Silvana, 17. Sep 1998, 20:27:04):
~#! rn=Acrimon rt=906042946 rg=gilden.zauberer
~#! tid=905995902
Done. Silvana (einzeilig)

-----------------------------------------------------------------------------



wille (Patryn, 22. Sep 1998, 20:10:48):
hi leute

die beschreibungen zu wille, observiere, todeszauber, zwingtanz, erzwingen,
schmerzen, befreide, entkraefte, observiere, bezaubere und irritiere
haben sich geaendert.
meist steht nur drin, dass wille jetzt halt auch alle
beherrschungsspells wegfaengt und noch bissel mehr.
entkraefte ist auch beherrschung, also dort muss man auch leiden :)
dann gabs noch viele kosmetische sachen, die kaum auffallen duerften, ausser
bei getriggerten sachen. wenn sich irgendwas zu sehr veraendert hat, dann
ist das nen bug: mir bitte melden :)

------
patryn

-----------------------------------------------------------------------------



Vorschlag (Lolli, 22. Sep 1998, 23:14:46):
ich haette mal nen vorschlag fuer die gilde. wie waere es wenn wir wie die
chaoten ein brett oder sonstwas haetten auf dem die Faehigkeiten
vergleichsweise angegeben werden. also wie gut man im vergleich zb zu
eingeloggten zauberern ist. bei zwer wird ja (meines wissens) nur die
spielerstufe beruecksichtigt.
waere mal ganz interessant zu wissen denke ich....

LOLLI  auch mal in die mpa schreibend

-----------------------------------------------------------------------------



Re: Vorschlag (Lug, 22. Sep 1998, 23:35:28):
~#! rn=Lolli rt=906498886 rg=gilden.zauberer
~#! tid=906498886
Tjae Lolli,

tut mir ja leid es Dir sagen zu muessen. Lass es doch auch gleich wieder ;)

LidKG
Lug

-----------------------------------------------------------------------------



komponenten (Patryn, 25. Sep 1998, 06:14:09):
hi zauberers

die komponentenabfrage kann jetzt ne ganze menge spielereien mehr und
dann musst ich doch gleich mal... :)

also die ganzkaraetigen edelsteine sollten jetzt im schnitt doppelt so
lange halten, wie die halbkaraetigen.

das zweite ist, dass ja silvana die wichtigeren ewigen komponenten
weghaben will...nun ja, das hab ich mal etwas abgewandelt:

der ewige rubin zerspringt bei ueberhitzung...test it :)
allerdings macht das keinen schaden, keine sorge.   . o O(trotz pa*-flag :)

------
patryn

-----------------------------------------------------------------------------



komponenten (Patryn, 28. Sep 1998, 12:11:43):
hi zauberers

ab sofort ist der durchschnittliche komponentenverbrauch nicht mehr
vom gildenlevel des casters abhaengig, sondern wird entsprechend
der faehigkeit des zur jeweiligen komponente gehoerigen spells ermittelt.
der bereich ist hierbei sehr gross! es lohnt sich also, auch spells auf
max zu lernen, wo dies bisher nicht so wichtig war.
anfaenger muessen sich umstellen und verstaerkt im mud komps suchen.

insgesamt gesehen ist aber auch fuer max-skill der komp.verbrauch leicht
gestiegen.

------
patryn

-----------------------------------------------------------------------------



gildenquest (Patryn, 30. Sep 1998, 19:21:22):
da ich mich gefuehlsmaessig gerade zwischen gefrustet und gelangweilt befand,
musste ich euch doch mal mit ner neuen zaubererquest nerven.
dabei geht es eigentlich nur darum, die gestellte aufgabenstellung zu
ueberleben, was bei einer gegnerschaft von 3 miteinander arbeinden npc's
wie ueblich nicht gar zu einfach sein sollte. allerdings gehoeren zu den
dreien schon 2 bekannte...nun ja, ihr werdet sehen.

------
patryn

-----------------------------------------------------------------------------



zaubererquests (Patryn, 30. Sep 1998, 21:32:03):
hi zauberers

und noch 2 weitere quests fuer die zauberer, dank an paracelsus.
es sind keine unbekannten mehr, aber um sie angezaehlt zu bekommen, muesst
ihr trotzdem noch mal ran, sofern ihr sie schon habt.

------
patryn

-----------------------------------------------------------------------------



Re: komponenten (Mensana,  5. Okt 1998, 13:57:47):
~#! rn=Patryn rt=906977503 rg=gilden.zauberer
~#! tid=906977503
Na ob das so gut ist, neulinge auf die Suche nach Komponenten zu schicken,
weiss ich nicht. Drakonien ist nicht gerade NewBe-freundlich.

Mensana

-----------------------------------------------------------------------------



hmm.. (Sirona,  5. Okt 1998, 14:02:22):
Mirror teilt Dir mit: argl alles stirbt :)
[Tod:Lars] Ein Bibliothekar hat gerade Mirror umgebracht.
[Tod:Ein Bibliothekar] Das geschieht einem Buchraeuber recht, Mirror!
- sirona -

-----------------------------------------------------------------------------



feuerballstaerke (Patryn,  7. Okt 1998, 14:16:20):
hi ihrs

da laufend leute nachfragen: feuerballstaerke heisst nun
angriffsstaerke. die zusatzfunktionalitaet hat nur vorbereitenden
charakter, bisher geht das nur fuer feuerball!

------
patryn

-----------------------------------------------------------------------------



Magisterposten (Tami, 17. Okt 1998, 21:37:40):
Huhu, ihr!
Sollte sich unter uns Zauberen ein Erstspieler befinden, der keinen
Magisterposten "abgekriegt" hat, dann kann er sich ja mal bei mir melden. Da
ich Zweitie bin will ich ja keine Magisterposten "besetzen"!;)

Ciao, Tami!

-----------------------------------------------------------------------------



Erschaffe (Anacrion,  3. Nov 1998, 21:28:59):
erschaffe n Haus
erschaffe n Haus
erschaffe n Haus
Hmmmmm. Also ich hab den Spruch jetzt so 300-400 mal gesprochen, wobei ich
geschlagene _4_ mal was gelernt habe (bei nem anfangsstand von SCHLECHT).

erschaffe n Haus
Ich finde, das koennte man ueberarbeiten ... so oft braucht man den spruch nun
nicht, dass der automatisch hochgehen wuerde ...

Anac*

-----------------------------------------------------------------------------



Re: Erschaffe (Hood,  3. Nov 1998, 21:30:30):
~#! rn=Anacrion rt=910128539 rg=gilden.zauberer
~#! tid=910128539
wozu musst du den spruch auf perfekt haben...296 bis 396 haeuser reichen
doch, oder?! ;)

------
patryn

-----------------------------------------------------------------------------



Re: Re: Erschaffe (Hood,  3. Nov 1998, 21:33:35):
~#! rn=Hood rt=910128630 rg=gilden.zauberer
~#! tid=910128539
Anacrion teilt Dir mit: hae ?
Anacrion teilt Dir mit: ich hab den jetzt auf aeusserst ungenuegend
Anacrion teilt Dir mit: und der ist mir bei nem spruchabstand von 20 sek in
Anacrion teilt Dir mit: den letzten 2 stunden maximal 7 mal MISSLUNGEN und aus
Anacrion teilt Dir mit: gelungenen lerne ich (noch?) nix :(
Thrainii ruft: hallo
Du teilst Anacrion mit: du hast also etwa 90 sekunden an deinem artikel
Du teilst Anacrion mit: geschrieben :)

-----
patryn grinst

-----------------------------------------------------------------------------



Re: Erschaffe (Jasper,  6. Nov 1998, 17:06:11):
~#! rn=Anacrion rt=910128539 rg=gilden.zauberer
~#! tid=910128539
versuch es malmit einem "!" vor deinen Triggern :P

-----------------------------------------------------------------------------



Re: Re: Erschaffe (Anacrion,  6. Nov 1998, 17:06:55):
~#! rn=Jasper rt=910371971 rg=gilden.zauberer
~#! tid=910128539
Ist kein Trigger .. nur /repeat .. schont die Fingerkuppen ;-P :)

Anac* - der Patryn gefragt hat und ja anwesend war :)

-----------------------------------------------------------------------------



Re^3: Erschaffe (Jasper,  6. Nov 1998, 17:10:34):
~#! rn=Anacrion rt=910372015 rg=gilden.zauberer
~#! tid=910128539
yo, aber ein /repeat -20 1000 !irgendwas
spammt dann nicht deine mails/news etc. mit den triggern voll :)

-----------------------------------------------------------------------------



Stirnreif (Anacrion, 18. Nov 1998, 02:54:37):
Hi auch :)
Ich wollte nur an dieser Stelle mitteilen, dass der Stirnreif des Ynakh
1.) Fuer Zauberer ohne Anpassung nicht zu tragen ist
2.) Bei Anpassung guer Finde destructet wird
3.) Nicht mehr nachgeclont wird

Anac* - seufzennd

P.S. Also destructen muss ja nicht sein, patryn, oder ? ;)

-----------------------------------------------------------------------------



Re: Stirnreif (Anatol, 18. Nov 1998, 05:10:40):
~#! rn=Anacrion rt=911357677 rg=gilden.zauberer
~#! tid=911357677
(a) Bitte trete aus der Akademie der Geistigen Kraft zu Taramis aus.
(b) Mache zuvor noch "spruchhilfe anpassung".
(c) "anpassung" vernichtete bei gedankenloser Anwendung schon immer die
    Zielruestung. Schon zu Silvanas Zeiten, jammer' also Patryn nich voll.
    Und ja, das trifft auch auf das von Dir erwaehnte Objekt zu. :o).
(d) _Natuerlich_ wird das Objekt nachgeclont. :-P
(e) Siehe (a). :o)

Mehr "multi", Anacrion, mehr "multi"....

Anatol


-----------------------------------------------------------------------------



Re: Re: Stirnreif (Anacrion, 18. Nov 1998, 12:43:03):
~#! rn=Anatol rt=911365840 rg=gilden.zauberer
~#! tid=911357677
Hmmmm.

Also ... scheint, dass der Reif doch nachgeclont wird. Komisch eigentlich.
Dass hiesse naemlich, dass da jemand in den 30 sek die zwischen Zerstoerung
und meinem Eintreffen beim Grab lagen, den Reif nicht nur genommen, sondern
auch nachher keinen Mucks gesagt hat (ohne Mucks angreifen zu wollen), 

Zum Zweiten war das ein Vorschlag, dass der Reif ja nicht unbedingt noch
bei 'finde' behindern muss ..... ist irgendwie dumm, wenn Uniques fuer
einzelne
Gilden unbenutzbar sind (und ich moechte hier nicht an die Waffen denken)

Anac* - denkt im uebrigen . o O (ignoriere news.anatol) ;)

-----------------------------------------------------------------------------



Re^3: Stirnreif (Anatol, 18. Nov 1998, 12:48:12):
~#! rn=Anacrion rt=911392983 rg=gilden.zauberer
~#! tid=911357677
Also zu fordern, dass Uniques fuer alle Gilden benutzbar sind, halte
ich irgendwie fuer sehr dreist - Uniques sind generell immer nur von
einem einzigen Spieler "gleichzeitig" (haha) benutzbar - und es sind
nicht die Annehmlichkeiten, die das Leben ausmachen, sondern eher die
Umstaende.

Des weiteren GLAUB'S mir einfach, dass der Reif nachgeclont wird, ich
habe da ausnahmsweise sogar selbst gewisse Erfahrungen gemacht.

Werd' Kaempfer! Oder noch besser: Lass' Deinen Zweitie Magier werden,
das ist gerade "in"...

Anatol :o)


-----------------------------------------------------------------------------



Re^4: Stirnreif (Anakin, 18. Nov 1998, 13:01:42):
~#! rn=Anatol rt=911393292 rg=gilden.zauberer
~#! tid=911357677

> Werd' Kaempfer! Oder noch besser: Lass' Deinen Zweitie Magier werden,
> das ist gerade "in"...

Och das ist doch schon lange in.

Anakin.

-----------------------------------------------------------------------------



Re: Stirnreif (Patryn, 18. Nov 1998, 13:06:15):
~#! rn=Anacrion rt=911357677 rg=gilden.zauberer
~#! tid=911357677
ich hab gluecklicherweise keine ahnung, wovon du redest. somit muss ich
daran natuerlich auch nichts aendern :)

------
patryn, arbeit von sich weisend

-----------------------------------------------------------------------------



Re^3: Stirnreif (Boing, 18. Nov 1998, 13:16:18):
~#! rn=Anacrion rt=911392983 rg=gilden.zauberer
~#! tid=911357677
Der Reif wird natuerlich nicht sofort beim destructen neu gecloned
sondern erst beim naechsten Reset. Das sollte eigentlich logisch sein.
  Boing

-----------------------------------------------------------------------------



Re^4: Stirnreif (Anacrion, 18. Nov 1998, 13:50:33):
~#! rn=Boing rt=911394978 rg=gilden.zauberer
~#! tid=911357677
+Aeh. lso ich hab schon bis zum naechsten Reset gewartet .. der muss ergo
innerhalb dieser 30 sek gewesen sein  ... sonst waere ich ja nie auf die
Schlussfolgerung, dass der nicht nachgeclont wird, gekommen ... das mit den 30
sek erschien mir reichlich unwahrscheinlich ..

Anac* - sich fuer die formatierung entschulkdigend.

-----------------------------------------------------------------------------



Re^5: Stirnreif (Dhojakt, 19. Nov 1998, 02:14:37):
~#! rn=Anacrion rt=911397033 rg=gilden.zauberer
~#! tid=911357677
Nach meinen beobachtungen taucht der reif erst wieder auf, wenn der raum
ausgeswappt war. Im raum warten nuetzt also nix, und toeter scheint nicht zur
abarbeitung seines repfiles zu kommen.
Khidar.

-----------------------------------------------------------------------------



Re^3: Stirnreif (Jiddu, 19. Nov 1998, 18:50:04):
~#! rn=Anacrion rt=911392983 rg=gilden.zauberer
~#! tid=911357677
ziehe reif aus; finde <name>; trage reif geht nicht ...?

-----------------------------------------------------------------------------



Re^4: Stirnreif (Anatol, 20. Nov 1998, 05:39:12):
~#! rn=Jiddu rt=911501404 rg=gilden.zauberer
~#! tid=911357677
Natuerlich wuerde das gehen. Aber haeltst Du das fuer sinnvoll? Es
reicht, wenn die Trves-Krieger zu Striptease-Kaempfern verkommen
sind, da muessen nicht auch noch die Zauberer mitmachen. Sieht auch
laengst nicht so elegant aus, eine Robe ist schnell abgeworfen, aber
so eine komplizierte Ruestung... o la la ;-)

Tellerrand, Jiddu, Tellerrand. Geh weiter Karate ueben.

Anatol


-----------------------------------------------------------------------------



Re^5: Stirnreif (Jiddu, 20. Nov 1998, 23:33:42):
~#! rn=Anatol rt=911540352 rg=gilden.zauberer
~#! tid=911357677
Fuer manche hier muss ich wohl doch ironie-flags setzen?!

-----------------------------------------------------------------------------



Re^6: Stirnreif (Anatol, 20. Nov 1998, 23:38:00):
~#! rn=Jiddu rt=911604822 rg=gilden.zauberer
~#! tid=911357677
Nein, wirf einfach Deine MPA weg.

Anatol - hilft gerne.


-----------------------------------------------------------------------------



Portal (Patryn, 23. Nov 1998, 23:28:59):
hi leute

padreic nervte mich mal wieder, und so musste ich mal am portal herumfummeln.
wenn man es durchschreitet, dann bestimmt das zielportal ueber die welt, in
der man sich fortan befindet. wem das syntaktisch nicht einleuchtet, der wird
sicher life seine erfahrungen damit sammeln...

------
patryn

-----------------------------------------------------------------------------



Re: Portal (Morgoth, 23. Nov 1998, 23:30:02):
~#! rn=Patryn rt=911863739 rg=gilden.zauberer
~#! tid=911863739
heisst das nicht 'fortRan' ?? 

M* ;-)

-----------------------------------------------------------------------------



Re: Re: Portal (Hasim, 24. Nov 1998, 15:58:46):
~#! rn=Morgoth rt=911863802 rg=gilden.zauberer
~#! tid=911863739
Wir haben jetzt ein Portal???
Oder meinst du den teleport?
Hasim, der Zeit hinterher...

-----------------------------------------------------------------------------



zauberstab (Patryn, 30. Nov 1998, 17:19:04):
hey ihrs

hin und wieder kam es zu dem problem, dass zauberer mit frisch erworbenem
stab keine stabmagiepunkte hochidelten oder angriffsspells nicht hutzen
konnten. das sollte nun behoben sein, allerdings kommt es mit dem alten
zauberstab jetzt zu bugs, wenn man bestimmte sachen nutzen moechte.
das besorgen eines neuen stabes hilft hierbei ungemein...mir ist leider
kein workaround eingefallen und irgendwie verliess mich auch die lust nach
3 sekunden des nachdenkens betreffs dieses themas.

------
patryn

-----------------------------------------------------------------------------



noch mal der zauberstab (Patryn, 30. Nov 1998, 17:52:03):
irgendwie hat der allbekannte vorschlag: 'hey, wie waers wenn man den
 zauberstab leichter erneuern koennte!' mich inzwischen zum
neunhundertundneuundneuzigsten mal erreicht und erwarb damit das recht,
wohlwollend von mir als zusaetzlicher service in betracht gezogen zu werden.
ein einfaches 'teile llystrathe mit zauberstab' oder
auch 'frage llystrathe nach zauberstab' sollte dies zukuenftig automatisch
erledigen.

------
patryn fuehlte sich durch gleichleutende mails bedraengt :)

-----------------------------------------------------------------------------



Re: noch mal der zauberstab (Patryn, 30. Nov 1998, 23:47:23):
~#! rn=Patryn rt=912448323 rg=gilden.zauberer
~#! tid=912448323
ja ja, ich weiss: bevor das richtig klappt muss man noch mal nach der
herkoemmlichen methode... :)
nich das ich noch 10 mails ueber duplizierte staebe erhalte: eigentlich
bin ich fuer einen spontanen reboot, das beruhigt die lage ungemein.
zum einen sind alle leute zu sehr beschaeftigt, um mir
inhaltsidentische mails an den kopf zu werfen und zum anderen waeren die
mails auch dieses inhalts beraubt :)

------
patryn

-----------------------------------------------------------------------------



Schreibfaulheit unter Zauberern (Birdy, 16. Dez 1998, 18:23:10):
Hiho !

Wieder einmal bestaetigt sich das Geruecht, dass Zauberer weltfremd und
praxisfern leben.
Unsere Rubrik sollte eigentlich angefuellt sein mit theoretischen Diskussionen
ueber die Wirkungsweisen von Zauberspruechen, aber was is ? Nix !
Ausserdem moechte ich, wo ich grad beim schreiben bin, darauf hinweisen, dass
sich aanscheinend noch niemand mit der Programmierung der Erzmagister
beschaeftigt.
Vielleicht waere es gut, einen Wttbewerb auszuschreiben oder einfach wieder
die alten zu nehmen, bis was Neues kommt.
Ich finds jedenfalls ziemlich deprimierend und die Motivation innerhalb der
Gilde geht bei mir langsam aber sicher den Bach runter.

Aber genau wie letztes Jahr und ich glaub das Jahr davor auch, kann ich dazu
sagen: "Kommt Zeit kommt Rat." oder "Eile mit Weile" oder "Immer cool
bleiben.".
Wohingegen ich mir dann natuerlich auch sarkastischerweise denke: "Was Du
heute kannst besorgen, das verschieben NICHT auf morgen." (neine ich will
nicht magier werden) ...
Ich seh grad, dass meine Sauklaue mal wieder zugeschlagen hat. :)

Morgen will ich mind. 20 Replys auf meinen Artikel haben, natuerlich zaehl ich
nur die, die von Zauberern kommen, besonders natuerlich von unseren
Gildenmagiern. :)

Birdy

-----------------------------------------------------------------------------



Re: Schreibfaulheit unter Zauberern (Zillus, 16. Dez 1998, 18:26:34):
~#! rn=Birdy rt=913832590 rg=gilden.zauberer
~#! tid=913832590
Reply Nr. 1. (Bin zwar kein Zauberer, und werde auch keiner ;) )

Wann gibt es ein Seherportal im Coronertal :) ?

zillus.

-----------------------------------------------------------------------------



Re: Re: Schreibfaulheit unter Zauberern (Astar, 16. Dez 1998, 18:30:31):
~#! rn=Zillus rt=913832794 rg=gilden.zauberer
~#! tid=913832590
Hmm, da faellt mir nur noch dieser dumme Witz ein:

Treffen sich zwei Zauberer, sagt der eine: Taramis.
Darauf der Andere: Erzmagister.

Astar (ex-Zauberer)

-----------------------------------------------------------------------------



Re^3: Schreibfaulheit unter Zauberern (Sharia, 16. Dez 1998, 18:31:43):
~#! rn=Astar rt=913833031 rg=gilden.zauberer
~#! tid=913832590
BRUELL !!! DER IS GENIAL :-)

Sharia

-----------------------------------------------------------------------------



Re^4: Schreibfaulheit unter Zauberern (Anacrion, 16. Dez 1998, 19:33:53):
~#! rn=Sharia rt=913833103 rg=gilden.zauberer
~#! tid=913832590
Alos ich hab alle Gildenmags schon nach besten Kraeften genervt mit derartigen
Witzzen :)

Aber deren Schreibfaulheit uebertrifft meine wohl noch bei weitem.
Auch ich habe Patryn vorgeschlagen, die alten Erzmagister anzuhaengen, bis was
neues da ist, die Antwort war:
'Das muss Silvana machen, ich habs nicht abgehaengt' ...
Ich persoenlich habe auch schon darauf hingewiesen, dass es durchaus schoen
waere, wenn hand vor dem Kampf auszusprechen waere (wie andernorts weihe auch)
...
Na ja ... bleibt zu sagen:
1.) Da wohl in naechster Zeit niemand irgendwas fuer die Erzmagister tun wird,
heisst es wohl, dass Silvana der Gilde den Kopf genommen und sich mehr oder
weniger ueber die Abstimmung hinweggesetzt hat (oder so)
2.) Das die Vergabe der MAgisterposten mehr oder weniger von
Verhandlungsgeschick abhaengt und nicht von Ahnung
3.) Das sich an unser3er Gilde nicht mehr soviel aendert, solange kein nicht
nur kompetenter s0ndern auch extrem Arbeitswuetiger Mag mal was proggt

Amen.


Anac*
P.S. Entschuldigt alle typos und ungereimtheiten, musste alles blind tippen
...

-----------------------------------------------------------------------------



Re^5: Schreibfaulheit unter Zauberern (Anatol, 16. Dez 1998, 19:37:17):
~#! rn=Anacrion rt=913836833 rg=gilden.zauberer
~#! tid=913832590
Die Motivation eines Gildenmagiers wird nicht unbedingt groesser, wenn
ihn 50'000 Spieler regelmaessig anmailen und rumdraengeln. Solange es
Spieler gibt, die Gildenstaerke mit Spielspass verwechseln, nehme ich es 
KEINEM echten Gildenmagier uebel, wenn er den Stift ruhen laesst.

Anatol - kam sich als Magister (zweiglos) nie wirklich schwach vor


-----------------------------------------------------------------------------



Re^6: Schreibfaulheit unter Zauberern (Anacrion, 16. Dez 1998, 19:41:49):
~#! rn=Anatol rt=913837037 rg=gilden.zauberer
~#! tid=913832590
Hmm. Anac* die 2te :)

1:0 fuer Dich. Ich stimme Dir in fast allen Puinkte zu.
Fast ? Ja Fast.

Es geht naemlich meiner Meinung nicht darum, die Gildenstaerke zu erhohen,
oder hab ich was falsch verstanden, es geht doch eher darum, dass
1. Die Erzmagister wieder angehaengt werden, was sie schon laengst sein
sollten. Leider gibt es da auch ein Problem, da die Gilde von Silvana ist und
Patryn nicht ganz das machen kann, was er will
2. Ein bisschen mehr Farbe in die Gilde kommt ...

Anac* - wuerde selber proggen, aber er will jan noch nen limitierten Posten
haben, ausserdem zu viel FPs sammeln und will ohnehin kein MAgierzweitie
werden ...


-----------------------------------------------------------------------------



Re^7: Schreibfaulheit unter Zauberern (Patryn, 16. Dez 1998, 21:11:52):
~#! rn=Anacrion rt=913837309 rg=gilden.zauberer
~#! tid=913832590
Hi Leute...

Es gibt derzeit ein paar Punkte in der Gilde, bei denen ich einen gewissen
Frustfaktor nicht wegreden kann. Nur allzubekannt sind die Probleme fuer
derzeitige Anfaenger in der Gilde (insbesondere das Lernen) oder auch die
recht statische Besetzung von Magisterposten bzw. das Nichtvorhandensein der
Erzmagister.
Nun kam hier ein paar mal der Anschein auf, dass Silvana mehr oder weniger
daran Schuld sei, da Sie ja nach Ihrem Abtritt noch mehrere Sachen gemacht
hat oder sie mir bei irgendetwas reingeredet haette. Dieser Meinung kann ich
mich nun ganz und gar nicht anschliessen und ich sollte es am besten
wissen. Sicher ist, dass Silvana in der Gilde Vetorecht hat, aber dass
geniesst Sie nunmehr durch den Balanceposten eh in jeder Gilde. Bis jetzt
hat das noch nirgendwo behindert. Sicher ist auch, dass die Gilde nicht eben
klein ist und Silvana als fruehere Gildenchefin natuerlich die
willkommendste Hilfe darstellt und ja auch einiges getan hat.
Es ist nunmal eine Tatsache, dass das Projekt Magister/Erzmagister-Pruefung
den Umfang einer Quest haben duerfte, wofuer wir beide derzeit nicht die
noetigen Resourcen aufbringen koennen. Ein Wiederanschliessen der Arena
steht nicht zur Debatte, und das ist nicht Silvanas alleinige Meinung. Ich
selbst habe damals genug lustige Kaempfe dort bestritten, bei denen ich per
einzelnem Tastendruck gewann und noch volle Magiepunkte hatte. Das ist
allgemeines Arenaproblem und kann konzeptionell einfach nicht beseitigt
werden.
Zum Lernproblem sei erwaehnt, dass Silvana daran arbeitet, derzeit aber
leider auch verhindert ist. Ich selbst muesste mich dort erst reinarbeiten,
was ich bisher scheute.
Es ist einfach ein riesen Zeitproblem. Keiner haelt Euch davon ab, mich
anzusprechen, um mir etwas Arbeit abzunehmen: Raeume beschreiben kann jeder,
wenn er sich halbwegs Muehe gibt und wer noch besser proggen kann, der darf
sich auch durchaus an sortierte Magisterguertel oder aehnlichen
Schnickschnack rantrauen: Ueberprueft und kopiert ist sowas schnell.
Selbst die Zaubererdoku...immer noch sind viele Fundstellen undokumentiert
oder Komponenten gar kaum erwaehnt. Bisher hat mich noch nie Jemand
angesprochen, ob denn da mal was in private Hand genommen werden koenne.
Es ist eben leicht, die Schuld bei anderen zu suchen...
Die ebenfalls umgehende Meinung, bei uns in der Gilde wuerde nix gemacht,
kann ich nun gar nicht mehr nachvollziehen. Viele Erweiterungen will man
hier gar nicht so oeffentlich diskutieren, da sich dann gleich tausend
Nichtzauberer aufregen: Nur bei uns scheint es keinen zu interessieren.
Es ist halt da und fertig, nettes Feature: Aber Monster kann ich damit immer
noch nicht zappen. Echt super.
Wie gesagt: Bringt Euch selbst ein, es muss ja nichts supertechnisches sein,
was Euch den Spielspass verdirbt. Details und Doku hilft schon enorm. Ich
bin in dieser Hinsicht jederzeit ansprechbar.
Eventuell bekommen dann manche Leute hier mal ein Gefuehl dafuer, wieviel
Zeit in vielen Dingen hier steckt. Ich selbst erwische mich ja auch immer
wieder, eine Woche fuer etwas zu veranschlagen, was locker mal einen Monat
braucht.

------
Patryn

-----------------------------------------------------------------------------



Re^7: Schreibfaulheit unter Zauberern (Neb, 16. Dez 1998, 21:36:16):
~#! rn=Anacrion rt=913837309 rg=gilden.zauberer
~#! tid=913832590
Ich bin ja mal gespannt, was Du fuer Erzmagisterposten angehaengt haben
moechtest, _ohne_ dass das eine Aufwertung der Zauberer bedeutet, Anacrion.
Koenntest Du das nochmal genauer erklaeren, bitte ? ;)

-----------------------------------------------------------------------------



Re^5: Schreibfaulheit unter Zauberern (Nonne, 17. Dez 1998, 09:29:18):
~#! rn=Anacrion rt=913836833 rg=gilden.zauberer
~#! tid=913832590
Du willst nicht ernsthaft weihe mit hand vergleichen?!?!? na gut, dann will
ich aber auch weihe mit element-schadensarten. weihe-feuer, weihe-saeure,
weihe-eis.
Obacht KATAKOMBEN, ich komme! hihi

Nonne.

-----------------------------------------------------------------------------



Re^6: Schreibfaulheit unter Zauberern (Jiddu, 18. Dez 1998, 19:19:32):
~#! rn=Nonne rt=913886958 rg=gilden.zauberer
~#! tid=913832590
Oder weihe mit chaosschaden ...
Jiddu->kurz()

-----------------------------------------------------------------------------



Neues Feature :( (Xenon, 24. Dez 1998, 12:32:41):
Kleine Traurige Weihnachtsueberraschung an Euch, Zaubies sind zu
Selbstzerstoerern mutiert:(.

Das passiert jetzt bei mir zur Zeit bei jedem Feuerball:

LP190 MP178 Stab47 Schutzart:s Hand:F XHand:X Wille:  Gift:N
Du laesst eine mittlere Kugel aus Feuer entstehen.
Du schleuderst die Kugel in des Eisriesen Richtung.
Dein Feuerball verbrennt den Eisriesen fast zu Asche.
Als die Kugel explodiert, trifft sie auch Dich.
Xenons Feuerball roestet Dich russig schwarz.
Dein Feuerball roestet Xenon russig schwarz.
LP137 MP178 Stab47 Schutzart:s Hand:F XHand:X Wille:  Gift:N

Xenon, ganz traurig.

-----------------------------------------------------------------------------



Re: Neues Feature :( (Patryn, 27. Dez 1998, 22:24:52):
~#! rn=Xenon rt=914502761 rg=gilden.zauberer
~#! tid=914502761
also es sollte nun wieder gehen...hat sich irgendwie mit den teamerweiterungen
eingeschlichen. hatte ja gar nix dran gemacht.
feinde fuer feuerball werden jetzt gleich mal anders ausgesucht:
  der kleine feuerball erwischt wirklich nur noch einen gegner
   (wie schon immer geplant)
  die anderen versionen je nach groesse und level dementsprechend mehr,
  allerdings jetzt auch sehr viel sicherer als zuvor.

------
patryn

-----------------------------------------------------------------------------



Re: Re: Neues Feature :( (Patryn, 28. Dez 1998, 10:18:25):
~#! rn=Patryn rt=914797492 rg=gilden.zauberer
~#! tid=914502761
also es geht leider doch noch nicht so ganz.
die betreffende mudlib-funktion, die wegen teamkampfes geaendert wurde,
tut nicht mehr im entferntesten das, was sie frueher mal getan hat.
bevor ich das bei mir aendere, spreche ich noch mal mit den
verantwortlichen leuten: ich glaube kaum, dass dies beabsichtigt war.
es duerfte durchaus auch querschlaeger bei anderen gilden geben,
sofern diese ebenfalls mehrere gegner in spells erfassen.

------
patryn

-----------------------------------------------------------------------------



skill-suchties? (Patryn, 28. Dez 1998, 16:29:19):
Drolli teilt Dir mit: und deinen riesenmit den dicken lasuritsteinen kann man
Drolli teilt Dir mit: auch killen?
Du teilst Drolli mit: also ich habs schon paar mal geschafft
Drolli teilt Dir mit: hmm du meinst als hood?
Drolli teilt Dir mit: alleine?
Du teilst Drolli mit: logisch :)
Drolli teilt Dir mit: oder team?
Du teilst Drolli mit: hood macht nur allein
Drolli teilt Dir mit: weil wir zauberer sind schon am gruebeln wie das wohl
Drolli teilt Dir mit: geht
Drolli teilt Dir mit: ist ja antimagiezone
Du teilst Drolli mit: das ist eigentlich recht einfach...wenn man weiss wie :)
Drolli teilt Dir mit: antimagie? ok man stelle einen schatten im nachbarraum
Drolli teilt Dir mit: zaubert sichhoch und geht rein und schlaegt zu brei mit
Drolli teilt Dir mit: hand feuer oder so
Drolli teilt Dir mit: zusammen mit schlagring stimmts?
Du teilst Drolli mit: tsja...ists doch schon
Drolli teilt Dir mit: hmm ok das schwebte mir auch vor nur habs nicht probiert
Du teilst Drolli mit: die zeit ist ausreichend fuer ein paar gute treffer
Drolli teilt Dir mit: ja nur haut er auch ganz schoen zu
Du teilst Drolli mit: eibfach ist er nich grad anfangs, ok :)
Drolli teilt Dir mit: wieso anfangs? wird er schwaecher?
Du teilst Drolli mit: noe, mit der zeit lernt man dazu und schafft ihn
Du teilst Drolli mit: einfacher...wie bei all meinen npc's
Drolli teilt Dir mit: hmm versteh ich dich richtig? der npc merkt sich den
Drolli teilt Dir mit: gegner und kaempft nachher schwaecher? oder gibts einen
Drolli teilt Dir mit: invis skill [16:19]
Drolli teilt Dir mit: also einen invisible skill des spielers bezueglich
Drolli teilt Dir mit: monster [16:19]
Du teilst Drolli mit: du verstehst wirklich nicht :) es gibt einen invis-skill
Du teilst Drolli mit: bezueglich des monsters, der ist direkt in deinem kopf
Du teilst Drolli mit: implementiert, das musste ich (hoffentlich) nicht
Du teilst Drolli mit: einbauen :)
Drolli teilt Dir mit: :) [16:21]
Du teilst Drolli mit: ich geh pennen, evtl. kommste ja noch dahinter :)
Drolli teilt Dir mit: klar bei mir muss man das einbauen ;) [16:21]
Drolli teilt Dir mit: gute nacht maeuschen [16:21]

------
patryn's beweis fuer die enge sichtweise eines sehers :)

-----------------------------------------------------------------------------



feuerball (Patryn, 29. Dez 1998, 15:54:51):
hi zuauberers

ok entwarnung, ihr koennt wieder mit feuerbaellen um euch werfen, ohne
mitstreiter durchzugrillen oder euch selbst :)
rochus war so nett, den fehler zu beheben...also: lasst es krachen ;)

------
patryn

-----------------------------------------------------------------------------



zhist (Patryn, 13. Jan 1999, 21:04:54):
hi zauberer

statt 'zrufe hist|hist lang' (welches trotzdem noch so geht und nun auch
klein- grossschreibung beachtet) gibts nun 'zhist [zeilen]', <zeilen> ist
optionaler intergerwert, der angibt, wieviel zeilen angezeigt werden.
wird nix angegeben, wird alles angezeigt.
'teile llystrathe mit zauberstab' sollte schon einem test vorausgehen...

------
patryn

-----------------------------------------------------------------------------



*zitat* (Woody, 16. Jan 1999, 02:40:00):
[Zauberer:Nachtwind] Erinnert Ihr Euch noch an die guten alten Zeiten? Als man
[Zauberer:Nachtwind] aus der Kueche mit einer Tasse Kaffee zum Rechner
[Zauberer:Nachtwind] zurueckkam, und der Weghier war todgeidlet? Als man die
[Zauberer:Nachtwind] Hydra im Startraum mit dem Todeszauber zappte? Damals war
[Zauberer:Nachtwind] Schutzhuelle noch so gut wie "mschau ein"! Verletze war
[Zauberer:Nachtwind] noch der ungeschlagen fieseste Spell, und entkraefte
[Zauberer:Nachtwind] erledigt mit dodamage() alles, was sich damit nicht
[Zauberer:Nachtwind] angreifen liess... Der einzige Schutz gegen unsere
[Zauberer:Nachtwind] Angriffsspells war es, sich schon von unserer Hand
[Zauberer:Nachtwind] vernichten zu lassen! Und das Entsorgen! 2.4 Tonnen
[Zauberer:Nachtwind] Granit in 0.45 Sekunden! Die ultimative Loesung aller
[Zauberer:Nachtwind] Probleme mit Stabpunkten! Ungestoertes Vollskripten im
[Zauberer:Nachtwind] Uebungsraum! Wenn ich dann an die jetzige Gilde denke.
[Zauberer:Nachtwind] NeinNeinNeinNein! Spell prepare? Worauf  soll man sich
[Zauberer:Nachtwind] denn bitte vorbereiten? Man hat bei Lars ja genug Zeit,
[Zauberer:Nachtwind] sich auf die naechsten 100 Tode vorzubereiten!
[Zauberer:Nachtwind] Stattdessen schaut man interessiert zu, wie die eigenen
[Zauberer:Nachtwind] LP munter gegen 0 gehen, waehrend man hoenische Meldungen
[Zauberer:Nachtwind] serviert bekommt, man waere jetzt "voellig entspannt"! Ja
[Zauberer:Nachtwind] sind wir denn alle total debil??? Teleport, der nur dann
[Zauberer:Nachtwind] geht, wenn man ihn grade sicher nicht braucht.  Das ist
[Zauberer:Nachtwind] kein Fluchtteleport, sondern ein _Fluch_teleport! Und
[Zauberer:Nachtwind] erstmal der Magisterguertel! Frueher taugte der
[Zauberer:Nachtwind] tatsaechlich noch fuer mehr, als nur die Hose oben zu
[Zauberer:Nachtwind] halten! ALLES MUELL! Um es mit den Worten Lugs zu sagen:
[Zauberer:Nachtwind] FICKT DIE BALANCE! Hauptsache es KRACHT! AMEN!


-----------------------------------------------------------------------------



Re: *zitat* (Anacrion, 16. Jan 1999, 15:00:16):
~#! rn=Woody rt=916454400 rg=gilden.zauberer
~#! tid=916454400
#Hmm. Na ja :) *lach* supergeil ...


Allerdings sind ein par Punkte dabei, die man zumindest _etwas_ aendern
koennte:
1. MAgisterguertel .. also fuer ne Lupe undn nen ewiges Wollknaeuel brauch ich
keinen Magisterguertel ., finde, das schiefer u auf jeden fall drin sein
sollte .. ohne nen schutzspruch ist der magier eh nen krueppel .. der
delfenmagier koennte ja ne einbalsamierte rabenfeder haben .. waere auch ganz
nett:)

Und Dder Spellprepare beim teleport ist zu lang .. 

Anac* - verwendet schon lange kein fr teleport mehr :((

-----------------------------------------------------------------------------



Re: Re: *zitat* (Mindblade, 17. Jan 1999, 17:06:14):
~#! rn=Anacrion rt=916498816 rg=gilden.zauberer
~#! tid=916454400
So, wie ich Silvana verstanden habe, will sie keine ewigen Alles! Genau aus
diesem Grund sind einige Features aus dem Magisterguertel verschwunden. Und
Schiefer ist nun wirklich keine Mangelkomponente und supereinfach zu besorgen.
Bei einigen anderen Komponenten hast Du allerdings recht, was die -im Moment
spaerliche- Verteilung angeht. Und ausserdem gibt es sogar ein ewiges
Schieferstueck, wenn Du soviel Wert darauf legst!;)
Und um sich am Anfang Schiefer zu besorgen reicht locker ein Schutz!

Mind*, heute mal fuer seine "Tochter" sprechend.

-----------------------------------------------------------------------------



Re: *zitat* (Birdy, 18. Jan 1999, 14:06:55):
~#! rn=Woody rt=916454400 rg=gilden.zauberer
~#! tid=916454400
Recht haste !!!!

Birdy will auch mal wieder metzeln gehn

-----------------------------------------------------------------------------



entsorgen (Patryn, 19. Jan 1999, 11:51:06):
hi ihrs

die zauberstabfunktion entsorgen heisst jetzt entsorge und wurde auch
ziemlich stark veraendert. dank padreic ueberarbeitung von diversen
mudlib-teilen, war es nun recht einfach, die syntax so zu erweitern, dass
man nun auch mehrere sachen zugleich oder sachen in containern
entsorgen kann.
vorsicht sei jedoch geboten: 'entsorge alles' kann verschiedenste
gefuehlsausbrueche hervorrufen...von andaechtigem staunen bis zu ich spiel
hier nicht mehr mit, ist mir zu doof :)

------
patryn

-----------------------------------------------------------------------------



Re: entsorgen (Patryn, 19. Jan 1999, 11:52:06):
~#! rn=Patryn rt=916746666 rg=gilden.zauberer
~#! tid=916746666
ach ja, ehe die fragen kommen:
gimmicks aktualisieren
muss benutzt werden.
die texte die am schluss kommen sind nur hinzugefuegt, das hat schon immer
so funktioniert.

------
patryn

-----------------------------------------------------------------------------



Re: entsorgen (Zorya, 20. Jan 1999, 00:55:14):
~#! rn=Patryn rt=916746666 rg=gilden.zauberer
~#! tid=916746666
Darf ich Dich dezent darauf stupsen, dass der Befehlsname 'entsorgen'
seinen Sinn hat(te)? Verwechslungen hatten schon zu testzeiten der 
Gilde hoechst unangenehme Konsequenzen.

   Zorya - die das eigentlich nix mehr angeht.

-----------------------------------------------------------------------------



kosmetik (Patryn, 20. Jan 1999, 14:20:47):
hi zauberers

drei kleine aenderungen:

(1) gross-kleinschreibe-typos in angriffsmeldungen entfernt, evtl.
    hauen nun ein paar trigger daneben :)
(2) durch die allgemeine rr-sperre wurde die inselloesung in verletze
    ueberfluessig (beides zusammen ergab ja nur noch luftschlaege :)
(3) wenn man spells schon mal gelernt hat und nicht mehr den erforderlichen
    level hat, kann man die spells nicht mehr nutzen.
     (z.B. bei aus- und wieder eingetretenen mitgliedern der gilde)

------
patryn

-----------------------------------------------------------------------------



ich mal wieder (Patryn, 21. Jan 1999, 16:18:33):
hi ihr nasen,

ich hab mal versuchsweise am zmessage-gimmick herumgebastelt und es
um die moeglichkeit erweitert, dass angezeigt wird, was fuer eine
schadensart hand grad macht...nix besonderes, aber wenns klappt, kann ja
evtl. noch anderes rein :)
wer vorschlaege hat, meldung an mich

und fuer die, welche es noch nicht wissen: der penner im vland hat nen
kleines lustiges teil, das dem entsorge-gimmick noch zugute kommt.

------
patryn

-----------------------------------------------------------------------------



ein bug, ein bug :) (Patryn, 21. Jan 1999, 18:00:36):
hallo ihr stuemper,

ja, genau diese duerfte dies nur interessieren. ich hab grad DEN BUG
ausgebaut, wer nich weiss was ich meine, sei nicht beunruhigt.
er hat viel verpasst :)

leider lernt man nun grundsaetzlich nicht mehr aus erfolgen...keine ahnung,
wie ich das korrekt einbaue...

------
patryn

-----------------------------------------------------------------------------



Re: ein bug, ein bug :) (Birdy, 21. Jan 1999, 18:54:54):
~#! rn=Patryn rt=916941636 rg=gilden.zauberer
~#! tid=916941636
Interessant. *gruebel*

-----------------------------------------------------------------------------



entsorge (Patryn, 26. Jan 1999, 00:46:13):
hi ihrs

auf wunsch eines zauberers kann man mit entzsorge nicht mehr ueber
max-stabmagiepunkte aufladen, das geht nur noch per entkraefte.
viel spass weiterhin.

------
patryn

-----------------------------------------------------------------------------



trichter (Patryn, 26. Jan 1999, 00:57:42):
und noch mal

wer den trichter kennt: noch mal auf wunsch wurde er um eine
zehnerpotenz abgewertet. viel spass.

------
patryn

-----------------------------------------------------------------------------



hand (Patryn, 26. Jan 1999, 01:07:46):
hi ihrs

heut zum letzten: die normale hand wurde abgewertet, da ich der spontanen
meinung war, dass zusatzmoeglichkeiten zu wenig genutzt werden.
ausserdem scheint es den leuten eh zu gut zu gehen, wenn man gewisse
vorschlaege so betrachtet.
viel spass noch.

------
patryn

-----------------------------------------------------------------------------



Re: entsorge (Morgoth, 26. Jan 1999, 07:55:18):
~#! rn=Patryn rt=917311573 rg=gilden.zauberer
~#! tid=917311573
Wieso werd ich immer getreten, wenn ich Sachen ueber MAX mache ??? ;-)))

M*

-----------------------------------------------------------------------------



Re: hand (Morgoth, 26. Jan 1999, 07:58:57):
~#! rn=Patryn rt=917312866 rg=gilden.zauberer
~#! tid=917312866
**HUST**

Wie bitte???
Kann es sein, dass Du irgendwo im falschen Logfile gelandet bist? Also die
Leute die ich so kenne, benutzen die eigentlich recht haeufig.

M*

-----------------------------------------------------------------------------



Re: Re: entsorge (Bendeigid, 26. Jan 1999, 08:38:24):
~#! rn=Morgoth rt=917337318 rg=gilden.zauberer
~#! tid=917311573
Hm, moeglicherweise, weil das nicht "ab und zu" vorkommt, sondern eher die
Regel darstellt?
Und sicher ist Dir bekannt, dass man immer besonders beobachtet wird, wenn man
"unangenehm" auffaellt. ;))

*duck*
Z'par Servu,
           Bendeigid

-----------------------------------------------------------------------------



Re: hand (Reaper, 26. Jan 1999, 10:19:16):
~#! rn=Patryn rt=917312866 rg=gilden.zauberer
~#! tid=917312866

aehh.. also rein-raus geht nicht mehr und hand wurde gleichzeitig 
abgewertet..?
Meiner Meinung nach waere es eher sinnvoll gewesen ausgleichend die Hand
etwas aufzuwerten, um die Chancen gegen bisherige Rein-Raus-Monster
wenigstens etwas zu erhalten.

Naja, dann weiss ich ja, wie in Zukunft nach nem Reboot Heerscharen 
von Zauberern stundenlang einem grinsenden Phlyaken nachlaufen werden, 
der sich ueber nen Rein-raus-versuch kaputtlacht, und bei dem Versuch
mit ner 'einfachen' Hand im Raum zu bleiben (woher soll auch ne 
Ausruestung kommen), den Betreffenden seelenruhig in Stueckchen 
zerschmettert, waehrend er selbst im besten Falle ein biszchen am Bauch 
gekitzelt wird ?

Das gleiche gilt auch fuer die Beschaffung der Hand-Komponenten.
Mit normalen Haenden freut sich das Zombieskelett, und Patryn wohl bald 
ueber eine Flut von Kerben...

Also ausgeruesteter Zauberer zu sein ist noch immer schoen und gut,
aber nen nackten Zauberer (ohne starken Zweiti o.ae.) auszuruesten langsam
so gut wie unmoeglich....

Und wenn ich jetzt auch noch fragen wuerde, ob im gleichen Zug vielleicht 
die Hand MIT Komponenten ebenso aufgewertet wurde, wuerde ich sicher nur 
ein mitleidiges Kopfschuetteln ernten....


Reaper
(hochkonzentriert ein paar Funken zaubernd)

-----------------------------------------------------------------------------



Re: hand (Niete, 26. Jan 1999, 10:30:30):
~#! rn=Patryn rt=917312866 rg=gilden.zauberer
~#! tid=917312866
ich hoffe obwohl deine meinung 'spontan' zustande kam, hast du da wenigstens
einigermassen drueber nachgedacht bzw das mal durchgetestet? die argumente von
reaper finde ich jedenfalls nicht voellig unschluessig, gerade nach einer ab-
wertung von rein-/raus ist man doch mehr auf hand angewiesen. ich finde die
abwertung (auch im versuch moeglichst objektiv zu sein :) ) doch etwas hart...

naja, bin ja auch ne 
         niete

-----------------------------------------------------------------------------



Re: hand (Birdy, 26. Jan 1999, 12:43:13):
~#! rn=Patryn rt=917312866 rg=gilden.zauberer
~#! tid=917312866
Ich wuerde sage, dass du mal ein bisschen an dir arbeiten solltest, damit
deine Launen dich nicht bestimmen, nach der Abwertung von rein-raus find ich
das jetzt schon fast ironisch. Da frag ich mich doch, ob es nicht einen
geheimen Magierplan gibt, die Zauberergilde zu schliessen, denn wenn ich jetzt
mal weiterueberlege, was bisher geschah und das in die Zukunft projiziere,
werde ich wohl naehctsen Montag austreten oder so.
Na mal schaun.

Birdy kommt mit dem 'letzten tropfen aus dem vollen fass abschoepfen' schon
fast gar nicht mehr nach

-----------------------------------------------------------------------------



Re: Re: hand (Patryn, 26. Jan 1999, 12:56:53):
~#! rn=Birdy rt=917354593 rg=gilden.zauberer
~#! tid=917312866
neben persoenlichen angriffen kann ich deinem artikel nur weinerliches
wehklagen entnehmen...mein mitleid gibts nicht.
wie waers mit nem gruppen-ohhhh, eins, zwei ...
der unterschied zu vorher ist lediglich, dass man mit hand ohne zusatzkomp
keine maxstaerke mehr erreichen kann. eure jammerei ist echt das letzte,
als bei verletze wegen reinraus die zeitbeschraenkung rauskam, war
das nur allzuverstaendlich...nicht mal eine anmerkung dazu.
reichlich heuchlerisch...nun ja

------
patryn ohhht

-----------------------------------------------------------------------------



Re^3: hand (Xenon, 26. Jan 1999, 14:42:24):
~#! rn=Patryn rt=917355413 rg=gilden.zauberer
~#! tid=917312866
Ich finde das deine Ankuendigung Zitat: "die normale Hand wurde abgewertet, da
ich der spontanen 
Meinung war, dass Zusatzmoeglichkeiten zu wenig genutzt werden." reichlich
missverstaendlich.
Abgesehen davon, dass es so klingt als haettest Du deine Enscheidung aus einer
Laune heraus getroffen (was sehr schade waehre, ich Dir aber noch nicht
richtig unterstellen will), klingt das in meinen Ohren als ob der jetzt
Handspruch allgemein schlechter ist.
Wenn es aber heissen sollte, das Hand im Durchschnitt gleich geblieben ist und
nur die maximale Staerke ohne Handkompos oder Ringe (?) nicht mehr zu
erreichen ist, haette sich wahrscheinlich niemand aufgeregt, da das sowieso
sehr selten vorkommt.

Allerdings finde ich das es viel gravierenden Arbeitsbedarf beim Ueben gibt. 
Falls es immer noch so ist das Du das Lernen aus Erfolg ausgebaut und beim
Lernen aus Misserfolg nichts geaendert hast, hast du Zauberern die noch ein
paar Gildenstufen steigen wollen das Ueben unverhaeltnissmaessig schwer
gemacht.
(Fuer die anderen Gilden: Ich lerne nur bei 30% der ohnenhin schon sehr selten
Misserfolge und brauche Komponenten fuer einige 10K, deswegen ist das Lernen
aus Erfolg fast wichtiger als aus Misserfolg).
In diesem Zusammenhang sehe ich eine Abwertung von Hand noch weniger
gerechtfertigt, weil ich eigentlich nur durch Erfolg den Hand-Skill auf Max
steigern konnte.
Soweit ich das Konzept mit dem Silvana die Gildenstaerken gegeneinander
abwaegt verstanden habe, wiedersprechen deine Entschweidungen in den letzten
Tagen diesem.
Ich weiss, ich weiss, dass macht alles viel Arbeit, aber erst mal Abklemmen
und dann die Spieler warten lassen haut auf Dauer auch nicht hin.
Falls sich das mit dem Ueben alles schon geaendert hat kannst Du meinen
Artikel gern loeschen.

Gruss Xenon


-----------------------------------------------------------------------------



Re: Re: hand (Mindblade, 26. Jan 1999, 14:48:13):
~#! rn=Reaper rt=917345956 rg=gilden.zauberer
~#! tid=917312866
Also hier laeuft urgendwas falsch, Phlyaken kann man mit ner dummen
nachtruestung ohne Probleme stehen.
"Aufwertung von Hand"????? Also nur weil Du vielleicht nicht mit den
entsprechenden Komponenten metzelst und oefter mal ne minimale oder schwache
Hand wuerfelst, heisst das noch lange nicht, dass Hand zu schwach ist. Mit der
Abwertung der "normalen" Hand kann ich z.B. mit meinem 2tie ganz gut leben.
Und bevor jetzt wieder son Spruch kommt...ich hol mir meine Extrakomponenten
nur mit meinem 2tie, der kann das besser als jeder Kaempfer. 

Mind*, spricht heute mal fuer seine Tochter und schuettelt nur noch den Kopf.

-----------------------------------------------------------------------------



Re^3: hand (Reaper, 26. Jan 1999, 15:21:02):
~#! rn=Mindblade rt=917362093 rg=gilden.zauberer
~#! tid=917312866

Tja, lieber Mindblade, mein Problem ist nur die Erstausruestung.
Dass ein ausgeruesteter Zauberer mit Phlyaken kein Problem hat
ist klar, aber wenn ich versuche mich nach nem Crash einigermassen
auszustatten wirds schwierig.

Ich selbst gehoere uebrigens zu den Zauberer, die fast nur MIT 
Komponenten metzeln, solange sie welche haben, und zu deren 
Lieblingsfeinden das Zombieskelett gehoert. Das begruendet wohl 
auch, dass meine letzten 25 Tode fast ausschliesslich auf das 
Zombieskelett gingen *g*

Wie gesagt, das einzige Problem ist die Beschaffung der ersten Handkomponenten
und die erste Ruestung (was bei den meisten wahrscheinlich ja Phlyakens ist.)

Da aber die Hand inzwischen sowieso wieder wie gehabt funktioniert ist
das Ganze Gespraech sowieso hinfaellig......


Reaper

-----------------------------------------------------------------------------



Re^4: hand (Ringor, 26. Jan 1999, 15:24:37):
~#! rn=Reaper rt=917364062 rg=gilden.zauberer
~#! tid=917312866
Nur so ne dumme Frage von einem Nicht-Zauberer:

Wenn Dir der Phylaken nackt zu schwer ist - hast Du schonmal dran gedacht,
Dich vielleicht erstmal anderweitig auszuruesten?

Andere Gilden koennen sich auch nicht sofort von jedem die Max-Ruestung holen.
Da faeng man auch erstmal klein an ...

Ringor denkt . o O(Zauberer)

-----------------------------------------------------------------------------



abwertung (Isis, 26. Jan 1999, 16:25:54):
Hmm..nur so ne idee...

Aber langsam siehts mir so aus, als sei eine reale Abwertung der Speiler
geplant...und zwar immer son bissl, damit nich das Geschrei zu gross wird...

gegen eine abwertung iss teilweise nix zu sagen...mega-monster mal
ausgenommen, aber die koennte man ja auch anpassen...

Was mich nur wunder, iss dass frueher einige Aenderungen erstmal in der MPA
diskutiert worden sind...kann mich nich erinnern, dass rein-raus mal so
richtig nen Thema war...

Zugegeben, solche diskussionen waren oft ziemlich schraeg, aber eineige haben
sich doch bemueht was ordentliches zu sagen...

Also, wenns Zufall iss, dass nach der grossen
Abwertungs-...aeh...Anpassungswelle von Silvana noch weiter nach unten
korrigiert wird, kein Prob...

Wenn allerdings ein strategischer Plan dahintersteht, sollte das denke ich
oeffentlich gemacht werden. 

Isis

P.S. balance hin oder her...ohne rein-raus geht Spielspass verloren..und darum
gehts doch, oder? Wers realistisch haben will, soll sich nach RL verziehen...

-----------------------------------------------------------------------------



Re: abwertung (Key, 26. Jan 1999, 16:27:55):
~#! rn=Isis rt=917367954 rg=gilden.zauberer
~#! tid=917367954
"ohne rein-raus geht Spielspass verloren"

Wenn Du der Meinung bist dann geh nachhause, und spiel in nem HomeOUD
(OneUserDungeon) :) oder kauf dir nen schoenes neues Spiel.

Key

-----------------------------------------------------------------------------



Re: abwertung (Anatol, 26. Jan 1999, 16:28:33):
~#! rn=Isis rt=917367954 rg=gilden.zauberer
~#! tid=917367954
Um rein/raus, liebe Isis, geht es hier gar nicht. Die Ineffektiv-Machung
der rein/raus-Taktik hat durchaus Gruende, die Dir jeder aktive und
programmierende Magier gerne erklaert. Sofern Du einen solchen findest.

Hier geht es um eine Abwertung der normalen Zauberer-Hand, wo sich
Patryn eventuell in der Kommastelle vertan hat - und das Geschrei dem-
entsprechend lauter ist als das eines Huehnerstalls in dem der Habicht
umgeht...

Anatol :o)


-----------------------------------------------------------------------------



Re: abwertung (Mindblade, 26. Jan 1999, 16:29:35):
~#! rn=Isis rt=917367954 rg=gilden.zauberer
~#! tid=917367954
"ohne rein-raus geht Spielspass verloren"....
Also, ich glaubs nicht und das von nem Karateka....seit wann macht ein
Karateka bei rein-raus viel Schaden?
Und wo geht der Spielerspass verloren, wenn man mal alle Gildenfeatures
ausnutzen kann und nicht nur alle x Sekunden mit einer Taste ein
rein-raus-makro startet.
CU, Mind*

-----------------------------------------------------------------------------



auf gehts (Patryn, 26. Jan 1999, 17:15:27):
hi zauberers

da ich grad in geberlaune bin hier ein weiterer artikel unter dem thema
  'wie kuendige ich aenderungen moeglichst undiplomatisch an.'
der letzte war ja schon nen voller erfolg und ich hoffe doch, dem noch
eins draufzusetzen :)

also um es kurz zu machen: verletze hat spellprepare

um es zu entschaerfen (tu ich jetzt aber ungern):
  wer im team kaempft und hinten steht, wird nich viel von merken.
  leicht staerker isses auch, nun ja.
damit das ganze funktioniert, muesstet ihr einmal kurz mit ende rausgehen,
ich mein nich das mit dem prepare, das geht schon :)

etwas zwang ist auch dahinter: wer kein ende macht hat nun wohl verbreitet
mit spellprepare zu kaempfen: also 'ende' !!! :)

------
patryn

-----------------------------------------------------------------------------



Re: Re: abwertung (Isis, 26. Jan 1999, 17:25:43):
~#! rn=Key rt=917368075 rg=gilden.zauberer
~#! tid=917367954
Hm, key, ich glaub nen oud waer was fuer Dich, sowenig, wie du mit leuten klar
kommst, die vielleicht mal ne andere Meinung haben, wie Du...

Und mehr hab ich nich gemacht, wie meine Meinung zu sagen...

Isis

-----------------------------------------------------------------------------



Re^4: hand (Patryn, 26. Jan 1999, 17:27:26):
~#! rn=Reaper rt=917364062 rg=gilden.zauberer
~#! tid=917312866
aeh die hand geht nicht so wie gehabt, scheinbar noch nich ganz
dahintergestiegen? :)

------
patryn

-----------------------------------------------------------------------------



Re: Re: abwertung (Saul, 26. Jan 1999, 17:28:14):
~#! rn=Anatol rt=917368113 rg=gilden.zauberer
~#! tid=917367954
Was Isis wohl mit "ohne rein-raus geht Spielspass verloren"    
nun genau meint... Wer weiss das schon?
Fakt ist aber, Monster die man schon 163 mal damit gekillt hat um   
an Ausruestung zu kommen, sind schwieriger geworden. Die Spieler
muessen sich eine neue Taktik fuer ein alt bekanntes Monster
zurechtlegen, und das ist fuer viele wohl langweilig.
Natuerlich ganz von den Monstern zu schweigen, die ueberhaupt
nicht mehr zu schaffen sind. Da kann man nur an die Magier
appelieren, diese zu aendern und an die Geduld der Spieler.
Der Satz von Dir: "Die Ineffektiv-Machung der rein/raus-Taktik 
hat durchaus Gruende, die Dir jeder aktive und programmierende 
Magier gerne erklaert." scheint zu zeigen, das Du diese Gruende
auch kennst. Also ergehe Dich nicht in Andeutungen sondern
erzaehl mal.
Und das "eventuell in der Kommastelle vertan" zeigt mir auch nicht
gerade den grossen Plan hinter den Verschl^H^H^H^Haenderungen die
den Spielspass erhoehen sollen. Das sieht schon eher nach
Schnellschuessen aus, oder nach vorauseilenden Gehorsam in Hinblick
auf den Gildenbalancemagier ;-)
Saul

-----------------------------------------------------------------------------



Re^3: abwertung (Key, 26. Jan 1999, 18:01:50):
~#! rn=Isis rt=917371543 rg=gilden.zauberer
~#! tid=917367954
Hab ich Dir erlaubt Deine Meinung zu sagen?

Ich glaube nein

Key

-----------------------------------------------------------------------------



abwertung (Jiddu, 26. Jan 1999, 22:42:46):
Hey wie waers mit nem Spell-prepare fuer Hand? :)
*duck*

Jiddu ->schmarrn()

-----------------------------------------------------------------------------



Re: abwertung (Acrimon, 26. Jan 1999, 23:01:44):
~#! rn=Isis rt=917367954 rg=gilden.zauberer
~#! tid=917367954
Hmm. Das seh ich anders.
Rein-raus hab ich nie gern gemocht.
Fuer mich war rein-raus der Spielspaszkiller, deswegen hab ichs auch schon
lange nicht mehr gemacht.

In Zukunft werd ich wohl wieder oefter Lust zum Kaempfen haben...

Acrimon, der Rote Ritter

-----------------------------------------------------------------------------



lernen (Patryn, 27. Jan 1999, 03:37:34):
hi ihrs

das lernen bei erfolg muesste wieder gehen, ich hoffe ohne bug

------
patryn

-----------------------------------------------------------------------------



Re^3: abwertung (Anatol, 27. Jan 1999, 12:25:51):
~#! rn=Saul rt=917371694 rg=gilden.zauberer
~#! tid=917367954
Bin ich hier programmierender Magier? Muss ich jeden Trend ("ich brauche
einen Magierzweitie, um toll zu sein") mitmachen? Zumal das ja nicht 
automatisch heissen wuerde, wirklich aktiv Programmierender zu sein, 
nicht wahr, liebe Magier/Spieler-Zweities? :o)

Ich denke, ein Punkt an dem jeder Magier, der gerne interessante Monster
schreibt, verzweifelte, ist eben, dass mit rein/raus so gut wie alles
recht unproblematisch ueber den Jordan zu begleiten ist, wenn man nicht
explizite Gegenmassnahmen ergreift (und sich dafuer dann ein paar Flame-
Mails antun muss). Kampfverhalten, dass sich ueber mehr als eine Runde
auswirt (z.B. Zaubersprueche, die fuer mehrere Sekunden das Geschehen
beeinflussen oder Dinge, die im Raum veraendert werden koennen),  sind
vertane Zeit, fallen einfach weg. 
Ein weiterer Knackpunkt liegt noch eher auf der Hand: Wenn ein Monster
eben nicht "leicht" umzuhauen sein soll und sich gar seiner Haut zu wehren
wissen sollte, musste dem Monster bisher kraeftigste Spells und noch
wichtiger heftige Waffenangriffe mitgeben, die oft genug hart an der
209-LP-je-Runde-Grenze lagen. Ich fand das nicht wirklich prall, und 
ich weiss von einigen Magiern, dass sie damit auch nicht wirklich
gluecklich waren.

Anatol


-----------------------------------------------------------------------------



Re^4: abwertung (Saul, 27. Jan 1999, 13:41:40):
~#! rn=Anatol rt=917439951 rg=gilden.zauberer
~#! tid=917367954
Den ersten Absatz haettest Du Dir ruhig sparen koennen.
Ansonsten kann ich den Artikel nur wuerdigen und bin
froh das Du die Gruende in Worte gefasst hast.
Saul

-----------------------------------------------------------------------------



Aenderungen (Reaper, 27. Jan 1999, 13:46:44):

Also, jetzt muss ich doch trotz allem nochmal eine Beschwerde hier
loswerden. Ich jammer zwar nur ungern, aber eine grundliegende
Aenderumg fehlt.......

Was ein richtiger Zauberer ist, der braucht ein spell-prepare auf 
'schau', 'i', 'sag' und 'teile mit'.
Wenn ich so ganz ohne spellprepare durchs MG laufe, fuehle ich mich
ja schon als wuerde ich zu einer anderen Gilde gehoeren....

Ausserdem sollte man (um es etwas interessanter zu machen) z.b. an
einem missglueckten 'schau' sterben koennen, und man muss natuerlich
auch Komponenten dafuer haben. Sonst macht das alles ja langsam keinen
Spass mehr. 

Den 'schau'-skill koennte man z.b. so machen, dass man je nachdem, wie
gut es geglueckt ist mehr Details im Raum erkennen kann.
(naja, nur so ein vorschlag)

Wer die langweilige Methode ohne diesen Aenderungen will kann ja 
immer noch in ne andere Gilde gehen.

Reaper, konzentriert sich auf die Ausfuehrung des Spruchs 'grins'.

-----------------------------------------------------------------------------



Re: Re: hand (Orktoeter, 27. Jan 1999, 14:05:14):
~#! rn=Reaper rt=917345956 rg=gilden.zauberer
~#! tid=917312866
Hmm ist das hier ein MUD ? Muss sich jeder gleich zu anfang ohne alles auf die
haertesten NPC stuerzen um Max-Ausruestung zu bekommen ?

Was haelst du davon, mit einfacher Ausruestung anzufangen, oder dir von
jemandem helfen zu lassen ? Notfalls soll man sogar so etwas wie ein Team
gruenden koennen (habe ich mal gehoert).

OrkT dachte immer, das er in einem MUD spielt.

-----------------------------------------------------------------------------



Re: Aenderungen (Mindblade, 27. Jan 1999, 14:16:57):
~#! rn=Reaper rt=917444804 rg=gilden.zauberer
~#! tid=917444804
Anstatt so rumzuflamen koennte man auch einfach mal eine vernuenftige Mail an
den Gildemagier schreiben und ihm vielleicht vorschlagen, Befehle wie schau
etc. aus der Prepare rauszunehmen.

-----------------------------------------------------------------------------



Re^4: abwertung (Jasonrigid, 27. Jan 1999, 14:47:45):
~#! rn=Anatol rt=917439951 rg=gilden.zauberer
~#! tid=917367954

Auch wenn es gar nicht hier hergehoert, auch von mir ein Kommentar zu
Rein-Raus.

Du hast zwar voellig recht, dass rein-raus aus der sicht der magier natuerlich
besch...... war, das problem ist bloss, und ich kann die frustration mehr als
nachempfinden, dass die spieler IM AUGENBLICK mit monstern mit mega-harten
angriffen ohne rein-raus leben muessen, bis sich die magier entschlossen haben
(und zwar alle, die irgendwie relevante Metzel-NPCs geschrieben haben) auch
ihre ganzen Monster anzupassen. Meine Befuerchtung ist nur, dass man mit den
Aenderungen, die NPCs abwerten, nicht ganz so schnell bei der Hand sein wird,
wie mit Aenderungen, die Spieler abwerten. Die Spieler werden sich wohl auf
eine ziemlich lange Uebergangszeit gefasst machen muessen.

Wie auch immer

Jason

-----------------------------------------------------------------------------



magisterposten (Patryn, 27. Jan 1999, 15:06:44):
hi zauberers

solange kein wettkampfsystem fuer magister existiert, hab ich mal ne
sparversion eingebaut. jeder der einen magisterposten haben moechte,
wird nach beantragung mit den vorhandenen leuten vergleichen.
der schlechteste muss dann dran glauben...
sicher werden jetzt wieder fuerchterlich viele rumjammern, denn schliesslich
sind sie mit ihrem hintern auf den magisterstuehlen festgewachsen, aber
das ist mir voellig wurscht. schoenen tag noch :)

------
patryn

-----------------------------------------------------------------------------



rein raus (Householder, 27. Jan 1999, 17:07:34):
Gilden, die Monster die etwa soviel schaden machen wie der weghier ohne
reinraus umhauen koennen gehoeren abgewertet .... ein armer karateka stirbt da
naemlich allzu leicht schon an der begruessung :-) von der moeglichkeit
mehrere runden darin auszuhalten, um seinen spell entfalten zu koennen ganz zu
schweigen :-)
HH

-----------------------------------------------------------------------------



magisterposten (Patryn, 27. Jan 1999, 17:35:27):
hi ihrs

noch der kleine nachtrag: man kann die zweige nun nicht mehr
beliebig schnell wechseln (auch wenn man nen hoeheren level als alle
anderen hat). eine zeitbeschraenkung ist wohl nur logisch.

------
patryn

-----------------------------------------------------------------------------



Re^3: hand (Siborit, 27. Jan 1999, 23:06:05):
~#! rn=Orktoeter rt=917445914 rg=gilden.zauberer
~#! tid=917312866
Sorry OrkToeter leider bin ich nicht mit dir einverstanden (bin dafuer auch
Zauberer ;).
Es geht hier meiner Meinung nach um unsere basisstaerke worueber Reaper sich
aufregt. Dein Argument das wir nicht klagen muessen weil wir nicht gleich
max-ruestung holen koennen ist sowie ich das sehe nicht zurecht. Die Zeit das
Patryn mit ein paar geruestete Augenklappen beim Hydra idlen konnte ist echt
vorbei (leider ;).

So wie du es sagst heisst das etwa: Kaempfer um ein faktor 10 abwerten und
dann sagen: "Was ihr koennt jetzt keine Schmetterlinge mehr killen ??? Das
hier ist doch ein MUD, gruendet denn auch ein team".

Siborit.

-----------------------------------------------------------------------------



Re^4: hand (Mindblade, 28. Jan 1999, 00:37:46):
~#! rn=Siborit rt=917478365 rg=gilden.zauberer
~#! tid=917312866
Also, wenn da "Re" nicht auf Hand, sondern auf "verletze" gekommen waer,
koennte ich ja noch sagen, es handelt sich um anschauliche uebertreibung. Aber
der "Hand"-Spruch ist nicht um einen Deut schlechter geworden, wenn man sich
die Muehe macht sich auszuruesten und die Kompos holt. Nen Kaempfer laeuft
schliesslich auch nicht die ganze Uptime mit nem Nachdolch rum! Das ist
vollkommener Schwachsinn!

-----------------------------------------------------------------------------



zauberstab (Patryn, 28. Jan 1999, 15:57:19):
hi ihr zauberstabschwinger... (nich falsch verstehen)

frohe kunde sei euch zuteil: der altbekannte fehler bezueglich des
vergessens des artikels beim zauberstabsnamen ward gefunden und...
 ...ausgemerzt :)
viel spass noch

------
patryn

-----------------------------------------------------------------------------



erzspells (Patryn, 29. Jan 1999, 18:31:42):
hi zauberers

ersucht ist ein ersatz fuer den verwandlungs-erzspell imagomation.
also dann mal her mit den vorschlaegen, mir faellt nix ein.
ach ja: der spell kann schon recht unueblich sein a'la todeszauber,
todesbann. den hat nur einer, und man muss schon gut dafuer sein.

------
patryn

-----------------------------------------------------------------------------



Re: erzspells (Jiddu, 29. Jan 1999, 23:23:35):
~#! rn=Patryn rt=917634702 rg=gilden.zauberer
~#! tid=917634702
Vielleicht was in der Richtung .. Vanwandlung in ein staerkeres Wesen mit
schoen viel Schlagschaden, ner guten Ruestung, das vielleicht noch schneller
kaempft oder schneller mp/le regeneriert o.ae.? 
Jiddu moechte an dieser Stelle das Balance-Team gruessen.

-----------------------------------------------------------------------------



erzispell (Birdy, 30. Jan 1999, 12:08:09):
also ich find die idee von jiddu aufgreifenswert, hab auch schon eine mail mit
ner genaueren variante an patryn geschickt.

-----------------------------------------------------------------------------



Re: Re: erzspells (Anacrion, 30. Jan 1999, 13:50:23):
~#! rn=Jiddu rt=917652215 rg=gilden.zauberer
~#! tid=917634702
Hmm. Also ein besseres Selbstverwandlung, dass die Werte gleich mitaendert ?
... dann kannste aber noch nen spruch erfinden :)

anac*
 ..P.S. Ich finde ja die Idee nicht schlecht, denke aber, dass die
Verwandlung eines Gegners zu was harmlosen DER klassische Verwandlungsspruch
ist und bleiben sollte :)

-----------------------------------------------------------------------------



bezaubere (Patryn, 30. Jan 1999, 14:50:54):
hi ihrs

in hinsicht auf nen sinnvoll zu verwendendes imagomation hab ich mal
die erkennung auf npc's verfeinert, bei denen das anwendbar sein wird.
da die erzmagister noch nicht wieder freigegeben sind, koenntet ihr nun
fragen, was euch das interessiert?! :)
nun ja...der spell 'bezaubere' hat ganz aehnliche probleme. derhat die selbe
ueberpruefungsmethodik erhalten und kann nun eine menge mehr.
vorher konnte man damit ja maximal HE-ameisen beeindrucken.
(wer mit all dem nix anzufangen weiss, der vergesse es einfach wieder:
  nich dass mich wieder tausend leute fragen, wieso-weshalb-warum.)

der haken: der spell kann jetzt wahrscheinlich zu viel. alles wird
mitgelogt und steht zur ueberpruefung bereit. um schlimmeres zu vermeiden:
  wer mit dem spell unfug macht und mir diesbezuegliche bugs nicht meldet,
  der fliegt fuer alle zeiten aus den magisterposten. ich erwarte einfach
  ein paar probleme. npc's, bei denen meine methodik danebenhaut, kann ich
  in spezielle listen eintragen, aber ich kenne natuerlich nich alle.
  deswegen baue ich mal auf eure hilfe. wenn das alles gut geht kommt auch
  imagomation in einem vernuenftigen zustand wieder.

------
patryn

-----------------------------------------------------------------------------



Re: Re: erzspells (Teddy, 30. Jan 1999, 17:14:13):
~#! rn=Jiddu rt=917652215 rg=gilden.zauberer
~#! tid=917634702
Das Balanceteam macht keine Gildenbalance.

Teddy, informativ.

-----------------------------------------------------------------------------



wahrsagen (Patryn,  2. Feb 1999, 21:55:35):
der spell sollte wieder fehlerfrei gehen, lag an der neuen unit, dass
der nun rumspinnte...hat wohl lange keiner benutzt in der form :)

------
patryn

-----------------------------------------------------------------------------



Re: ich mal wieder (Jasper,  3. Feb 1999, 02:11:32):
~#! rn=Patryn rt=916935513 rg=gilden.zauberer
~#! tid=916935513
meinst du morgoth? :P

Jasper geht schonmal in deckung ... grinsend

-----------------------------------------------------------------------------



Re: abwertung (Jasper,  3. Feb 1999, 02:26:51):
~#! rn=Isis rt=917367954 rg=gilden.zauberer
~#! tid=917367954
Also das rein-raus war schon immer ein thema, und mittlerweile gibts ja auch
die moeglichkeit allen spells eine vorbereitungszeit zu geben, was aber wohl
nicht in vielen gilden benutzt wird. meiner meinung waere es auch die bessere
loesung gewesen, alle spellbooks zu durchwuehlen :P und den spells/skills
jvorbereitungszeiten von 2-100 sekunden zu geben...

Jasper verwoehnt vom zombiemud :)

-----------------------------------------------------------------------------



Re: Re: ich mal wieder (Key,  3. Feb 1999, 08:31:39):
~#! rn=Jasper rt=918007892 rg=gilden.zauberer
~#! tid=916935513
Jasper! reparier mal deine Laeden :)

Key

-----------------------------------------------------------------------------



Re^3: ich mal wieder (Jasper,  4. Feb 1999, 00:15:20):
~#! rn=Key rt=918030699 rg=gilden.zauberer
~#! tid=916935513
die funktionieren seit jahren fehlerfei, wenn da was bugt, dann liegt das
an morgoths std-laeden :P

-----------------------------------------------------------------------------



Re^4: ich mal wieder (Key,  4. Feb 1999, 15:29:14):
~#! rn=Jasper rt=918087320 rg=gilden.zauberer
~#! tid=916935513
Oder an ner anderen Aenderung?

Zumindest funzen sie nimmer ;)

Key

-----------------------------------------------------------------------------



Schwarzes Brett in der Kneipe (Vincent,  6. Feb 1999, 18:51:25):
Das schwarze Brett in der Gilden-Kneipe - wird das eigentlich noch
weitergefuehrt? Die informationen dort sind ja zum Teil ziemlich
veraltet. Falls es nicht mehr weitergefuehrt wird, koennte nicht jemand 
die Infos rausnehmen, die heute keine Gueltigkeit mehr haben?
Das waere riesig.

Vincent

-----------------------------------------------------------------------------



liste hin und liste her (Patryn, 15. Feb 1999, 13:37:41):
Hi Ihrs,

Hier noch mal die offizielle Ankuendigung: Llystrathe gibt wieder ueber die
Vollmitglieder der Gilde Auskunft, wie gehabt mit
4teile llystrathe mit liste4. zusaetzlich sind jetzt 3 Optionen zulaessig:
All jenen, die sich nicht entbloeden konnten, mich mit ihren Neurosen zu
nerven (hier speziell Toplistophobie, Symptome: reichen von schwerem
unheilbaren Verfolgungswahn bis zu manisch depressiven Verhalten durchsetzt
von heuchlerischen Anfaellen), sei die Option 4austragen4 ans Herz gelegt.
Eventuell bekommen sie sich ja damit wieder in den Griff und stuerzen sich
nicht gleich von der Osterbachschlucht.
Die Option 4eintragen4 ist dann fuer den Fall, dass die Leute mit
heuchlerischen Zuegen endlich die Top10 erreicht haben und sich wieder
eintragen moechten.
Die Option 4anzeigen4 ist default und kann entfallen.
Also 4teile llystrathe mit liste [anzeigen|austragen|eintragen4.
Wer nicht in der Liste ist, kann keine Magisterposten belegen, das liegt nun
mal im derzeitigen System begruendet. Wer sich eintraegt, hat trotzdem noch
4 Tage Sperre.

------
Patryn, leicht amuesiert ueber manche Probleme anderer

-----------------------------------------------------------------------------



Re: liste hin und liste her (Patryn, 15. Feb 1999, 13:39:05):
~#! rn=Patryn rt=919085861 rg=gilden.zauberer
~#! tid=919085861
na ja...die linux-neueinrichtung hat mir die sonderzeichen veraendert,
sorry wegen der 4en :)
die letzte wirkliche zahlangebe namens 4 stimmt nicht mal, da soll ne 14 hin.

------
patryn

-----------------------------------------------------------------------------



Re: Re: liste hin und liste her (Anatol, 15. Feb 1999, 13:48:54):
~#! rn=Patryn rt=919085945 rg=gilden.zauberer
~#! tid=919085861
Lieber Patryn,
das Problem der ganzen Geschichte ist weniger, dass man wieder sieht, 
wie toll manche Leute scripten koennen und wie schlecht sich manche
dabei anstellen, jenes nicht zu tun. Das Problem ist auch nicht, dass
man 14 Tage Pause hat, falls man sich aus der Liste austrug. 

Das Problem ist, dass Dank Deiner Umstellung wieder einmal nur die in
den Genuss der "besseren" Raenge kommen, die sich konsequent gegen ihre
Mitzauberer durchsetzen. Das Offensichtliche: Je hoeher man in der Liste
steht, desto leichter bekommt man einen Platz in begehrten Zweigen (der
Abwehrzweig ist fast vollstaendig in der Top 10, toll, gell?). Dass Du 
damit DAS foerderst, was "wir" auszurotten hofften, naemlich sinnlose
Uebescripts oder Untersuchescripts (der Spielerlevel scheint in Deiner
huebschen Liste massgeblich beteiligt zu sein), dass Du denjenigen die
Moeglichkeit zur - wenn auch nur zeitlich begrenzten - Entfaltung in 
einem Zweig raubst, die eigentlich nicht jedem Stups und FP hinterher-
betteln wollen, ja, das ist _das_ Problem.

Um es ueberspitzt auszudruecken: Die Erzmagisterraenge sind fuer SECHS
Leute toll. Etwas mehr eingetragene ueterstuetzende Ruestungsteile 
wuerden zweihundertsechsundvierzig Zauberern zugute kommen, ist aber
leiderleider nicht so spektakuler.

Na...

... gut, dass wir verglichen haben.

Anatol :o)


-----------------------------------------------------------------------------



Re: liste hin und liste her (Ringor, 15. Feb 1999, 13:50:38):
~#! rn=Patryn rt=919085861 rg=gilden.zauberer
~#! tid=919085861
> Wer nicht in der Liste ist, kann keine Magisterposten belegen, das liegt
> nun mal im derzeitigen System begruendet.

Sorry, wenn ich Dir da in den Ruecken falle - aber das "derzeitige System" ist
dann doch zumindest ueberarbeitungswuerdig, wenn Du die Abfrage, ob jemand in
der Liste drin ist, an die Stelle packst.

Die meiner Meinung nach einzig vernuenftige Stelle fuer eine Abfrage der
Anzeige ist die Ausgabe der Liste selbst und nirgendwo anders.

Die jetzige Loesung koenntest Du Dir auch schenken, da Du auf diese Art jeden
zur Aufnahme in die Liste zwingst, sofern er an einem Magisterposten
interessiert ist (wer nicht?).

Meine Meinung,
Ringor. Nicht-Zauberer.

-----------------------------------------------------------------------------



Re^3: liste hin und liste her (Birdy, 15. Feb 1999, 13:58:13):
~#! rn=Anatol rt=919086534 rg=gilden.zauberer
~#! tid=919085861
Vielleicht solltest Du mal ueberlegen, was Du da schreibst, Anatol.
Wir sind nunmal keine Gleichmachergilde, sondern jeder tut hier soviel, wie er
will oder fuer notwendig haelt.
Wenn jemand, so wie Du, keinen Ehrgeiz mehr hat, hier etwas zu erreichen,
sollte er nicht von sich auf andere schliessen.
Jeder der Erzmagister oder auch nur Magister werden will, kann dies tun, dass
er dabei bestimmte Anforderungen erfuellen muss, liegt ja wohl im Sinn der
Sache, da diese Posten schliesslich bestimmte Belohnungen darstellen, die man
in Froma neuer Sprueche lernen kann.
(ups, Froma=Form)
Dass nun eine weitere Anforderung darin besteht, in der Liste zu erscheinen,
finde ich nicht weiter erschuetternd, schliesslich moechten viele auch wissen,
wie gut man sein muss, um Erzmagister zu werden (wenn sie dann irgendwann auch
einmal wiederkommen sollten ;) ).
Und Konkurrenz in unserer Gilde findet ich gut, schliesslich sind wir, wie
schon gesagt, keine Gleichmachergilde.


-----------------------------------------------------------------------------



Re^4: liste hin und liste her (Anatol, 15. Feb 1999, 14:03:18):
~#! rn=Birdy rt=919087093 rg=gilden.zauberer
~#! tid=919085861
Der Wahlspruch einer meiner zwergischen Freunde aus dem Struv Koru Tschakar:
"Ich muss nicht mit einem Script konkurrieren. Das habe ich nicht noetig."
Und wenn es Dir lieber ist, andere Zauberer als Konkurrenten zu sehen statt
als Gleichgesinnte: Viel Spass, Ar^H^HBirdy.

Selten um eine Antwort verlegen,
Anatol


-----------------------------------------------------------------------------



Re^5: liste hin und liste her (Birdy, 15. Feb 1999, 14:07:57):
~#! rn=Anatol rt=919087398 rg=gilden.zauberer
~#! tid=919085861
Natuerlich ist jeder Zauberer mein Konkurrent, wenn es um Erzmagister- und
Magisterposten geht, schliesslich sind diese limitiert und ich will seinen
dieser Posten.
Wenn ich keinen dieser Posten wollte, waere wahrscheinlich kein Zauberer mein
Konkurrent.
Und Gleichgesinnte oder sogar Freunde unter uns Zauberern habe ich trotzdem.
Du siehst das anscheinend nur schwarz/weiss.

-----------------------------------------------------------------------------



Re^3: liste hin und liste her (Patryn, 15. Feb 1999, 14:09:49):
~#! rn=Anatol rt=919086534 rg=gilden.zauberer
~#! tid=919085861
vielen dank fuer die vielen konkreten vorschlaege anatol.
wir sind so schlau als wie zuvor, wuerd ich sagen :)

------
patryn

-----------------------------------------------------------------------------



Re^4: liste hin und liste her (Ringor, 15. Feb 1999, 14:12:01):
~#! rn=Patryn rt=919087789 rg=gilden.zauberer
~#! tid=919085861
Was ist aus dem Vorschlag geworden, eine Metzelstrecke zu bauen, auf der jeder
Zauberer zeigen kann, wieviel er von seiner Gilde kennt?

Auf diese Art wuerdest Du die Zauberfaehigkeit testen, und nicht das Geschick
im Umgang mit Skripten.

Ringor

-----------------------------------------------------------------------------



Re^5: liste hin und liste her (Patryn, 15. Feb 1999, 14:21:19):
~#! rn=Ringor rt=919087921 rg=gilden.zauberer
~#! tid=919085861
also da wuerde ja sofort wieder die VFgTL auf den plan treten und mich 
an den pranger stellen :)
auch da gaebe es natuerlich eine vergleichsmoeglichkeit, um sein koennen
einzuordnen. ja, das ding koennte man als topliste entlarven, au weia.
die derzeitige loesung ist laut artikel in dieser rubrik als voruebergehend
zu kennzeichnen. ich weiss, dass sie nicht perfekt ist, an der
metzelarea wird gearbeitet. sicherlich werden auch dort scripts laufen
und so weiter und so weiter...the neverending story

------
patryn

VFgTP...Volksfront gegen Toplisten

-----------------------------------------------------------------------------



Re^6: liste hin und liste her (Ringor, 15. Feb 1999, 14:25:05):
~#! rn=Patryn rt=919088479 rg=gilden.zauberer
~#! tid=919085861
Bleibt die Frage, warum Deine Abfrage, ob man in der Topliste auftaucht, an
einer so ungluecklichen Stelle steht.

Ich wage sogar einfach mal zu behaupten, dass selbst eine Qualifizierung ueber
eine Topliste ganz ohne Einsicht der Spieler in selbige Liste ginge. Eine
Meldung wie "Dir fehlen noch 153 Superduperguildratingpunkte zu einem
Magisterposten" waere auch ohne Vergleichsmoeglichkeit zu den Plaetzen 1-9
aussagekraeftig.

Ringor denkt . o O(hoffentlich faengt Boing nie mit so einem Schnickschnack
an)

-----------------------------------------------------------------------------



Re^7: liste hin und liste her (Boing, 15. Feb 1999, 14:26:16):
~#! rn=Ringor rt=919088705 rg=gilden.zauberer
~#! tid=919085861
Ich lese interessiert mit, vielleicht kann man die ein oder andere Topliste
in der Struv-Kneipe noch verbessern. :)
  Boing

-----------------------------------------------------------------------------



Re^6: liste hin und liste her (Mindblade, 15. Feb 1999, 17:46:06):
~#! rn=Birdy rt=919087677 rg=gilden.zauberer
~#! tid=919085861
Also dazu kann ich nur eins sagen:
Wie kommst Du darauf, dass jeder Zauberer Dein Konkurrent ist, momentan
koennen sich doch eh alle HLP-Zauberer auf ihren Posten ausruhen, weil die
anderen erstmal questen und forschen muessen! Vorher konnte man wenigstens mal
mit einem Freund tauschen, um auch mal in den Genuss eines guten Postens zu
kommen. Dass Dir diese Regelung besser gefaellt kann ich mir denken, gibt ja
eh ziemlich wenig Zauberer >Lvl 70!;)

Mind*, fragt sich, was das jetzige System mit Konkurrenz zu tun
hat...Questkonkurrenz?

-----------------------------------------------------------------------------



Re^3: liste hin und liste her (Teddy, 16. Feb 1999, 22:06:31):
~#! rn=Anatol rt=919086534 rg=gilden.zauberer
~#! tid=919085861
Wie waers vorher mal mit nen paar kleineren 'Bugs' die ausgebaut werden
koennten?

Teddy, kann sich gewisse Sachen eigentlich nicht als Absicht vorstellen.
P.S:: Ja, ich weiss ich bin da zu optimistisch ;(

-----------------------------------------------------------------------------



Re^4: liste hin und liste her (Patryn, 16. Feb 1999, 23:06:39):
~#! rn=Teddy rt=919202791 rg=gilden.zauberer
~#! tid=919085861
was fuer bugs? wie waers mal mit was konkreten, statt solch orakelmaessige
halbanschuldigungen zum besten zu geben. bugs die ich kenne, sind auch raus.
da ich seit mehreren monaten nicht mehr gespielt habe, ist es durchaus
verstaendlich, dass ich in dieser beziehung nicht so viel mitbekommen kann...

------
patryn

-----------------------------------------------------------------------------



Re^5: liste hin und liste her (Teddy, 16. Feb 1999, 23:42:45):
~#! rn=Patryn rt=919206399 rg=gilden.zauberer
~#! tid=919085861
Machen wirs halt konkret.
Erstmal vorneweg: Ich fuehle mich als Chaot NICHT zu schwach und kann gut
damit leben das andere Leute staerker sind als ich. (Glaubt mir eh wieder
keiner.)

Allerdings finde ich persoenlich eine brennende Hand (Auch mit Komponente),
die staerker als ein Chaosball/Feuerball/Hitzestrahl und damit angeblich auch
besser als ein verletze reinhaut denn doch ein wenig uebertrieben.
Leider ist die Kompohand genau so stark, ne deutliche Hand ist deutlich
staerker als mein Chaosball (nein ich heule nicht) und trifft ohne
nomagic/spelldefend oder aehnliche Probs durch schnellkampf gleich mehrmals
pro runde und stoert auch andere sprueche wie verletze, entkraefte oder
feuerball nicht.

Zum anderen, entkraefte. Entkraefte ist ein Beherrschungsspruch, damit wird er
leider ziemlich oft von Magiern vergessen die nur angriffssprueche abfangen.
Soweit noch nicht Problem der Zauberergilde. Das allerdings ein
BEherrschungsspruch Schadenstypen annimmt will mir nicht so ganz klar werden,
das widerspricht imho dem Grundgedanken des Entkraefte.

So, vielleicht siehts ja mal wer sachlich und versucht sich darueber Gedanken
zu machen vorm flamen.
Konkrete Vorschlaege zur Aenderung der Hand gibts uebrigens auch, die sind
nicht auf meinem Mist gewachsen sondern da stehen Leute hinter, die auch
HLP-Zauberer sind.

-----------------------------------------------------------------------------



Re^6: liste hin und liste her (Teddy, 16. Feb 1999, 23:43:11):
~#! rn=Teddy rt=919208565 rg=gilden.zauberer
~#! tid=919085861
Mist, Unterschrift fehlt, natuerlich:

Teddy ;)

-----------------------------------------------------------------------------



Re^7: liste hin und liste her (Nonne, 17. Feb 1999, 10:02:53):
~#! rn=Teddy rt=919208591 rg=gilden.zauberer
~#! tid=919085861
Och Teddy,
groesstenteils kann ich mich dem nur anschliessen. Aber Silvana sprach, dass
die Zauberergilde immer die beste Angriffsgilde sein wird. Das sie auch die
beste Verteidigung hat ist sicher zufall. Ich bin einfach froh, dass Zauberer
andere Ausruestung brauchen als ich und habe ein PAL-Feld um die ganze Gilde
gelegt. Ausser natuerlich, dass man Zauberer mit Hand-Kompos zu allem
verfuehren kann. So bekommt man in 2 Minuten die Ausruestung, wo man als
nicht-Zauberer die ganze Nacht dran sitzt. Also: nicht drueber Aufregen, nutz
die Bastarde aus, bis sie schwarz werden ;-)

Nonne. (Kleriker aus Ueberzeugung)

-----------------------------------------------------------------------------



Re^6: liste hin und liste her (Key, 17. Feb 1999, 19:19:46):
~#! rn=Teddy rt=919208565 rg=gilden.zauberer
~#! tid=919085861
Aehm Teddy?
In letzter Zeit jammerste mehr als ne Frau ... biste krank? 

Also .... mir persoenlich ist es scheissegal ob Zauberer 100 oder 1000 mal
mehr Schaden machen koennen als ich.
Zum einen brauchen sie dafuer Komps, Du nicht, zum anderen koennen sie keinen
starken Nicht Physikalischen Schaden machen.
Uebrigens kannst Du auch mit nem Schwert nen ordentlichen Schaden machen, und
dabei auch noch Finsternis und nen Chaosball anwenden, und sogar noch nen
Daemonen beherschen.

Aber naja, nicht die Gilden machen einen stark, sondern man selbst.

Key

P.S.: Das soll jetzt kein Freifahrt schein fuer die Zauberer sein
aufzuruesten. Aber bevor man wieder lauthals rumschreit von wegen abwerten
sollte man mal drueber nachdenken. Und vielleicht auch ueberlegen obs net
andere Wege gibt.

-----------------------------------------------------------------------------



Re^8: liste hin und liste her (Key, 17. Feb 1999, 19:21:08):
~#! rn=Nonne rt=919245773 rg=gilden.zauberer
~#! tid=919085861
Hmm jetzt zu Zeiten des Teamkampfes koennte man drueber nachdenken den Schutz
der Zauberer etwas abzuwerten .... aber dafuer dann den den sie auf andere
sprechen koennen aufzuwerten?

Key

-----------------------------------------------------------------------------



Re^7: liste hin und liste her (Teddy, 17. Feb 1999, 19:26:25):
~#! rn=Key rt=919279186 rg=gilden.zauberer
~#! tid=919085861
Schade Key, du scheinst bislang als einziger nicht gelesen zu haben was ich
geschrieben habe.
Ich hab deutlich geschrieben das ich mich nicht zu schwach fuehle und keine
Probleme damit habe, das andere staerker sind als ich, auch nicht damit das
sie deutlich staerker sind als ich.
Wenn ich sowas schreibe, hat das durchaus Gruende(Ueberraschung).
Wenn ich mir andererseits Muehe gebe das Thema sachlich zu behandeln find ich
natuerlich Begruessungsformeln wie 'Du jammerst in letzter Zeit wie ein altes
Weib' unheimlich gelungen und sehr passend.
Bevor du also anfaengst zu flamen waers eifnach nett, wenn du meinen Artikel
nochmal liest und mir vielleicht sogar unterstellst das ich in etwa weiss,
wovon ich da spreche, ich kenne durchaus die Vor- und Nachteile der Gidlen,
ich habe lediglich zur Diskussion gestellt, das da wohl ein Spell ein wenig
ausm Gleichgewicht (Nein ich sage nicht Balance;)) geraten ist, was einige
hohe Zauberer im uebrigen genauso sehen.
Also beschraenk dich bitte einfach auf sachliche Argumente.
Zu guter Letzt, ch hab sogar die Zauberer mit sich selber und mit allen
anderen Gilden verglichen.

Teddy, enttaeuscht ueber einen SO sinnlosen Artikel.

-----------------------------------------------------------------------------



Re^8: liste hin und liste her (Key, 17. Feb 1999, 19:29:58):
~#! rn=Teddy rt=919279585 rg=gilden.zauberer
~#! tid=919085861
Ich hab Dich nicht mit nem Alten Weib sondern ner Frau verglichen ... .)

Ansonsten wenn was mit der Gildenbalance net stimmt wende Dich vertrauensvoll
an Silvana oder Patryn per mail ...

Key

-----------------------------------------------------------------------------



Re^9: liste hin und liste her (Teddy, 17. Feb 1999, 19:31:16):
~#! rn=Key rt=919279798 rg=gilden.zauberer
~#! tid=919085861
Das steht nciht zur Diskussion, Patryn hat mich halt aufgefordert daher hab
ichs dann auch geschrieben, mehr nicht.

Teddy
P.S.: Frau=Weib?;)

-----------------------------------------------------------------------------



Re^10: liste hin und liste her (Key, 17. Feb 1999, 19:31:37):
~#! rn=Teddy rt=919279876 rg=gilden.zauberer
~#! tid=919085861
Hmm aber Frau=Altes Weib?

Key :)

-----------------------------------------------------------------------------



Re^7: liste hin und liste her (Jiddu, 17. Feb 1999, 21:52:06):
~#! rn=Key rt=919279186 rg=gilden.zauberer
~#! tid=919085861
Ein Verwandlungsmagister kann so weit ich weiss sehr wohl starken
nicht-pysikalischen schaden machen, jeden den sie Wollen. Und reine
Komponenten-Hand ist ja auch nicht nur physikalisch.
Berichtigt mich wenn ich falsch liege...
Jiddu.

-----------------------------------------------------------------------------



Re^8: liste hin und liste her (Mindblade, 17. Feb 1999, 21:57:20):
~#! rn=Nonne rt=919245773 rg=gilden.zauberer
~#! tid=919085861
Aeh Key, lass Dir mal oefter Huellen verpassen, die sind gut genug!;)

-----------------------------------------------------------------------------



Re^8: liste hin und liste her (Mandy, 17. Feb 1999, 21:58:50):
~#! rn=Jiddu rt=919288326 rg=gilden.zauberer
~#! tid=919085861

Ups, da muss ich jetzt wiederspechen. Einfach nur um das klarzustellen.
Auch Wandlungsmagister koennen definitiv _keinen_ starken physischen schaden
machen. Wandlung Erde ist dafuer absolut nicht geeignet. 3 Haende machen
genausoviel Schaden.
Wobei, schweifen wir hier nicht ein wenig ab?

Mandy

-----------------------------------------------------------------------------



Re^9: liste hin und liste her (Jiddu, 17. Feb 1999, 22:00:01):
~#! rn=Mandy rt=919288730 rg=gilden.zauberer
~#! tid=919085861
Es ging doch um NICHT-physikalischen oder?! :)
Jiddu.

-----------------------------------------------------------------------------



Re^10: liste hin und liste her (Anatol, 17. Feb 1999, 22:00:58):
~#! rn=Jiddu rt=919288801 rg=gilden.zauberer
~#! tid=919085861
Wuerden die Herren Karateka und Chaoten mit ihrem doch recht bescheidenen
Wissen ueber Zauberei und Magie in anderen, dafuer wesentlich geeigneteren,
Rubriken ihre Aufwartung machen? Wie waere es mit "Kochrezepte", die habe
ich ohnehin abbestellt...

Anatol


-----------------------------------------------------------------------------



Re^11: liste hin und liste her (Jiddu, 17. Feb 1999, 22:01:49):
~#! rn=Anatol rt=919288858 rg=gilden.zauberer
~#! tid=919085861
Hey mein Erstie ist Wurstzauberer ok? .)

-----------------------------------------------------------------------------



Erfahrungen beim Lernen (Spellfire, 18. Feb 1999, 04:06:35):
Moin,
ich wollte nur mal frage ob das nur bei mir so ist, oder ob ich was falsch
machen, dann waere ich fuer Tips dankbar. Ich habe heute den ganzen Tag
schnell geuebt, dabei 150-200 Federn und 17706 Kps (von denen ca 80% fuer
schnell), das einzige was es mir gebracht hat ist ne Menge Schulden bei
Freunden und ne Steigerung von aeusserst uebel aus sehr uebel. Ich weis ja das
das lernen nicht linear ist, aber kreis rund? 
Gaebs nicht die Moeglichkeit die Zauberbremse oder so wieder zu dem zu machen
was der Name sagt? Ein Teil was mich bei nem Spruch behindert, soda ich mehr
Misserfolge habe die in Lernerfolg resultieren?
Oder zu mindest den Preis fuer manche Kompos senken....
So ist meine erster Artikel inner mpa und bin jetzt auch muede und frustriert.
Ein gut Maggi wuenschender Spellfire

-----------------------------------------------------------------------------



Re^8: liste hin und liste her (Anakin, 18. Feb 1999, 10:07:31):
~#! rn=Teddy rt=919279585 rg=gilden.zauberer
~#! tid=919085861

>Schade Key, du scheinst bislang als einziger nicht gelesen zu haben was ich
>geschrieben habe.

Ich habs auch nicht gelesen.

Anakin.

-----------------------------------------------------------------------------



Re^9: liste hin und liste her (Nonne, 18. Feb 1999, 11:19:49):
~#! rn=Anakin rt=919332451 rg=gilden.zauberer
~#! tid=919085861
komisch, ich schon.

Nonne. einzeilend

-----------------------------------------------------------------------------



Re^10: liste hin und liste her (Anakin, 18. Feb 1999, 16:16:11):
~#! rn=Nonne rt=919336789 rg=gilden.zauberer
~#! tid=919085861

Was ist daran komisch, dass ich den Artikel nicht gelesen habe?

Anakin.

-----------------------------------------------------------------------------



Re^9: liste hin und liste her (Teddy, 18. Feb 1999, 21:39:55):
~#! rn=Anakin rt=919332451 rg=gilden.zauberer
~#! tid=919085861
Hm, wiederspricht sich das nciht? ,)

Teddy

-----------------------------------------------------------------------------



Re^11: liste hin und liste her (Trauma, 18. Feb 1999, 21:40:46):
~#! rn=Anakin rt=919354571 rg=gilden.zauberer
~#! tid=919085861
naja lies ihn, steht ja noch in der mpa

-----------------------------------------------------------------------------



Stabgimmick (Tami, 22. Feb 1999, 21:42:37):
Hi Ihr!

Anscheinend bin ich wohl die einzige, die sich hier ueber neu eingefuehrte
Stabgimmicks wie "shield" wundert. Vielleicht ist es auch einigen noch
ueberhaupt nicht aufgefallen, was dieses "tolle" Gimmick bewirkt.
Nicht, dass die eigentliche Idee nicht witzig waere, jemanden von Magie
abzuschirmen. Nur frag ich mich, was dieses Gimmick im MG bewirken soll.
Dazu fallen mir genau 3 Sachen ein:
Unerkannte PKs begehen, wenn man nen Spieler im richtigen Moment von seinen
magischen Faehigkeiten trennt. So ein verhinderter Teleport kann schon recht
toedlich enden.

Ohja, man kann Leute, die nen niedrigeren Level haben als man selbst nen paar
Minuten am Metzeln hindern. Diejenigen werden sich bestimmt masslos ueber so
eine Aktion freuen.

Oder die dritte Variante:
Arenakaempfe gegen zaubernde Gilden machen jetzt besonders viel Spass, da man
sich ja mittlerweile gegen Froschen schuetzen kann, hat man jetzt endlich
wieder das Mittel einen Arenagegner totzuidlen.

Kommen wir nun zu den positiven Eigenschaften eines solchen Gimmicks...
...hm da faellt mir "spontan" nicht eine einzige ein. Hoechstens, dass man so
einfach ohne PK sein Feindschaftsband um einige Namen erweitern kann.
#
So, ich hab meinen Senf dazu jetzt mal geschrieben. Das Gimmick ist meiner
Meinung nach absolut UEBER! Das Teil waer was fuer nen PK-Mud und hat hier im
MG keine Daseinsberechtigung!

-----------------------------------------------------------------------------



Re: Stabgimmick (Patryn, 23. Feb 1999, 01:41:07):
~#! rn=Tami rt=919719757 rg=gilden.zauberer
~#! tid=919719757
wie waere es, wenn du dich mal ueber das ausnutzen und weitergeben des
monatelang kursirenden lernbugs beschweren wuerdest?! wenn ich mir deine
skills ansehe und mit onlinealter und heissen tips vergleiche...
das ist weitaus unanstaendiger gegenueber seinen mitspielern als ein
verfehltes shield, was obendrein mitgelogt wird.

------
patryn

PS: in einem pk-mud waeren spells wie shield und invis fuer spieler
    uebrigens bedenkenswerter als hier, da sitzt du einem fehlurteil auf


-----------------------------------------------------------------------------



Re: Re: Stabgimmick (Asmodis, 23. Feb 1999, 02:28:51):
~#! rn=Patryn rt=919734067 rg=gilden.zauberer
~#! tid=919719757
Aber nett, dass die Zauberer immer weiter aufgeruestet werden :-)

P.S.: invis gibts im PK auch

-----------------------------------------------------------------------------



Re^3: Stabgimmick (Patryn, 23. Feb 1999, 02:32:24):
~#! rn=Asmodis rt=919736931 rg=gilden.zauberer
~#! tid=919719757
du willst doch jetzt nicht ernsthaft DAS pk-mud mit dem woertchen balance
in verbindung bringen? dort hauen nicht zuletzt viele spieler ab, weil
gewisse invis/festhalte/spezialparalyze-sachen den aelteren spielern
die laune verdorben haben. gegen unvorherzusehende angreifer und
unausgewogene fesselspells hat man auch als HLP keine chance....
ueber aufgeruestete zauberer lache ich jetzt einfach mal, und es lachen
gewiss so an die 280 zauberer mit.

------
patryn

-----------------------------------------------------------------------------



Re^4: Stabgimmick (Anatol, 23. Feb 1999, 02:35:49):
~#! rn=Patryn rt=919737144 rg=gilden.zauberer
~#! tid=919719757
Das PK-Mud ist wirklich kein PK-Mud, sondern ein konzeptloses Irgendwas.
Aber mitlachen tu' ich trotzdem nicht, Patryn :o). Hoechstens ueber die
Gleichgueltigkeit diverser gildenbetreuender Magier. Und selbst das ist
eigentlich eher zum Heulen... 

Anatol


-----------------------------------------------------------------------------



Re^4: Stabgimmick (Asmodis, 23. Feb 1999, 06:09:40):
~#! rn=Patryn rt=919737144 rg=gilden.zauberer
~#! tid=919719757
Nunja, dann will ich mal behaupten, wer die hiesigen Supermonster
ueberlebt, der ueberlebt auch in PK :-)

-----------------------------------------------------------------------------



Re: Re: Stabgimmick (Ringor, 23. Feb 1999, 10:03:43):
~#! rn=Patryn rt=919734067 rg=gilden.zauberer
~#! tid=919719757
Was war jetzt eigentlich Deine Rechtfertigung, dass Du das "shield"
angeschlossen laesst? Doch wohl nicht diese von Dir so gerne benutzte Ausrede
mit dem Mitloggen, oder?

Das tust Du ja angeblich auch beim Portal. Schade nur, dass die Logfiles
anscheinend keiner liest. Oder warum kann man mit dem Portal noch immer
ungehindert jede Scheisse anstellen, die man moechte?

Das Shield wurde so nie von Silvana genehmigt. Es ist wider jede Balance und
kann boese missbraucht werden - Logfile oder nicht. Wenn andere Gildenmagier
auf eigene Faust solche Klamotten anschliessen, bekommen sie ordentlich einen
auf den Deckel. Warum Du eigentlich nicht?

Ringor

P.S: Dass das Ganze jetzt in der MPA ablaeuft, ist schade, aber auf Mails
reagiert Patryn leider nicht. 

-----------------------------------------------------------------------------



Re^5: Stabgimmick (Mahatmu, 23. Feb 1999, 14:57:14):
~#! rn=Asmodis rt=919750180 rg=gilden.zauberer
~#! tid=919719757
Da bezweifle ich arg.
Du hast in letzter Zeit zu oft in PK gemagiert anstatt hier zu spielen .

Gloin

-----------------------------------------------------------------------------



Re^3: Stabgimmick (Patryn, 23. Feb 1999, 16:16:44):
~#! rn=Ringor rt=919764223 rg=gilden.zauberer
~#! tid=919719757
warum sollte ich mich rechtfertigen...keine lust.
ich hab mir nochmals das portallog durchgeschaut...der absolut groesste
teil geht zu diversen kneipen, friedhofskneipe zum beispiel. ja, das ist
sogar im sinne des erfinders. der naechste grosse batzen geht
unverstaendlicherweise in seherhaeuser...nun ja, wers braucht.
dann bleiben noch etwa 5%, von denen ich die meisten auf den ersten blick
als ungefaehrlich einstufen kann und der rest kann man per hinhueppen testen.
es gab 2 spruenge in quests, wobei das nur sinn in quests bringt, wo
man irgendwelche items holt, die man weitergeben kann. das war einmal(!)
archi...das kann ja nicht viel weiter gebracht haben, und einmal glaub ich
puma. lass mich bitte an deiner weisheit teilhaben und sende mir mal ne mail,
was fuer unsinn so mit dem portal gemacht wird. danke.

------
patryn

-----------------------------------------------------------------------------



aenderungen (Patryn, 23. Feb 1999, 19:18:57):
hi ihrs,

* die berechnungsformeln fuer hand haben sich grundlegend geaendert,
  stabielere werte, jedoch werden auch ausreisser nach oben radikal
  eingekuerzt. auch bei den kompos wird sich in den naechsten tagen da
  noch was tun, die hand sollte eher die ausnahme, und nicht die regel sein
* fuer shield muss man etwa 4 mal bessere werte als der gegner haben, also
  level/maxmagiepunkte/magiepunkte, kleiner teil success, wille zaehlt rein
* frosche klappt nicht mehr auf leute mit wille, auch bei sich selbst nicht,
  wird nun extra abgefangen
* allgemeines frosch-abfangen des wille-objektes veraendert, der bug mit
  bleibenden negativ-stats fuer kraft sollte behoben sein

------
patryn

-----------------------------------------------------------------------------



Re: Re: Stabgimmick (Taragon, 23. Feb 1999, 22:45:08):
~#! rn=Patryn rt=919734067 rg=gilden.zauberer
~#! tid=919719757
> verfehltes shield, was obendrein mitgelogt wird.
Hmmm, heisst das man kann shield zwar anwenden, aber wenn man das tut wird man
getreten weil da jemand anhand des Logfiles dann sagt dass das boese war ?

Taragon - auf stabhilfe shield wartend :-)

-----------------------------------------------------------------------------



ruestungen (Patryn, 24. Feb 1999, 00:11:06):
hi ihrs,

nach endloser wuehlerei hab ich nun endlich ne hypothese zur
ruestungsunterstuetzung. da es mir nunmehr gelungen ist, zwei ruestungen
dort einzutragen, kann man das problem nun doch mal angehen.
bitte schickt mir einfach mal vorschlaege, was was unterstuetzen koennte,
natuerlich unter beachtung, was fuer ruestungstypen was unterstuetzen
duerfen und in vernuenftigen massen. (mittel/schlecht/gut/sehr gut und so)
ich will nicht: in dem gebiet gibts viele ruestungen, such mal durch.
meine rl-zeit steht momentan auf kriegsfuss mit mud-problemen.

------
patryn

-----------------------------------------------------------------------------



Re: ruestungen (Key, 24. Feb 1999, 19:17:52):
~#! rn=Patryn rt=919815066 rg=gilden.zauberer
~#! tid=919815066
Zu Zauberer und Ruestung faellt mir nen bisserl was ein:
Schuhe: Sandalen! Mehr brauchen die nicht, Ruestungsklasse 1?
Hose: Stoffhose ohne irgendwelchen Schutz gegen Magie, Wie Jaegerhose oder so.
Ruestung: Keine
Umhang: Koennte man was nettes nehmen, allerdings auch ohne Magieschutz ....
Hmm faellt mir spontan auch nur der gruene Umhang von Paracelsus ein .... oder
Robe oder wie auch immer :) Oder das Teil von Morgoth :)
Hmm Hut ... Ausser nem Zaubererhut passt nix dazu ... auch von Morgoth ...
Amulett ... Steini?
Hmm ring ... ziemlich egal ..

Worauf ich hinauswill ist ganz einfach ... Zauberer sind fuer mich
Magiebegabte Wesen, die keinen grossen Wert auf Ruestung legen.
Und deren Ruestung sollte auch net unbedingt magisch sein .... Sonst koennten
sich ja Kurzschluesse bilden .)

Achja noch eins .... Patryn ich weiss net was Du da staendig rumwurschtelst
wie nen irrsiniger!
Kann die Gilde netmal ne Woche ohne irgendwelche Veraenderung leben?
Staendig was neues, was geaendertes .... Denk mal drueber nach ob das so
wichtig ist.

Key

P.S.: An den meissten Gilden wird Monatelang, ja sogar jahrelang nix gemacht
und sie gefallen den Leuten trotzdem. 

-----------------------------------------------------------------------------



Re: Re: ruestungen (Anatol, 24. Feb 1999, 19:23:03):
~#! rn=Key rt=919883872 rg=gilden.zauberer
~#! tid=919815066
Aehm, Key... kann das sein, dass Tuareg etwas inaktiv war in letzter Zeit?
Tuareg als Zauberer braucht, wenn er halbwegs brauchbar Leistung zeigen 
moechte, Ruestungsteile, die seine Zauber unterstuetzen. Als Beispiel:
Der Ring des Feuers aus der Feuerebene unterstuetzt die Sprueche "hand",
"erzwinge" und "verletze", also Angriffszauber, wie alle Ringe. Aber
er unterstuetzt sie nur maessig. Es gibt auch Ringe, die "hand" wirklich
super unterstuetzen, damit kannst Tuareg dann Haeuser abfackeln. Aber...
"verletze" kann er dann ... na, sagen wir: zu 3/4 des Moeglichen.

Das Problem derzeit ist, dass aufgrund der nur spaerlich gemeldeten 
Ruestungsteile die meisten Zauberer doch recht uniformiert herumlaufen.
Was - finde ich - sehr schade ist. Dass Patryn hier (endlich ? :)) etwas
Energie reinsteckt, ist meiner Meinung nach echt ok. 

Nix gegen ein "Wir hacken auf Pa* herum!". Aber bitte begruendet :)

Anatol


-----------------------------------------------------------------------------



Re: Re: ruestungen (Mahatmu, 24. Feb 1999, 19:25:15):
~#! rn=Key rt=919883872 rg=gilden.zauberer
~#! tid=919815066
Ich weiss net, ob die einen Lichtspell haben, aber die Lichtxxx als Boost
fuer den duerfte eventuell ganz gefaellig fuer Anfaenger sein ... Du be-
greifst das Prinzip?
Und MUD sowie Gilde leben von Veraenderung. Nur die Opis noergeln immer.

Mahatmu

-----------------------------------------------------------------------------



Re^3: ruestungen (Key, 24. Feb 1999, 19:27:53):
~#! rn=Anatol rt=919884183 rg=gilden.zauberer
~#! tid=919815066
Hmmm ja stimmt, Tui ist lahmgelegt ....

Ich wollte doch nur auf folgendes hinaus:
Die Gilde aendert sich so oft das man nach einem Tag netmehr weiss ob der
Spruch ueberhaupt noch existiert den man gestern lernte.
Ausserdem find ich Zauberer die sich verkleiden wie nen Kaempfer reichlich
beknackt ....
Hmm die Sache mit den Ringen .... irre ich mich oder waere das gar net zur
Diskusion wenn die Gilde net staendig geaendert wuerde? 

Key

-----------------------------------------------------------------------------



Re^3: ruestungen (Key, 24. Feb 1999, 19:29:32):
~#! rn=Mahatmu rt=919884315 rg=gilden.zauberer
~#! tid=919815066
"Und MUD sowie Gilde leben von Veraenderung."

Veraenderung? Ja schoen, aber muss die staendig sein? Bzw wieso nix neues?
Alte Gebiete werden ja auch net jede Woche einmal geaendert .... Obwohl es
einiges gibt das ne Ueberarbeitung noetig haette ...

Key

-----------------------------------------------------------------------------



Re^4: ruestungen (Anatol, 24. Feb 1999, 19:32:46):
~#! rn=Key rt=919884473 rg=gilden.zauberer
~#! tid=919815066
Die Geschichte mit den spruchbeeinflussenden Ruestungsteilen ist nicht
auf Patryns Mist allein, sondern eher auf einer Duengemischung einiger
Seher und der beiden damaligen Gildenmagier Silvana UND Patryn gewachsen.
Hintergedanke war, diejenigen Zauberer, die ausser dem Uebungsraum und der
Kneipe nichts vom Leben als Zauberer kannten, ein wenig von denen, die
wirklich etwas vom Mud wissen und 2 + 2 ohnehin zusammenzaehlen koennen,
zu differenzieren. 
Es ist vielleicht nicht GANZ das herausgekommen, was beabsichtigt war, 
aber daran kann man noch arbeiten, dazu sind VERAENDERUNGEN ja da. Und
nun geh weiter Tode abidlen, Key ;o)

Anatol


-----------------------------------------------------------------------------



Lernen buggy ? (Taragon, 24. Feb 1999, 23:03:23):
Hallo !
schutz
Ich weiss nicht ob es nur mir so geht oder ob noch mehreren das Phaenomen
aufgefallen ist... aber es kommt mir vor als koenne ich nicht richtig lernen.
In den letzten 5 Tagen habe ich licht von 'befriedigend' auf 'ziemlich gut'
hochbekommen durch einfaches Anwenden und dabei aus Erfolgen gelernt.
Komischerweise ist das aber haargenau der einzige Spruch bei dem ich
ueberhaupt was gelernt habe in dieser Zeit... das ist irgendwo nicht logisch.
Der Rest meiner Sprueche befindet sich im Gebiet von 'ausreichend' und sollte
demnach ebenfalls 'lernbar' sein.
Vielleicht ist da ja wirklich was buggy und es faellt nur keinem auf weil die
meisten schon fast auf max sind :-)

-----------------------------------------------------------------------------



Re: Re: ruestungen (Patryn, 25. Feb 1999, 00:16:03):
~#! rn=Key rt=919883872 rg=gilden.zauberer
~#! tid=919815066
kann es sein, dass du derzeit eine gewisse 0-bock-stimmung aufs mud hast
und diese auch von anderen erwartest? :)
die mitglieder der gilden, an denen jahrelang nichts gemacht wurde, sind
auch nicht eben die gluecklichsten.
das erste gildenkonzept fuer ruestungen wurde irgendwann mal aufgegeben,
da war es durchaus so, dass zauberer nur sandalen und robe zu tragen
hatten, bzw. absolut schwaches zeugs. das wurde irgendwann so umfunktioniert,
dass rueste jetzt weitaus weniger bringt als frueher, aber man praktisch
auch bessere beliebige ruestungen zulassen kann, die zusaetzlich
spells unterstuetzen. mit dieser aenderung hatte ich uebrigens absolut
nix zu tun, deshalb straeubte ich mich so lange...
nun ja, ich weiss, dass dort was gemacht werden muss, also mach ich es.
 (im uebrigen auf flehende mails vieler spieler hin)
das naechste, was auf alle einfluss hatte, sind die balanceanpassungen:
 wie du evtl. weisst, wurden sie in allen gilden vorgenommen, und sind
keinesfalls auf meinem mist gewachsen.
dann gabs noch die grosse aenderung lernsystem: auch damit hatte ich bisher
absolut nix zu tun. auch dort muss was gemacht werden, aber wenn ich mich
versuche, da reinzuknieen, schwirren mir nach ner halben stunde
wuehlerei nur noch randoms, ifs, thens, offsets, faktoren und so weiter
um die ohren. an tausend stellen sind irgendwelche lernsachen eingebaut.
es ist nicht gerade leicht, sich da reinzufinden, wenn man es nicht geproggt
hat und es nicht dem standardgilden-lernsystem folgt.
drei umfassende aenderungen, mit denen ich also nich viel zu tun hatte :)

alle anderen sachen sind doch eher dinge, mit denen du nie in beruehrung
kommst, wenn du nicht willst. verschiedene spells koennen mehr, wenn man
halt verschiedene sachen besorgt oder mehr sp investiert, mehr
konzentrationszeit und so weiter.
auf die normalen spells hatte es relativ wenig einfluss.
was genau willst du nun eigentlich? dass ich einmal laut rufe: die gilde ist
nun fertig und bleibt so, wie sie ist, und alles fallen lasse?
ich hoffe mal, du bist der einzige, der das so sieht, sonst waere es schade
um meine zeit...

------
patryn

-----------------------------------------------------------------------------



Re^3: ruestungen (Anacrion, 25. Feb 1999, 00:58:57):
~#! rn=Patryn rt=919901763 rg=gilden.zauberer
~#! tid=919815066
Also erstmal: ich finde das toll, dass an unserer Gilde was passiert. Das
Handlungsbedarf da ist, sieht man ja, aber es ist nicht die einzige Gilde wo
das so ist .. und hier passiert wenigstens was :)
Im Rahmen dieses Absatzes also noch schnell einen kleinen Dank nach Dresden :)

Zum Thema Ruestungen: Ich persoenlich finde ja die Idee, dass sich Zauberer in
schwere Pazer huellen, ziemlich absurd. Wenigstens ist es so, dass wir skeine
Metallruestung verwenden, sondern nur welche aus (ueber-)natuerlichen
Materialien wie Seide, Nacht, Hydraschuppen, Jade u.v.m. Das Konzept mit
uznterstuetzenden Ruestungen dagegen finde ich nichts so gelungen. Die Idee
finde ich im grossen und ganzen eigentlich gut, naemlch bei der Spruchstaerke
nicht nur en Skill sondern auch die Wurstigkeit bzw. das Gegenteil zu
beruecksichtigen. Wenn ich mir allerdings einen Zauberer vorstelle, dann ..
rennt der nicht in Klamotten rum, die ne gesamt-Ac von nahe 100 haben, sondern
hat ehr die auch in der fruehen ZaubererFAQ beschriebenen Sandalen mit ner
Robe an, lacht die Kaempfer aus, die sich so schwer mit Eisen behaengen
muessen ud schuetz sich auf magischem Wege. Das einzige was er trgt sind
Amulette, Ringe, Robe, Sandalen, im Gebirge evtl. Handschuhe (obwohl er sich
ja auch magisch gegen Erfrierungen schuetzen koennte ;) und nen Zaubererhut.
Auch soll es Zauberer geben, die einen (nicht behindernden) magischen
Stirnreif tragen. 
Waere es nicht besse, die maximale Fertigkreit (100%) nicht bei 35 sonden
einer hoeheren Stufe anzusetzen ? selbstverstaendlich so, dass man mit LVL5
auf jeden Fall 80% ueberall haben kann (auch in schweren skills mir Rating 600
fuer eingeweihte). Damit trennt man auch spreu vom Weizen, kann abe di
Zauberer auf den Weg der tugend zurueckfuehren der sich in der ablehnung
jeglicher Ruestung aeussert (oder so)


Das die Learnfuncs wie in anderm Artikel erwaehnt geaendert muesn (teilweise)
ist klar, jedoch ist das Lernsystem (wie Patryn schrib) sehr komplizier und
man muss neue Wertein Funktionen erstmal empirisch testen. 

Im Uebrigen hoffe ich, dass die neuen gildengebaeude bald fertig sind (ab 3.3.
bin ich wieder voll dabei, Patryn ;) ) und dass nicht mehr soviel rumgeflamed
wird. 

Anacrion - Zauberer aus Leidenschaft, nicht wegen Krampfkraft

-----------------------------------------------------------------------------



Re^4: ruestungen (Anacrion, 25. Feb 1999, 01:00:05):
~#! rn=Anacrion rt=919904337 rg=gilden.zauberer
~#! tid=919815066
Ups. also ein paar kleine Aenderungen (musste blind tippen) also 80% bei
LVL35, einzelne Buchstaben bitte reindenken :)
Gruss und Kuss
Anac*

-----------------------------------------------------------------------------



Re^5: ruestungen (Anatol, 25. Feb 1999, 01:24:05):
~#! rn=Anacrion rt=919904405 rg=gilden.zauberer
~#! tid=919815066
Es faellt mir schwer, ein Reply auf dieses so gehaltvolle und durchdachte
Statement Anacrions zu verfassen, ohne dabei Worte wie "naiv", "wurstig"
oder "einfaeltig" in persoenlich beleidigender Weise anzubringen, aber ich
versuche es, mutig und hoffnungsvoll wie immer, dennoch.

Sag mal, Anacrion, welcher traurige Hund hat Dir den Mega-Floh ins Ohr
gesetzt, dass man Zauberer-Faehigkeit ausgerechnet an der Spielerstufe
messen kann?

Hach Mist, jetzt kaeme der Punkt, wo ich auf seinen eigene Spielerstufe
hinweisen muesste. Das koennte er - zurecht - persoenlich nehmen. Ich
belasse es also besser bei dem, was ich bis hierher schrieb und begnuege
mich mit der Anmerkung, dass ich "Gruss und Kuss" nicht auf meine Person
angewendet wissen moechte. Nun, zumindest nicht von ihm.

Anatol


-----------------------------------------------------------------------------



Aenderungen (Patryn, 25. Feb 1999, 02:15:57):
Hi Ihrs, auch heute ein paar Aenderungen, doch eher kosmetischer Natur:
* der Zauberstab-bug, welcher grundsaetzlich nach Lehrlingspruefung
  auftauchte, ist entfernt
* zu diesem Zweck wird von nun an nicht mehr auf Gildenlevel groesser gleich
  5, sondern auf bestandene Lehrlingspruefung gecheckt
* das gleiche gilt fuer die Liste, nich wundern, wenn auch nen 4er Level
  da drin auftaucht...frueher konnte man ja gleich erhoehen nach Bestehen
  der Lehrlingsquest, jetzt braucht man noch Zaubererquestpunkte vorher
* Magier haben Lehrlings- und Magisterquest automatisch bestanden
* zum Wolle besorgen gibts bei einem gewissen Penner nun noch ein lustiges
  Item
Das wars erstmal, na ja...ausser einer Spielpause auf unbestimmte Zeit.
Alle die was fuer mich basteln, machen bitte erstmal weiter...evtl.
koennen wir uns ja mal auf der Party verstaendigen. Ich weiss, das nehmen
wir uns jedes mal vor, aber es kam meist nur zu Einzelgespraechen :)
Also wer was hat, schreibe es auf und bringe es mit. Wir koennen dann
bei einem Bier ueber Sinn und Unsinn diskutieren *grins*

------
patryn

-----------------------------------------------------------------------------



Re: Aenderungen (Mahatmu, 25. Feb 1999, 03:18:40):
~#! rn=Patryn rt=919908957 rg=gilden.zauberer
~#! tid=919908957
Bier? Du?

Mahatmu bringt Martini mit.

-----------------------------------------------------------------------------



Re^3: ruestungen (Key, 25. Feb 1999, 08:40:30):
~#! rn=Patryn rt=919901763 rg=gilden.zauberer
~#! tid=919815066
Hmm was ich will? Maoam oder wie das Zeug heisst :)

Nee ernsthaft, ich finde es im natuerlich gut wenn was an der Gilde gemacht
wird, nur machst du soviel das es inzwischen ne neue Gilde ist. Und dabei
zaehlen auch kleine Aenderungen, von denen es einige gab.

Balance ist klar, aber irgendwie haben das die meissten Gilden mit nen paar
kleinen Aenderungen in max. 2 Monaten durchgezogen, bei Dir dauern die
Aenderungen seit ca 1 Jahr an.

Ansonsten fuer alle die es falsch verstanden haben:
Nein ich hab im Grunde nix gegen Aenderungen. Und finde es gut von
verschiedenen Mags wenn sie was aendern.


Key

-----------------------------------------------------------------------------



Re^6: ruestungen (Anacrion, 25. Feb 1999, 13:27:31):
~#! rn=Anatol rt=919905845 rg=gilden.zauberer
~#! tid=919815066

Ich denke nicht, dass man Zaubererfaehigkeit in Spielerstufen messen kann.
Sollte das so ruebergekommen sein, bitte ich dies zu entschuldigen. Ich glaube
allerdings, dass der Besitz von unterstuetzenden Ruestungenkeinerlei Ausssage
ueber die Faehigkeiten als Zauberer trifft. Aus diesem Grunde halte ich Deine
Kritik fuer reht .. aehm. ach nien. Ich moechte nicht auf die von Dir aus
gutem Grundne vermiedene Semantik zurueckkommen, Anatol :)
Faktum ist, dass man sich Forscherpunkte ud Kills holen muss, um
aufzusteigen.Das erreichen von beiden Dingen spiegelt meines Erachtens
durchaus etwas Kenntnis des Muds wieder und selbst Duz wirst mir zustimmen,
dass gerade die ppar Zauberer, die _keine_ wuerste sind ( ich berufe mich da
auf Morgoths angaben) jenseits der LVL60-Grenze sind, da sie doch durhcaus
eine grosse Zahl von Kills und FPs besitzen.
Es ist nicht so, dass ich ein derartiges System als der Weiheit letzten
Schluss sehe, aber das momentane System ist es definitv nicht ...allein, wenn
ich mir meinen eigenen Ausruestungsbeschaffungsmarathon angucke, der nicht nur
fuer mich, sondern auch fuer eione gewisse zZahl befreundeter Zauberer gedacht
ist, die von meinen Schlagringen, Jaderuetungen undzaubererhueten bestimmt
keine bessere Kenntnis des MGs erlangt haben.

Gruss 
Anacrion (Fuehle sich gekuesst wer moege)

-----------------------------------------------------------------------------



Re^7: ruestungen (Morgoth, 25. Feb 1999, 13:29:48):
~#! rn=Anacrion rt=919949251 rg=gilden.zauberer
~#! tid=919815066
Du hast da ein bischen was falsch verstanden. Einige von denen, die ich
aufgezaehlt habe sind noch nicht einmal LVL50. ;-)
Und Ruestungsteile gibt es wirklich zu hauf...
Ich will jetzt nicht wieder sagen, dass man bei mir das meiste findet, aber
rein hypothetisch koennte man das mal behaupten ;-))

M*

-----------------------------------------------------------------------------



Re^8: ruestungen (Anacrion, 25. Feb 1999, 13:33:58):
~#! rn=Morgoth rt=919949388 rg=gilden.zauberer
~#! tid=919815066
Hmm. Stimmt. Ihre Ersties aber nicht. *gruebel* ..  Na ja . Wohl einer der
Punkte, wo das System nicht greift .. 

Wer kann der kann : jo. genau :) Ich wollte ja nicht nur das ruestungssysem in
den Schmutz ziehen snndern auch ne Alternative bieten. Wenn die betreffenden
Spieler die ZUweities mal ein paar kills machen liessen, die sie mit
sicherheit schaffen wuerden ( ;) ) dann haette sich das ja erledigt. 

Anac*

-----------------------------------------------------------------------------



Re^6: ruestungen (Ariana, 25. Feb 1999, 18:18:36):
~#! rn=Anatol rt=919905845 rg=gilden.zauberer
~#! tid=919815066
also, ich moecht mich jetzt nich in die fachdiskussion einmischen (bevor du
was ueber meine spielerstufe sagen moechtest) aber ich denke, ihr solltet eure
persoenlichen beleidigungen per mail abwickeln, es nervt ziemlich.
und was immer patryn vielleicht tut, oder nich tut, bei bugs is er fuer kleine
spieler recht schnell erreichbar, was ich hier net von jedem sagen kann.

ariana *langsam wirklich genervt*

-----------------------------------------------------------------------------



Re^4: Stabgimmick (Teddy, 25. Feb 1999, 20:59:03):
~#! rn=Patryn rt=919786604 rg=gilden.zauberer
~#! tid=919719757
Diese Mail hast du von diversen Leuten bereits nach der letzten Party
gekriegt, Reaktion=0!

Teddy, begeistert von soviel Bereitschaft zur Zusammenarbeit.

-----------------------------------------------------------------------------



Neuer Punkt 'generell' ? (Taragon,  1. Mar 1999, 14:02:43):
Hi !

Mir ist gerade aufgefallen, dass Lly irgendwie einen Punkt 'insgesamt' seit
Neuestem zu haben scheint...
Im Zaubern bin ich ziemlich gut laut Lly, und die Sprueche sind auch alle
mindestens ausreichend, die meisten befriedigend und zwei sind ziemlich gut.
Trotzdem meint Lly bei 'insgesamt':
Du teilst Llystrathe mit: insgesamt
Llystrathe sagt: Du bist generell gesehen, gemessen an Deinem Gildengrad
Llystrathe sagt: aeusserst uebel.

Kann mir mal einer erklaeren was dieser Wert aussagen soll und wie der
zustande kommt ?

Taragon

-----------------------------------------------------------------------------



Re: Neuer Punkt 'generell' ? (Tunixgut,  1. Mar 1999, 14:03:37):
~#! rn=Taragon rt=920296963 rg=gilden.zauberer
~#! tid=920296963
Da spielen Koerpergeruch und Kleidung mit rein... :o))

's Karate-Zwerchle - auf Grimmborn wartend...

-----------------------------------------------------------------------------



Re: Re: Neuer Punkt 'generell' ? (Taragon,  1. Mar 1999, 14:08:25):
~#! rn=Tunixgut rt=920297017 rg=gilden.zauberer
~#! tid=920296963
> Da spielen Koerpergeruch und Kleidung mit rein... :o))
Bin ich Zwerg oder was ? Wasche ich mich mit Huehnerkacke ? :-))))

-----------------------------------------------------------------------------



Re^3: Neuer Punkt 'generell' ? (Dieder,  1. Mar 1999, 14:09:17):
~#! rn=Taragon rt=920297305 rg=gilden.zauberer
~#! tid=920296963
seit wann waschen Zwerge sich??? :)))

Dieder

-----------------------------------------------------------------------------



Re^4: Neuer Punkt 'generell' ? (Taragon,  1. Mar 1999, 14:11:08):
~#! rn=Dieder rt=920297357 rg=gilden.zauberer
~#! tid=920296963
> seit wann waschen Zwerge sich??? :)))
Seit dem sie ohne Waesche noch besser riechen wuerden wie mit Huehnerkacke
:-))

Tara Gone

-----------------------------------------------------------------------------



entsorge (Hood,  1. Mar 1999, 18:04:19):
### ACHTUNG! ###

aus technischen gruenden zerstoert das entsorge ab jetzt auch den inhalt
von containern, falls die container als zu entsorgendes objekt angegeben
wurden. dies gilt auch fuer leichen! also erst rausnehmen, dann leiche
entsorgen.
als nebeneffekt sollte es nun noch etwas schwerer werden, npcS zu betreten.
ach ja: solllte ein objekt innerhalb das paketes nicht zerstoerbar sein,
so wird auch das paket nicht zerstoert. (also jetzt container==paket)
sollte das paket nicht zerstoerbar sein, wegen verflucht oder sonstwas, dann
wird trotzdem versucht, dessen inhalt zu zerpfluecken.

------
patryn

-----------------------------------------------------------------------------



Re: entsorge (Anatol,  1. Mar 1999, 21:04:21):
~#! rn=Hood rt=920311459 rg=gilden.zauberer
~#! tid=920311459
Viel Aufstand fuer ein bisschen Padreic ;) ?

Anatol - kann sich das Laestern nicht verkneifen


-----------------------------------------------------------------------------



Re: Re: entsorge (Hood,  1. Mar 1999, 22:52:26):
~#! rn=Anatol rt=920322261 rg=gilden.zauberer
~#! tid=920311459
na ja, waren nur 3 zeilen ++,
das war padreic gerade noch so wert :)

------
patryn

-----------------------------------------------------------------------------



Re: Neuer Punkt 'generell' ? (Jehova,  2. Mar 1999, 00:59:18):
~#! rn=Taragon rt=920296963 rg=gilden.zauberer
~#! tid=920296963
gildenquests spielen da glaube auch mit rein.

jOSjOSj*
+#2345678!".

-----------------------------------------------------------------------------



Re: Re: Neuer Punkt 'generell' ? (Jehova,  2. Mar 1999, 00:59:54):
~#! rn=Jehova rt=920336358 rg=gilden.zauberer
~#! tid=920296963
argh. bloede mac-tastatur. weder tilde noch at kann ich finden :(

-----------------------------------------------------------------------------



Re^3: Neuer Punkt 'generell' ? (Asmodis,  2. Mar 1999, 01:03:11):
~#! rn=Jehova rt=920336394 rg=gilden.zauberer
~#! tid=920296963
Schmeiss die doch weg ...

-----------------------------------------------------------------------------



Re^4: Neuer Punkt 'generell' ? (Jehova,  2. Mar 1999, 01:10:22):
~#! rn=Asmodis rt=920336591 rg=gilden.zauberer
~#! tid=920296963
argh. bin grad an der uni. ich glaube, die werden hier nicht allzusehr erfreut
reagieren, wenn ich sowas mache. und alle anderen kisten sind im moment tot.
(6 ! Pools) und kein admin da ... OS*fluch*

-----------------------------------------------------------------------------



Re^3: Neuer Punkt 'generell' ? (Bynandrel,  2. Mar 1999, 03:46:32):
~#! rn=Jehova rt=920336394 rg=gilden.zauberer
~#! tid=920296963
@ auf dem Mac ist Shift+Alt+1 (Okay, nicht gerade intuituiv :-(, auf der
US-Tastaturbelegung ist es immerhin Shift+2...)
Die Tilde kriegt man, wenn man zuerst alt+n und dann die Leertaste drueckt.
(alt+n sagt dem Rechner "Mach ueber dem naechsten Zeichen ne Tilde" und das
Leerzeichen ist dann ebendieses Zeichen.
Allerdings ist das mit der Tilde bei NCSA Relnet auf dem Mac so ne Sache - bei
mir zumindest schickt er stattdessen irgendeinen anderen Code ans Mud. Ist ISO
8859-1 evtl. nicht die richtige Tabelle?

In dieser Hinsicht leicht ratlos

Bynandrel, der um 3:41 Uhr eigentlich besseres zu tun haben sollte, als
MPA-Posts zu schreiben...

-----------------------------------------------------------------------------



Re^3: Neuer Punkt 'generell' ? (Aline,  2. Mar 1999, 11:53:33):
~#! rn=Jehova rt=920336394 rg=gilden.zauberer
~#! tid=920296963

at = @ = option + shift + 1

tilde = ~ = option + n

Wo ist das Problem?

Aline arbeitet nur mit Macs

-----------------------------------------------------------------------------



Re^4: Neuer Punkt 'generell' ? (Acrimon,  2. Mar 1999, 18:10:57):
~#! rn=Bynandrel rt=920346392 rg=gilden.zauberer
~#! tid=920296963
Doch, iso-8859-1 ist definitiv richtig.

Acrimon

-----------------------------------------------------------------------------



entsorge (Hood,  2. Mar 1999, 22:06:36):
das handling des befehls hat sich nochmal ziemlich geaendert, stabhilfe 
gibt auskunft.

------
patryn

-----------------------------------------------------------------------------



Re: entsorge (Wim,  3. Mar 1999, 11:43:47):
~#! rn=Hood rt=920311459 rg=gilden.zauberer
~#! tid=920311459

Hmm... also ich habe "entsorge" eigentlich recht haeufig aus Faulheit benutzt:
entsorgen leiche, schau. mal sehen was man nimmt. das unt leiche, nimm X aus
leiche war mir immer zu viel zu tippen...

(irgendwie muss ich mir wohl schnell das nimm saeckchen, entsorgen saeckchen,
abgewoehnen

-----------------------------------------------------------------------------



Re^4: Neuer Punkt 'generell' ? (Jehova,  3. Mar 1999, 20:38:41):
~#! rn=Aline rt=920375613 rg=gilden.zauberer
~#! tid=920296963

das haettest du mir sagen sollen, als ich den artikel geschrieben hatte.
nichtmal ~r konnte ich tippen :) naja, macs ...

bye, j*

-----------------------------------------------------------------------------



teamspruch fuer zauberer (Birdy,  4. Mar 1999, 16:08:52):
Hiho !

In Bezug auf Lenas Artikel in g.klerus moechte ich auch bei uns mal
nachfragen, ob es nicht moeglich waere team-zaubersprueche einzufuehren.
Vielleicht auch gleich einen Spruch, der nur von einem team mit magistern
jedes zweiges gesprochen werden koennte.
Oder ein Spruch, der nur von einem Team alles Erzmagister gesprochen werden
kann.
Nur sone Idee halt. :)  (Und dann auch noch bei Lena geklaut. ;))

Birdy

-----------------------------------------------------------------------------



Re: teamspruch fuer zauberer (Hood,  4. Mar 1999, 18:13:32):
~#! rn=Birdy rt=920563732 rg=gilden.zauberer
~#! tid=920563732
dementsprechend konzepte liegen schon bereit, nur ist es ziemlich
balancekritisch, meinte silvana.
vorgesehen ist ein befehl "link" aehnlich WoT, es kann nur noch einer
zaubern, er hat abber alle magiepunkte der mitglieder, die spells
verbessern sich dadurch je nach groesse des zirkels
 (natuerlich nicht 2 leute, 2-fache staerke, weitaus schlechter und
   exponentiell fallend, anders geht das nich)

ach ja: viel spass bei einer neuen zaubererquest.
ehe grosse protestrufe erschallen: sie ist offensichtlich optional,
wer nich will, braucht nicht. viel spass...

------
patryn

-----------------------------------------------------------------------------



Re: Re: entsorge (Asmodis,  4. Mar 1999, 23:17:04):
~#! rn=Wim rt=920461427 rg=gilden.zauberer
~#! tid=920311459
Das Klassischste ist doch immer noch: iss leiche, nimm alles

-----------------------------------------------------------------------------



Re^7: ruestungen (Jasper, 11. Mar 1999, 01:54:13):
~#! rn=Ariana rt=919966716 rg=gilden.zauberer
~#! tid=919815066
Also wenn man alle persoenlichen Beleidigungen aus der mpa lassen wuerde, dann
wuerde es
maximal 10 neue Artikel/Woche geben :)

Gruntz sagt: zaubern lernen dauert eh zu lange ;P

-----------------------------------------------------------------------------



neue aenderungen braucht das land... (Hood, 11. Mar 1999, 04:32:51):
hi zauberers,

es haben sich diverse ruestungsunterstuetzungen geaendert und auch
neue ruestungen sind dazugekommen. da sich dies in der naechsten woche
weiterhin stark aendern wird, rennt mal nich gleich los neue listen
anfertigen...wollte es nur gesagt haben :)
 (nich dass mir jemand tode anlastet, die auf miesere spells durch diverse
  abwertungen gehen :)

ausserdem hat die neue questbelohnung einen neuen befehl namens "ginhalt"
much fun...

------
patryn

-----------------------------------------------------------------------------



hand (Patryn, 11. Mar 1999, 18:02:16):
hi ihrs,

ab jetzt kostet eine komponentenhand auch ein flaeschchen!!!
immer schoen auf den verbrauch achten :)
ich werd mal noch paar flaeschchen dann unterbringen irgendwo,
aber die feuerhand musste etwas eingedaemmt werden

------
patryn

-----------------------------------------------------------------------------



Re: hand (Ringor, 11. Mar 1999, 23:33:03):
~#! rn=Patryn rt=921175336 rg=gilden.zauberer
~#! tid=921175336
Nur interessehalber:

Hat also Deine Umwertung bei Hand so sehr angeschlagen, dass auf einmal alle
Zauberer nur noch mit Komponenten rumlaufen? Oder woher der ploetzliche
Umschwung von "es metzelt ja keiner mit Kompo-Haenden" auf "die Feuerhand
musste etwas eingedaemmt werden"?

Ringor. Neugierig.

-----------------------------------------------------------------------------



Re: Re: hand (Patryn, 11. Mar 1999, 23:34:54):
~#! rn=Ringor rt=921195183 rg=gilden.zauberer
~#! tid=921175336
Nur interessenhalber:

auf duemmliche polemik muss ich nicht eingehen, oder?

------
Patryn, genervt.

-----------------------------------------------------------------------------



Re^3: hand (Ringor, 11. Mar 1999, 23:51:39):
~#! rn=Patryn rt=921195294 rg=gilden.zauberer
~#! tid=921175336
Mit manchen Leuten machen Diskussionen wirklich immer wieder besonderen Spass.
Bin ich gegen eine Aufwertung der Zauberer, dann bin ich der mudbekannte
Zauberer-Hasser. Hinterfrage ich eine Abwertung der Zauberer, dann ist es
duemmliche Polemik. 

Wenn ich daraus jetzt oeffentlich eine Schlussfolgerung ziehe, dann ist das
wahrscheinlich eine boese Beleidigung oder so, und irgendein sensibler Magier
setzt sich wieder fuer drei Tage "spielpause -1". 

Ringor macht bald einen Goldwaagen-Handel auf.

-----------------------------------------------------------------------------



Re^4: hand (Hood, 12. Mar 1999, 01:15:14):
~#! rn=Ringor rt=921196299 rg=gilden.zauberer
~#! tid=921175336
mudbekannter zaubererhasser? wusste ich gar nich, aber egal.
duemmliche polemik wird deine hinterfragung nicht dadurch, dass sie etwa
erfragt, eher durch den saeuerlichen tonfall.

in der tat wurden die komps seit der abwertung der normalhand sehr viel
staerker genutzt als zuvor. es viel dann auf, dass sich die komponenten
fuer die staerke der hand zu wenig verbrauchen, wenn man dies mit der
derzeitigen verteilung selbiger vergleicht.
der logische schluss war, entweder die komponenten noch schwerer in der
besorgung zu machen (das sterben beim besorgen scheint ja manche nich
 zu stoeren, aber in der jetzigen form reicht das wohl), oder sie
noch mehr zu verknappen (hab sie eigentlich nich allzuviel verteilen
lassen), oder halt das zu machen was auch schon laenger im text steht:
 du schuettest den inhalt des flaeschchens... und da wards verbraucht

und? zufrieden...

------
patryn

-----------------------------------------------------------------------------



Re^5: hand (Ringor, 12. Mar 1999, 10:15:30):
~#! rn=Hood rt=921201314 rg=gilden.zauberer
~#! tid=921175336
Das ist doch eine Erklaerung, mit der auch ein dummer Zwerg wie ich etwas
anfangen kann. Danke.

Ringor. Will gar nicht immer meckern. ;-)

-----------------------------------------------------------------------------



neu (Patryn, 15. Mar 1999, 15:46:27):
hi ihrs,

folgende hilfen sind neu: frosche, entsorge, blocke, stabhilfe, licht
 (bei licht geht option farbe bisher nur fuer schwarz), zstty...hmmm,
 wohl noch ein paar, vergessen
dafuer noetig: teile lllystrathe mit zauberstab, gimmicks aktualisieren
alle spells haben neue suchfunktionen, es sollte nun zb gehen
  identifiziere lolli in schleimbeutel in mir

------
patryn

-----------------------------------------------------------------------------



krankheiten (Patryn, 15. Mar 1999, 19:55:42):
ich hab mal alle bisher unbekannten krankheiten aus einem log in fluchtest
eingebaut, es sollte jetzt etwa 3 mal soviel erkennen wie zuvor.
wenn noch unerkannte krankheiten auftauchen, her mit der info. ich schau
nich immer ins log und alles erkennt es nicht.

------
patryn

-----------------------------------------------------------------------------



lernen lernen lernen (Hood, 16. Mar 1999, 04:14:58):
hi zauberers,

heut mal ein kritisches thema: das lernen :)
ich habe auf der party schon diverse meinungen eingeholt und sie gingen
wie ueblich in alle richtungen. es gibt derzeit eigentlich eine reihe
von zauberern, die im ueben stecken.
ich bitte einen jeden von ihnen um ihre meinung, was derzeit zu hart
zum ueben ist, was zu leicht (ja auch das, vorahnung hatte ich in 3 stunden)
ich kann unmoeglich einen testie hochueben, und mit euch stehen genuegend
leute in der materie.
beruecksichtigt dabei bitte, dass eigene dummheit bestraft wird.
wer kampf- und abwehrspells in der kneipe uebt, hilft mir nicht damit,
mir zu erzaehlen, es ginge zu langsam.
ihr koennt ja zur abwechslung auch mal zuvor miteinander reden...
wenn es so gut klappt wie bei den ruestungen, dann wird sich da auch
sicher was tun, da mir die infos tagelange arbeit ersparen.

nochmals: es gab magisteranwaerter, die meinten, die spells liessen sich
schnell genug hochueben. das system kann also nicht nur muell sein,
objektive einschaetzungen sind erwuenscht.

------
patryn

-----------------------------------------------------------------------------



dummdidumm (Patryn, 17. Mar 1999, 01:07:20):
hi...

# feuerwalze auf reinraus angepasst. natuerlich lebt sie geradezu davon... :)
# erdbeben etwas umgebaut, spruchhilfe erdbeben hilft weiter
# magierzweities fuer normalos nicht mehr in rangelliste sichtbar *grins*
# jeder zweig hat einen 6. posten nur fuer magierzweities erhalten,
  davon sind 5 posten nur fuer spieler zugaenglich, einer nur fuer diese
  zweities, bei gleichen einschraenkungen wie zuvor, ich hoffe mal damit
  dem gildenfrieden etwas auf die spruenge zu helfen.
hinweiss:
  erwischte unmarkierte magierzweities werden rausgeworfen.
  magierzweities die schon einen posten haben, treten zurueck und
   versuchen, neu einzutreten. damit kommen sie in die richtige liste.
  ein zusatzposten pro zweig sollte keine kompo-probleme aufkommen lassen,
   aber normalos haben wie ueblich vorrang.

------
patryn

PS: wenn etwas nich so klappen sollte wie geplant, war ne recht komplizierte
    aenderung, dann mailt es mir bitte.
    soweit es ging, hab ich schon getestet, dabei flogen gleich mal
    viele leute aus dem angriffszweig, neu eintreten bitte :)

-----------------------------------------------------------------------------



Re: dummdidumm (Patryn, 17. Mar 1999, 01:08:52):
~#! rn=Patryn rt=921632840 rg=gilden.zauberer
~#! tid=921632840
kommando zurueck, man braucht nich aus- und eintreten. die einordnung ist
auto erfolgt.

------
patryn

-----------------------------------------------------------------------------



Re: dummdidumm (Asmodis, 17. Mar 1999, 01:27:58):
~#! rn=Patryn rt=921632840 rg=gilden.zauberer
~#! tid=921632840
Heisst das, dass sich jetzt einige Spielerchen outen muessen ? :-)

-----------------------------------------------------------------------------



Re: Re: dummdidumm (Patryn, 17. Mar 1999, 01:29:17):
~#! rn=Asmodis rt=921634078 rg=gilden.zauberer
~#! tid=921632840
sie werden leise klamm und heimlich aus der liste gemaust.
mehr nicht...

wer mit dem outen nich leben kann, dem kann ich auch nich helfen.
ich wuerde sagen: falsche gilde...

------
patryn

-----------------------------------------------------------------------------



schwarzes brett (Patryn, 17. Mar 1999, 01:45:56):
ich hab mal versucht, alle aenderungen der letzten monate im
gildenbrett stichpunktartig festzuhalten, wem noch was einfaellt, ich trage
es gerne nach.

------
patryn

-----------------------------------------------------------------------------



bewachende npcs (Patryn, 17. Mar 1999, 02:22:53):
wie mir auf der party angetragen wurde, funktioniert das bezaubern von
wachnpcs noch nich so, wie damals beschrieben. ich hab das nochmals
ueberarbeitet, nun sollte es tun.
an dieser stelle wiederum die missbrauchawarnung!
zukuentig soll das abfragesystem ja auch fuer imagomation, daemonenfratze
und feuerwalze arbeiten, also schoen testen :)

------
patryn

-----------------------------------------------------------------------------



Hmm, merkwuerdiger Lernerfolg (Mensana, 17. Mar 1999, 13:37:19):
> finde phlyaken
Du murmelst die vorgeschriebenen Worte und haeltst ploetzlich eine magische
Kugel in den Haenden.
Phlyaken wehrt Deinen Zauber ab.

Du lernst etwas aus Deinem Erfolg.
Du hast Dich gerade im Umgang mit dem Zauberstab verbessert.
Dein Zauberstab unterstuetzt Dich bei dem Spruch.

Ich bin ja froh, wenn ich was lerne, aber aus einem "nichtgelungenen" Zauber?
Merkwuerdig.

Mensana

-----------------------------------------------------------------------------



Re: Hmm, merkwuerdiger Lernerfolg (Patryn, 17. Mar 1999, 13:42:54):
~#! rn=Mensana rt=921677839 rg=gilden.zauberer
~#! tid=921677839
gelungen ist der zauber schon, trotzdem kann man auch den abwehren.
ich koennte das sicher ausbaun, sehe aber die notwendigkeit in diesem
fall nicht...

------
patryn

-----------------------------------------------------------------------------



Re: Re: Hmm, merkwuerdiger Lernerfolg (Key, 17. Mar 1999, 13:44:17):
~#! rn=Patryn rt=921678174 rg=gilden.zauberer
~#! tid=921677839
Hmm aus Fehlern sollte man lernen ... oder? .)

Key

-----------------------------------------------------------------------------



Re: Re: Hmm, merkwuerdiger Lernerfolg (Taragon, 17. Mar 1999, 13:48:28):
~#! rn=Patryn rt=921678174 rg=gilden.zauberer
~#! tid=921677839
Denke ich mir auch mal.
Der Zauber kann ja gelungen sein, aber wurde trotzdem abgewehrt. Und man lernt
ja am Gelingen eines Zaubers, und nicht am erwarteten Resultat des Zaubers :-)

-----------------------------------------------------------------------------



hilfe (Patryn, 17. Mar 1999, 14:51:42):
schaetz, rueste, schutz, schutzhuelle haben neue hilfeseiten

------
patryn

-----------------------------------------------------------------------------



Re: hilfe (Birdy, 17. Mar 1999, 16:20:15):
~#! rn=Patryn rt=921682302 rg=gilden.zauberer
~#! tid=921682302
ARGL !
Patryn, ich habe auch so schon genug auf Arbeit zu tun, jetzt auch noch die
WWW-Seiten aendern ... ;)

Birdy. im Stress

-----------------------------------------------------------------------------



Re: Re: hilfe (Patryn, 17. Mar 1999, 16:21:23):
~#! rn=Birdy rt=921687615 rg=gilden.zauberer
~#! tid=921682302
och...fuer dich werde ich glatt noch mehr aendern :)
siehe zB meteoritenerz/nadel-kompohilfe

------
patryn grinst birdy an

-----------------------------------------------------------------------------



lernen (Patryn, 17. Mar 1999, 20:07:29):
hi ihrs,

ich habe schon eine reihe von mails bekommen, die mir einen ueberblick
verschaffen. wie erwartet wiedersprechen sich einige, aber es gibt
auch viele uebereinstimmungen. da ich ne grosse liste machen muss,
in die ich fuer jeden spell die einschaetzungen abgleiche, muss ich
irgendwann mal nen schlussstrich ziehen.
ich denke mal, naechste woche montag ist erst mal einsendeschluss fuer
einschaezungen zum lernen. bis dahin koennt ihr noch meinen folfer
massakrieren (pro tag nen halbes dutzend nur zum lernen *stoehn*)

------
patryn

-----------------------------------------------------------------------------



ruestungen (Patryn, 17. Mar 1999, 21:06:33):
heut haben sich wieder mal fuerchterlich viele ruestungsunterstuetzungen
geaendert, besonders hats ringe und amulette erwischt.
das tigonenamulett hat jetzt auch ne verdammt lange liste, nur so als
motivation ;)

------
patryn

PS: als amulett kann es natuerlich nur illusion und hellsicht
unterstuetzen,aber die zweigmagister muessten inzwischen den wert der einen
oder anderen
unterstuetzung kapiert haben

-----------------------------------------------------------------------------



SSP (Boing, 18. Mar 1999, 10:58:38):
Die SSP wurde komponententechnisch etwas aufgeruestet.
  Boing

-----------------------------------------------------------------------------



Re: SSP (Jasonrigid, 18. Mar 1999, 12:36:10):
~#! rn=Boing rt=921754718 rg=gilden.zauberer
~#! tid=921754718
Ja, ganz toll, jetzt fangen auch noch Zauberer an, die SSp leerzuraeumen,
schoenen Scharnk auch *grins* ;).

Jason schmarrnd mal ne Runde, ist bloss froh, dass er grad nicht mehr
ausbilden muss.

-----------------------------------------------------------------------------



Re: SSP (Paracelsus, 18. Mar 1999, 14:09:16):
~#! rn=Boing rt=921754718 rg=gilden.zauberer
~#! tid=921754718
Hi.

auch in Drakonien gibts einige Komponenten mehr. Aber nur fuer Seher.
Und die seht ihr auch erst, wenn die Monster platt sind ;)=

Para*

-----------------------------------------------------------------------------



Eismine (Tsunami, 18. Mar 1999, 20:34:42):
Die Eismine wurde komponententechnisch etwas aufgeruestet.
Tsunami.

-----------------------------------------------------------------------------



Re: Eismine (Bendeigid, 19. Mar 1999, 09:49:33):
~#! rn=Tsunami rt=921789282 rg=gilden.zauberer
~#! tid=921789282
Hi, Neskaya wurde komponententechnisch ein wenig beibehalten.

Ist das nu Mode, den Zauberern gleich anzugeben, wo sie was finden/suchen
muessen?

Bendeigid, verwundert

-----------------------------------------------------------------------------



Re: Re: Eismine (Patryn, 19. Mar 1999, 14:05:49):
~#! rn=Bendeigid rt=921836973 rg=gilden.zauberer
~#! tid=921789282
wenn sich was aendert, ist es ok, und in den letzten tagen wurden
viele monster hauptsaechlich neu ausgestattet, die schon was hatten.

------
patryn

-----------------------------------------------------------------------------



Liste (Patryn, 19. Mar 1999, 15:31:19):
hi ihrs,

teile llystrathe mit liste liefert nur die innerhalb der letzten 3 monate
  aktiven zauberer
teile llystrathe mit liste komplett liefert alle, normalos sehen trotzdem
  keine magierzweities, magierzweities sehen wirklich alle
es sei noch mal dran erinnert:
mit teile llystrathe mit austragen|eintragen kann man sich aus beiden
verseionen austragen|eintragen, kann allerdings keine posten fuer
die nicht eingetragene zeit in anspruch nehmen.
hat man sich wieder eingetragen  oder ist man nach laenger als 3 monaten
wieder da, so muss man dennoch 4 tage warten, um einen posten besetzen
zu koennen. diese zeit gilt auch fuer postenwechsel oder spaeter
aufstieg zu erz

------
patryn

-----------------------------------------------------------------------------



flaechenangriff... (Hood, 19. Mar 1999, 16:44:31):
hi ihrs

schau
das erdbeben-spell hat jetzt endlich eine vernuenftige lernfunktion,
gegen viele starke npc's lernt man extra.
da steht dann auch etwas text da, mal bitte durchtesten, da ich
das in feuerball, feuerwalze, daemonenfratze, verwirrung
uebernehmen will :)

------
patryn

-----------------------------------------------------------------------------



Re: Re: SSP (Asmodis, 21. Mar 1999, 23:31:08):
~#! rn=Jasonrigid rt=921760570 rg=gilden.zauberer
~#! tid=921754718
Nun mach nicht so, als ob die SSP nur fuer die Trves gebaut wurde ...
Ausserdem gibts auch andere schoene metzelgebiete ...

-----------------------------------------------------------------------------



Re^3: SSP (Boing, 22. Mar 1999, 09:50:16):
~#! rn=Asmodis rt=922059068 rg=gilden.zauberer
~#! tid=921754718
Korrekt ... die SSP gab's schon, bevor es den ersten Gildenmagier
der Trves gab. :)
  Boing

-----------------------------------------------------------------------------



Re^3: SSP (Koomi, 22. Mar 1999, 11:29:50):
~#! rn=Asmodis rt=922059068 rg=gilden.zauberer
~#! tid=921754718
Nicht fuer jede Gilde, einige sind da klar benachteiligt, selbst wenn sie zu
den Topspielern bzw. -sehern mit ausgemaxten Faehigkeiten und Ausruestung
zaehlen.

Naja, ist eh schon langsam wurscht, schade darum, wie um andere Sachen hier
auch.

Koomi

-----------------------------------------------------------------------------



Re^4: SSP (Key, 22. Mar 1999, 11:57:48):
~#! rn=Koomi rt=922102190 rg=gilden.zauberer
~#! tid=921754718
Es soll ja auch net jeder Depp alles killen koennen.
Und vor allem net alle Gilden gleich sein

Und ich finde es ganz und garnet schade drum das das so ist ...

Key

-----------------------------------------------------------------------------



guertelwahn (Patryn, 23. Mar 1999, 19:56:31):
hi ihrs,

ab sofort gibts guertel als ordentlich erfasste ruestung.
sowohl alle zaubererguertel als auch die gilde haben das sofort bemerkt :)
das hat diverse konsequenzen:
  guertel lassen sich nun ruesten: leider ging mit der letzten abwertung die
    annaehernde sinnlosigkeit dieses features daher
    (wegen der geringen staerke der ruestung)
  es laesst sich nur noch ein guertel zur gleichen zeit tragen
viel spass

------
patryn

-----------------------------------------------------------------------------



feuerwalze (Patryn, 24. Mar 1999, 05:44:01):
die feuerwalze hat sich stzark veraendert, sowohl was das lernen,
als auch misslungene walzen, als auch das angriffsverhalten betrifft.
vorsicht also!

------
patryn

-----------------------------------------------------------------------------



daemonenfratze (Patryn, 24. Mar 1999, 23:25:03):
der spell nutzt nun die abwehr/bewache/lernfunktionen von
feuerwalze/feuerball u.s.w.,
es sollten sich einige unterschiede bemerkbar machen.

------
patryn

-----------------------------------------------------------------------------



bewache-abfrage (Patryn, 24. Mar 1999, 23:35:26):
die abfrage, ob ein npc ein ort bewacht oder nich, musste nochmals
gelockert werden. leider setzen die meisten magier ihre viecher anders
als ich in die natur...nun ja.
was schon damals galt: zuviel missbrauch wird bestraft, verdaechtige
probleme damit sind mir bitte zu mailen!

------
patryn

-----------------------------------------------------------------------------



fluchtteleport (Patryn, 25. Mar 1999, 15:49:26):
wie viele wissen, gehen bei uns spells auch dann schief, wenn man
kein alkohol intus hat und sie perfekt kann.
da ich es hasse, wenn man nach einem tod nich sagen kann:
  hey, da hab ich aber was falsch gemacht,
bildet der spell teleport jetzt eine ausnahme, bei sehr sehr wenig
alkohol und fast voller faehigkeit landet man nicht mehr in
diversen (meist ja dann unerwarteten) todesfallen...

------
patryn

-----------------------------------------------------------------------------



teleport (Patryn, 26. Mar 1999, 14:50:32):
teleport hat eine neue zusatz-lernfunktion erhalten,
wiederum klappt es besonders gut bei vielen gegnern, aber man sollte auch
sinnvoll fluechten, nicht mit maximalen lebenspunkten.
spieler-verteidiger ala trves-rueckendecker erhoehen die chance auf
lernerfolg ungemein...

------
patryn

-----------------------------------------------------------------------------



Re: teleport (Morgoth, 26. Mar 1999, 14:51:30):
~#! rn=Patryn rt=922459832 rg=gilden.zauberer
~#! tid=922459832
Blickst du da eigentlich selbst noch durch???

Morgoth, weiss eh nicht mehr wo der unterschied zwischen Zauberer und Magier
ist....

-----------------------------------------------------------------------------



Re: Re: teleport (Patryn, 26. Mar 1999, 14:54:44):
~#! rn=Morgoth rt=922459890 rg=gilden.zauberer
~#! tid=922459832
die derzeitigen zusatzlernmoeglichkeiten wurden explizit durch spieler
angeregt. sie sind auch recht logisch aufgebaut und gleichen sich
ziemlich stark. das abwehrzauber gegen starke angriffe zusatzlernen
einbringen, flaechenspells gegen viele starke gegner u.s.w., das ist
eigentlich logisch. die zauberer sind nun mal eine recht schwierige gilde,
und haben sich mehr den kopf zu zerbrechen, als: haben wir heut schon
gebetet?

------
patryn

-----------------------------------------------------------------------------



Re^3: teleport (Nonne, 26. Mar 1999, 15:00:13):
~#! rn=Patryn rt=922460084 rg=gilden.zauberer
~#! tid=922459832
Wie soll ich das jetzt verstehen? Meinst Du man koennte einen Kleriker
effektiv spielen, ohne nachzudenken? Wieso hauen dann nicht alle Kleriker
alles in Stuecke, wie Sharia oder Neb? Nur weil deine Gilde vom Feeling her
total im Keller ist, und Du die krampfhaft mit millionen Features (vergebens)
wieder auf die Beine bringen willst, brauchst nicht auf die einzige Gilde mit
feeling rumhacken. Aber die Zauberer werden ja eh bald abgehaengt...

Nonne, gluecklich in der schwaechsten aber stimmigsten Gilde.

P.S: *Flame off*

-----------------------------------------------------------------------------



Re^4: teleport (Mahatmu, 26. Mar 1999, 15:01:48):
~#! rn=Nonne rt=922460413 rg=gilden.zauberer
~#! tid=922459832
*lach* *rotfl* *schrei*
(a) weil Du rumheulst
(b) Kleriker und schwach ?
(c) Heul weiter

Mahatmu

-----------------------------------------------------------------------------



Re^4: teleport (Patryn, 26. Mar 1999, 15:02:30):
~#! rn=Nonne rt=922460413 rg=gilden.zauberer
~#! tid=922459832
irgendwie fuehlen sich immer die falschen leute angegriffen, ich hab gar
nix gegen eure gilde...
heut schon mal an nem glueckskeks genagt? trink dein teechen und mach
ein paar entspannungsuebungen :)

------
patryn

-----------------------------------------------------------------------------



Re^5: teleport (Key, 26. Mar 1999, 15:03:56):
~#! rn=Patryn rt=922460550 rg=gilden.zauberer
~#! tid=922459832
Hey was soll das?
Was zum Teufel kann denn der arme Glueckskeks dafuer?
Musst Du immer auf wehrlosen Sachen rumhacken? =;)

Key schmarrnend

-----------------------------------------------------------------------------



Re^6: teleport (Morgoth, 26. Mar 1999, 15:04:30):
~#! rn=Key rt=922460636 rg=gilden.zauberer
~#! tid=922459832
Leibniz ist IMMER schuld ;)

M*

-----------------------------------------------------------------------------



Re^5: teleport (Nonne, 26. Mar 1999, 15:04:50):
~#! rn=Patryn rt=922460550 rg=gilden.zauberer
~#! tid=922459832
Was sollte dann die Andeutung mit dem Beten???

(a) heul
(b) ich kriege nix platt
(c) heul weiter

*Ironie off*

Nonne, ist gluecklich in seiner Gilde, hatte er das nicht schon gesagt??
,

-----------------------------------------------------------------------------



Re^6: teleport (Patryn, 26. Mar 1999, 15:08:37):
~#! rn=Nonne rt=922460690 rg=gilden.zauberer
~#! tid=922459832
also leute, die wirklich gluecklich mit irgendetwas sind, springen auf
kleine seitenhiebe kaum derart an.
dein kommentar war auch nicht grad der gluecklichst gewaehlte, was haben
z.B. die erweiterten lernfunktionen der letzten tage mit deinen
ich-zitiere: verzweifelten-versuchen-der-kampfkrafterhoehung zu tun?
ich wollte morgoth ans bein pinkeln, du wolltest mir ans bein pinkeln,
ich gab nen dummen kommentar, du gabst nen dummen kommentar, sind wir nun
quit? auf wiedersehn und schoenen tag noch

------
patryn

-----------------------------------------------------------------------------



Re^7: teleport (Nonne, 26. Mar 1999, 15:10:31):
~#! rn=Patryn rt=922460917 rg=gilden.zauberer
~#! tid=922459832
Sind wir *grins*

Ich sprach aber von der Stimmung, nicht von der Kampfkraft. Ich schrieb
naemlich `Krampfhaft`, sieht aehnlich aus, heisst aber was anderes.

--- end of thread ---

-----------------------------------------------------------------------------



Re^8: teleport (Mahatmu, 26. Mar 1999, 15:17:58):
~#! rn=Nonne rt=922461031 rg=gilden.zauberer
~#! tid=922459832
Nein, ich will diesen Thread noch nicht beendet haben. Erst muessen wir noch
ueber Flames, Etikette und Kraempfe diskutieren.
Sonst bleibt die bloede Zeitung so leer und ich muss arbeiten.

Mahatmu

-----------------------------------------------------------------------------



Re^9: teleport (Dieder, 26. Mar 1999, 15:19:26):
~#! rn=Mahatmu rt=922461478 rg=gilden.zauberer
~#! tid=922459832

Ok, um der Sache zu dienen und die Diskussion etwas anzuleiern werfe ich mal
ein kurzes, knappes, praegnantes, stets wirkungsvolles

"ZAUBERER ABWERTEN!!!"

ein...

Dieder

-----------------------------------------------------------------------------



Re^10: teleport (Nonne, 26. Mar 1999, 15:20:46):
~#! rn=Dieder rt=922461566 rg=gilden.zauberer
~#! tid=922459832
Das bringt doch nichts, das wird wieder eine versteckte aufwertung wie
letztesmal, nein:

ZAUBERER-GILDE ABHAENGEN !!

hehe

Nonne, inkognito

-----------------------------------------------------------------------------



Re^11: teleport (Dieder, 26. Mar 1999, 15:22:21):
~#! rn=Nonne rt=922461646 rg=gilden.zauberer
~#! tid=922459832
wie waers mit ner neuen Taktik:

Zaubererrubrik vollmuellen, dann kann Bug^H^H^HPatryn keine Aufwertungen mehr
bekannt geben und wirds vielleicht drum bleiben lassen? :)

Dieder, kichert daemonisch.

-----------------------------------------------------------------------------



Re^12: teleport (Mahatmu, 26. Mar 1999, 15:24:36):
~#! rn=Dieder rt=922461741 rg=gilden.zauberer
~#! tid=922459832
Dann verlegt er bloss eigenmaechtig die sinnvollen Artikel. Hm. Rubriks-
bezug: Jaja, die Zauberer sind schon arme Wuerste, muessen dauernd ihren
Komponenten hinterherlaufen. Wird Zeit, dass da mal ein paar Morgoths
wieder buggige Gegenstaende bauen, die sich irgendwie doch und nicht
und ueberhaupt benutzen lassen. -320 Sonstewasse oder so. Aber der boese
Patryn loggt ja alles mit.

Mahatmu

-----------------------------------------------------------------------------



Re^4: teleport (Trug, 26. Mar 1999, 15:29:27):
~#! rn=Nonne rt=922460413 rg=gilden.zauberer
~#! tid=922459832
Nonne,

 "schwaechste" Gilde?? Wie definierst du dann die 'Anfaenger'gilden? Absolut
mega-schwach-drauf?

Nuja, anscheinend gehoeren aber doch irgendwo im MG "Schwaeche" mit
"Atmosphaere" zusammen? Am besten soll ich das mal lassen, sonst entsteht
wieder ein sinnloser Flamethread, wo sich jede Gilde anjammert, wie 'schwach'
sie doch sind.

Trug.

-----------------------------------------------------------------------------



Re^5: teleport (Key, 26. Mar 1999, 15:30:33):
~#! rn=Trug rt=922462167 rg=gilden.zauberer
~#! tid=922459832
Hmm interessant .... Wir haben schon oft ueber die staerksten Gilden
diskutiert ...
Aber was ist jetzt die schwaechste?

Key

-----------------------------------------------------------------------------



Re^12: teleport (Patryn, 26. Mar 1999, 15:34:11):
~#! rn=Dieder rt=922461741 rg=gilden.zauberer
~#! tid=922459832
oh, dazu habe ich mich schon entschlossen :)
zukuenftig werde ich hier nur noch aufs gildenbrett verweisen.

------
patryn

-----------------------------------------------------------------------------



Re^5: teleport (Nonne, 26. Mar 1999, 15:38:00):
~#! rn=Trug rt=922462167 rg=gilden.zauberer
~#! tid=922459832
Mich hat nur gewundert, dass Du in deinem ersten Artikel noch nicht darauf
eingegangen bist. Ich habe nicht geheult, ich heule nicht, ich bin
gluecklicher Kleriker. Ich kriege viel platt, und wenn nicht, besteche ich
einen Zauberer mit Handkompos, die Welt ist schoen!

Nonne.

-----------------------------------------------------------------------------



Re^11: teleport (Koomi, 26. Mar 1999, 21:45:50):
~#! rn=Nonne rt=922461646 rg=gilden.zauberer
~#! tid=922459832
Vielleicht die Zauberergilde in mehrere, fuer jeden Zweig einzelne Gilden
zerschlagen? Naja, unrealistisch :)

Realistischer waere ein Spezialisation in gewisse Zweige, wo dann die Zauberer
entweder die anderen Zweige nicht mehr beherrschen oder einen saftige
MP-Aufschlag zahlen, wenn sie einen Spruch aus einen anderen Zweig lernen
wollen. Waere vielleicht nach einen 'Grundpraktikum' (die Lehrlingspruefung)
nett.

Just my 2 cents
Halbelf Koomi

-----------------------------------------------------------------------------



Re: Re: teleport (Asmodis, 26. Mar 1999, 22:58:15):
~#! rn=Morgoth rt=922459890 rg=gilden.zauberer
~#! tid=922459832
Magier kennen sich nicht im Mg aus :-)

-----------------------------------------------------------------------------



Re^6: teleport (Asmodis, 26. Mar 1999, 23:04:36):
~#! rn=Key rt=922462233 rg=gilden.zauberer
~#! tid=922459832
Am Schwaechsten sind immer noch die Abenteurer.

-----------------------------------------------------------------------------



Re^4: teleport (Jiddu, 27. Mar 1999, 01:02:34):
~#! rn=Nonne rt=922460413 rg=gilden.zauberer
~#! tid=922459832
Ist es das feeling, das gewisse kleriker zu so geistreichen wuenschen wie ich
will in 'bete' ne integrierte zeitung haben bringt? :) es soll da ja noch
andere gilden mit einem ansatz von feeling geben nonne.. ich frag mich auch
wieso du auf so eine sicher nicht boes gemeinte <g> anspielung gleich so
agressiv reagierst. ist das aufgestauter frust? :) 

keep cool,
   Jiddu.

-----------------------------------------------------------------------------



Re^5: teleport (Hasim, 28. Mar 1999, 00:07:58):
~#! rn=Jiddu rt=922496554 rg=gilden.zauberer
~#! tid=922459832
Also ihr habt se doch nicht mehr alle, also wirklich...
Macht doch einfach ne Mega-supa-gilde, z.B. "X-men" oder was, und geht da alle
rein, die zauberer - abwerten rufen, dann ham wir hier endlich Ruhe! Also
echt, was hindert Euch dran, hier einzutreten, wenns denn sooooo toll ist,
oder einen der 45000 zweities einzubringen...
Hasim, sich immer mehr wundernd, und als Wustzauberer schon oft besiegt worden
seiend...

-----------------------------------------------------------------------------



Re^5: teleport (Jiddu, 28. Mar 1999, 01:59:48):
~#! rn=Jiddu rt=922496554 rg=gilden.zauberer
~#! tid=922459832
Das war zufall, dass du jetzt auf meinen ARtikel geantwortet hast oder?????
Ich rufe nicht Zauberer abwerten und ich bin zufrieden mit der Staerke meiner
Gilde weil sie mit der Wahl der Gilde rein -garnichts- zu tun gehabt hat.

  Jiddu, hat auch selbst nen Wurstzauberer.

-----------------------------------------------------------------------------



Re^6: teleport (Hasim, 28. Mar 1999, 21:12:16):
~#! rn=Jiddu rt=922586388 rg=gilden.zauberer
~#! tid=922459832
Ja, Zufall, war halt der letzte in der Reihe ;)
Hasim, sich fuer evtl entstandene wirrungen entschuldigend ;)

-----------------------------------------------------------------------------



Re^6: teleport (Tilly, 29. Mar 1999, 00:13:25):
~#! rn=Hasim rt=922579678 rg=gilden.zauberer
~#! tid=922459832
Hehe, gute Idee die SuperGilde. Hab auch gleich nen Vorschlag fuer den
hoechsten Gilden-Rang: Caeptn MorgenGrauen!
 ->schmarrn()

-----------------------------------------------------------------------------



Re^7: teleport (Jimdigriz, 29. Mar 1999, 11:44:23):
~#! rn=Tilly rt=922666405 rg=gilden.zauberer
~#! tid=922459832
Hoi

Die X-men gibt es doch schon laengst...

JdG

-----------------------------------------------------------------------------



Re^5: teleport (Songoku, 29. Mar 1999, 18:25:15):
~#! rn=Trug rt=922462167 rg=gilden.zauberer
~#! tid=922459832
Genau.
Hier gibt es naemlich keine schwachen Gilden.


Oh ... jetzt ist mir beim trainieren schon wieder eine Ameise an
Altersschwaeche gestorben.

sayounara!

-----------------------------------------------------------------------------



Re^6: teleport (Songoku, 29. Mar 1999, 18:28:09):
~#! rn=Hasim rt=922579678 rg=gilden.zauberer
~#! tid=922459832
Eine Gute Idee.
Aber nur, wenn als Spielerrassen noch die Sayajins und t1000 eingefuehrt
werden.

sayounara!
n

-----------------------------------------------------------------------------



Re^7: teleport (Songoku, 29. Mar 1999, 18:29:06):
~#! rn=Tilly rt=922666405 rg=gilden.zauberer
~#! tid=922459832
Hat der den Babydrachen auf dem Schild??

sayounara!

-----------------------------------------------------------------------------



neues stabgimmick (Patryn, 30. Mar 1999, 06:36:13):
hi zauberers!

es gibt ein neues stabgimmick. wir koennen nun unseren zauberstab weihen!
jeder kennt das problem der neu aufgetauchten monster, die nur mit
einer schadensart zu erlegen sind. da zauberer einzelgaenger sind, zaehlt
das teamargument per definition nicht.
wegen der balance musste die dauer leider sehr eingeschraenkt werden.

------
patryn

-----------------------------------------------------------------------------



Re: neues stabgimmick (Mahatmu, 30. Mar 1999, 14:11:13):
~#! rn=Patryn rt=922775773 rg=gilden.zauberer
~#! tid=922775773
Mammi :) Aber Morgoth hat ja damit angefangen. Als naechstes gibt es wohl:
- die Glaubenswalze
- die Segenhand
- Komponenten fuer Blitz
- Llykandri und Lllysaphina ...

Mahatmu

-----------------------------------------------------------------------------



Re: Re: neues stabgimmick (Nonne, 30. Mar 1999, 16:59:04):
~#! rn=Mahatmu rt=922795873 rg=gilden.zauberer
~#! tid=922775773
JJJJJJJJJJJJJJJJJAAAAAAAAAAAAAAAAAAAAAAAAA

Koennte diesen Artikel mal jemand nach gilden.klerus verlegen? Ich finde, dass
ist eine ausgezeichnete Idee! Morgoth, da weisst, was Du die naechsten Tage
tust ;-)

Nonne.

-----------------------------------------------------------------------------



Re: neues stabgimmick (Feuerwehr, 31. Mar 1999, 00:47:26):
~#! rn=Patryn rt=922775773 rg=gilden.zauberer
~#! tid=922775773
Hi!

*Grins* *Kicher*.

Aehm, das war kein Scherz?
'Wir Zauberer kaempfen alleine, wollen jedes Monster plaetten, und damit
 wir das koennen, baue ich alles noetige ein und um?'

Hey, endlich verstehe ich, was bei euch so vorgeht!

Gruesse!

    Feuerwehr, schmarrend.

PS: Hey Karatekas! Wollt ihr eure Haende nicht weihen koennen? Haut mal Rochus
    an! *kicher*.

-----------------------------------------------------------------------------



gimmicks hin und gimmicks her (Patryn, 31. Mar 1999, 06:57:10):
hi ihrs,

die zaubererkombo 'gimmicks aktualisieren`, 'spruchhilfe nachtsicht' sollte
neues enthuellen...

------
patryn

-----------------------------------------------------------------------------



neues gimmick (Hasim, 31. Mar 1999, 19:08:01):
Ich habs grade mal ausprobiert...
mein zauberstab sagte mir, dass weder die umgebung beleuchtet sei, noch
irgendein gegenstand leutete... allerdings war die umgebung beleuchtet...
leuchte ICH jetzt???

Hasim . o O (Strahlendes Wetter in tschernobyl)

-----------------------------------------------------------------------------



Re: neues stabgimmick (Orktoeter, 31. Mar 1999, 19:51:04):
~#! rn=Patryn rt=922775773 rg=gilden.zauberer
~#! tid=922775773
Das mit dem weihen passt so ueberhaupt nicht zu zauberern, nennt es doch
zumindest anders.

(Diese Aussage enthaelt keine Wertung ob die Funktion in der Zauberergilde
sinnvoll ist oder nicht) OrkT

-----------------------------------------------------------------------------



Re: Re: neues stabgimmick (Jiddu,  3. Apr 1999, 03:23:44):
~#! rn=Feuerwehr rt=922834046 rg=gilden.zauberer
~#! tid=922775773
Ja, Gemeinheit, bei uns war das nur so ein doofer Aprillscherz ;) Nun, warum
koennen Klariker eigentlich nicht fremde Haende weihen?
Jiddu, versucht immernoch Para-Karateorks zu beschwoeren.

-----------------------------------------------------------------------------



magier.urlaub? :) (Patryn,  5. Apr 1999, 19:30:37):
hi leute

in einer woche geht das semester wieder los, und damit werde ich mich so rar
machen wie vor den ferien. meine aenderungswut an der gilde strebt somit
monoton gegen null, was die einen freut, die anderen betruebt (hoffentlich).
mails werden weitergeleitet, diversen bugs kann ich mich auch ab und zu
annehmen, aber ansonsten hab ich leider keine zeit (ich will zumindest
hier keine zeit haben :)
also, bis irgendwann...

------
patryn

PS: ich hoffe mal, die erze kommen waehrend der naechsten 2 monate
    irgendwann, liegt weniger an mir als an balance

-----------------------------------------------------------------------------



zweities hin und zweities her (Hood,  7. Apr 1999, 16:38:49):
ich will nur mal drauf hinweisen, dass die erkennung von spielern, die
gleichzeitig magier sind nur dann funktioniert, wenn der spieler der
zweitie ist. nein ich werde das nicht aendern: ich bin strikt gegen
magierzweities. spielerersties von magierzweities haben ihren posten
ersatzlos zu raeumen.

------
patryn

-----------------------------------------------------------------------------



zaubererquests (Hood,  8. Apr 1999, 07:45:59):
hi ihrs,

ich empfehle sehr, bis morgen auf das erledigen groesserer quests
zu verzichten. durch einen bug, den ich schon lange mal ueberpruefen
wollte (*grins*) lernt man bei einer quest immer nur um 0.5%,
das steht doch etwas im gegensatz zu den geplanten 25% bei einer 100er
quest.

------
patryn

-----------------------------------------------------------------------------



Re: zaubererquests (Woody,  8. Apr 1999, 15:41:54):
~#! rn=Hood rt=923550359 rg=gilden.zauberer
~#! tid=923550359
Vielleicht sollte Llystrathe bis dahin auch einen anderen Text
ausgeben:

"Ich habe Dich beim Zauber 'teleport' unter den Armen gekitzelt."


Woody.-

-----------------------------------------------------------------------------



Re: zaubererquests (Key,  9. Apr 1999, 00:35:29):
~#! rn=Hood rt=923550359 rg=gilden.zauberer
~#! tid=923550359
*hust*
25% durch ne Quest?

Oehm ... ich erinner mich zwar nimmer genau, aber das ist doch ne ganze Menge
....

Wobei ich im mom eh keine Ahnung hab wie das bei euch mit dem lernen laeuft :)

Aber aeh ... kann man die noch im nachhinein abkasieren? :) Ich glaub Tui
haette Ideen wo er die haben will ;)

Key

-----------------------------------------------------------------------------



Re: Re: zaubererquests (Hood,  9. Apr 1999, 00:37:42):
~#! rn=Key rt=923610929 rg=gilden.zauberer
~#! tid=923550359
also den zuschlag kann ich nachtraeglich NICHT nachholen :)
also 25% spellueben sparen oder tigonenquest machen, kommt meiner meinung
nach auf selbe raus, ist schon angemessen :)
bei derzeit 940 punkten sind das 2 spells von 0 auf 100 und noch einer
von 0 auf 30. die questen sollten ja als lernersatz herhalten.
derzeit ists zumindest albern :)

------
patryn

-----------------------------------------------------------------------------



Re^3: zaubererquests (Key,  9. Apr 1999, 01:26:07):
~#! rn=Hood rt=923611062 rg=gilden.zauberer
~#! tid=923550359
Tigonenquest ... Ach ... jaja :)
Das waren noch Zeiten mit stille ;)

Key

-----------------------------------------------------------------------------



... (Patryn,  9. Apr 1999, 02:29:35):
hi leute

ich hab beim spielen diverse bugs gefunden und auch welche gemailt bekommen,
paar verbesserungen vorgenommen -> siehe brett in der gilde und uebliche
aktualisierungen

------
patryn

-----------------------------------------------------------------------------



gimmick hin und gimmick her (Patryn,  9. Apr 1999, 03:58:13):
hi leute,

es gibt nun auch das neue gimmick 'verfluche zauberstab', da ich die
nerverei leid war. ich seh ja ein, dass man den stab auch verfluchen koennen
sollte, wenn man ihn weihen kann, aber diesmal musste ich den spell wirklich
teuer machen. wir sind schliesslich keine chaoten.

------
patryn, hat es leid

PS: wenn man ihnen den kleinen finger reicht...



-----------------------------------------------------------------------------



Re^3: zaubererquests (Neb,  9. Apr 1999, 10:33:03):
~#! rn=Hood rt=923611062 rg=gilden.zauberer
~#! tid=923550359
Welcher Zauberer faengt denn bitte schoen Spells auf 0% an ? ;)

Neb

-----------------------------------------------------------------------------



Re^4: zaubererquests (Neb,  9. Apr 1999, 11:22:40):
~#! rn=Neb rt=923646783 rg=gilden.zauberer
~#! tid=923550359
P.S.: Ja, ich weiss selbst, dass das Haarspalterei is ;)

-----------------------------------------------------------------------------



Re: gimmick hin und gimmick her (Taragon,  9. Apr 1999, 15:05:38):
~#! rn=Patryn rt=923623093 rg=gilden.zauberer
~#! tid=923623093
Hmmmm...

> verfluche stab
Dazu hast Du noch nicht die Macht.

Ab wann geht das denn, bzw. wann ist die Hilfeseite da ? :-)

Taragon

-----------------------------------------------------------------------------



Re^4: zaubererquests (Muadib,  9. Apr 1999, 18:13:16):
~#! rn=Key rt=923613967 rg=gilden.zauberer
~#! tid=923550359
stell dich nich an, tigonen kann man doch zu zweit recht locker machen :)

mua *hats gesehen*

-----------------------------------------------------------------------------



gimmicks (Patryn, 16. Apr 1999, 04:17:11):
neue hilfeseite zu 'gimmick', dafuer bitte neuen stab holen wie ueblich per
teile llystrathe mit zauberstab.
'verfluche' wurde abgewertet, war wohl noch zu stark.

------
patryn

-----------------------------------------------------------------------------



alle woche wieder... (Patryn, 23. Apr 1999, 15:54:24):
neben zahlreichen bug- und typofixes gabs auch eine durchaus spuerbare
aenderung: ab jetzt braucht man gegner, gegen welche man kaempft, nicht
  nochmals in spells angeben, welche lebewesen als argumente erwarten
und im selben raum operieren. selbige werten automatisch angewaehlt.
z.B werte ohne argument wertet einen derzeitigen gegner, was meist nur
bei einem einzigen gegner sinn macht.
zwingtanz ohne argument hat die nachlesbaren auswirkungen auf einen
derzeitigen gegner. u.s.w.

------
patryn

-----------------------------------------------------------------------------



Re: alle woche wieder... (Asmodis, 24. Apr 1999, 02:01:10):
~#! rn=Patryn rt=924875664 rg=gilden.zauberer
~#! tid=924875664
Und bei mehreren Gegnern wird zufaellig einer ausgewaehlt ? Mann, drckt sich
der kompliziert aus :-)

-----------------------------------------------------------------------------



Re: alle woche wieder... (Householder, 24. Apr 1999, 18:27:36):
~#! rn=Patryn rt=924875664 rg=gilden.zauberer
~#! tid=924875664
boooah ist das kompliziert ... zum glueck bin ich ein karateka , da brauch ich
nur toete alle einzugeben und schon nehmen die dinge ihren lauf :-)
HH

-----------------------------------------------------------------------------



stabschadeb (Patryn, 24. Mai 1999, 15:57:57):
hi ihrs,

ich hab mal wieder was gemacht, sprich: ihr braucht nen neuen zauberstab :)
danach hilft stabhilfe stabschaden weiter.
entkraefte mit stabschaden wurde um 20% zusammengestrichen.

------
patryn

-----------------------------------------------------------------------------



spielpause (Patryn, 27. Mai 1999, 13:52:38):
hi ihrs,

ab heute abend bin ich dann fuer 2 monate nicht mehr da, sofern es nicht
noch schlimmer kommt. mails bekomme ich trotzdem, sofern sie nicht
von draussen ins mud geschickt werden (dann funktioniert die umleitung
scheinbar nicht, kleiner bug). ich will dann gerne drauf antworten.
ciao und viel spass

------
patryn

-----------------------------------------------------------------------------



Re: spielpause (Catweazle, 28. Mai 1999, 10:35:30):
~#! rn=Patryn rt=927805958 rg=gilden.zauberer
~#! tid=927805958
It's not a bug, it's a feature.
Ich denke jeder kann sich vorstellen, was passieren wuerde, wenn
wir mail die von aussen kommt, an Internetmailadressen weiterleiten wuerden.
Unser kleines mailsystem ist alles andere als RFC-konform, intern
koennen wir uns da evtl. auftretende Probleme leisten, aber nach
aussen wird das boesartgier.
Und ich denke niemand moechte, dass MG auf alle moeglichen Blacklists kommt,
nur 
weil jemand versucht hat, ueber den rechner zu spammen...
YTC

-----------------------------------------------------------------------------



WWW-Seiten unserer Gilde (Birdy,  9. Jun 1999, 12:12:06):
Hiho Kollegen und Kolleginnen !

In Anbetracht meiner einjaehrigen Abwesenheit, die am 1.November dieses Jahres
beginnt, suche ich jemanden, der unsere Gildenseiten unter die Fittiche nimmt.
:)
Entweder per mail an mich oder einfach hier in unsere Rubrik posten, damit die
auch mal wieder etwas gefuellt wird. ;)

Gruss
Birdy

-----------------------------------------------------------------------------



Re: WWW-Seiten unserer Gilde (Hasim,  9. Jun 1999, 23:59:30):
~#! rn=Birdy rt=928923126 rg=gilden.zauberer
~#! tid=928923126
Wie????
Was????? 
Wieso weg??????
Hasim, verwirrt

-----------------------------------------------------------------------------



Re^22: Yrdsteine (Taragon, 14. Jun 1999, 17:14:31):
~#! rn=Songoku rt=929349089 rg=d.fernwest
~#! tid=928519874
# wie waere es, wenn karatekas FW als heimat waehlen koennten??
# (also im dojo statt z.b. in der abenteurergilde anfangen nach einem der
# seltenen reboots)
Wie waere es, dasselbe fuer die Zauberer zu machen ? :-)))
Es ist schliesslich auch nicht gerade um die Ecke wenn man zum beispiel
Zauberer-Hobbit-Nichtseher ist ;-)

-----------------------------------------------------------------------------



Re^23: Yrdsteine (Paracelsus, 14. Jun 1999, 17:15:39):
~#! rn=Taragon rt=929373271 rg=gilden.zauberer
~#! tid=928519874
Geht doch zu den Kaempfern. ;)

Para*

-----------------------------------------------------------------------------



Re^24: Yrdsteine (Taragon, 14. Jun 1999, 18:31:58):
~#! rn=Paracelsus rt=929373339 rg=gilden.zauberer
~#! tid=928519874
# Geht doch zu den Kaempfern. ;)
Waeh... aber sonst gehts dir gut, oder ? :-)))

Taragon - Trotz aller Gildenkraempfe stolz drauf ein Zauberer zu sein.

-----------------------------------------------------------------------------



Re^23: Yrdsteine (Bambulko, 14. Jun 1999, 18:45:06):
~#! rn=Taragon rt=929373271 rg=gilden.zauberer
~#! tid=928519874
Huch, was ist denn hier loss? Es hat ja noch immer keiner "Heul doch"
geschrieben....Wird aber langsam mal Zeit.

Bambulko

-----------------------------------------------------------------------------



Re^24: Yrdsteine (Anacrion, 14. Jun 1999, 18:45:32):
~#! rn=Bambulko rt=929378706 rg=gilden.zauberer
~#! tid=928519874
Anatol hat sich noch nicht eingeloggt .. ihm gebuehrt da Vorrang.

Anac*

-----------------------------------------------------------------------------



kleines Feature (Wim, 16. Jun 1999, 11:28:15):
Im Zauberstab koennt ihr nun per "zmessage review" eure aktuelle Stabreport
Zeile abfragen.
(zmessage ohne Parameter gibt wie schon immer die Befehlssyntax an ;) )

-----------------------------------------------------------------------------



Re: kleines Feature (Taragon, 16. Jun 1999, 11:57:24):
~#! rn=Wim rt=929525295 rg=gilden.zauberer
~#! tid=929525295
Uii.... endlich mal was sinnvolles :-)))
BTW: Bist du jetzt neuer Gildenmagier oder wie oder was ? :-)))

-----------------------------------------------------------------------------



Re: Re: kleines Feature (Rikus, 16. Jun 1999, 11:58:49):
~#! rn=Taragon rt=929527044 rg=gilden.zauberer
~#! tid=929525295
scheinbar ein unausgelasteter EM, dem Ihr all Eure Wuensche mailen
solltet :-)

Rikus

-----------------------------------------------------------------------------



Re^3: kleines Feature (Taragon, 16. Jun 1999, 12:00:25):
~#! rn=Rikus rt=929527129 rg=gilden.zauberer
~#! tid=929525295
Gute Idee... da faellt mir auch spontan was ein :-))
zmessage kann ein paar Dinge anzeigen, aber es fehlen noch einige sachen wie
z.B. schnell, schmerzen, und andere anhaltende Zauber... waere nett wenn man
die auch anzeigen lassen koennte :-)

-----------------------------------------------------------------------------



Re: Re: kleines Feature (Wim, 16. Jun 1999, 12:02:17):
~#! rn=Taragon rt=929527044 rg=gilden.zauberer
~#! tid=929525295
Nene. sooo schnell wird sich das hoffentlich nicht aendern ;)
Ich habe meinen Aenderungsidee auch brav Patryn vorher vorgeschlagen und sein
Okay dazu.

-----------------------------------------------------------------------------



Re^3: kleines Feature (Wim, 16. Jun 1999, 12:02:47):
~#! rn=Rikus rt=929527129 rg=gilden.zauberer
~#! tid=929525295
Ach, alle Aenderungen werde ich dann einfach an Padreic oder an Dich
weiterleiten... das geht schon.

-----------------------------------------------------------------------------



Re^23: Yrdsteine (Morgonate, 16. Jun 1999, 17:34:47):
~#! rn=Taragon rt=929373271 rg=gilden.zauberer
~#! tid=928519874
da kennt wer das heimweh nicht.

Morgonate

-----------------------------------------------------------------------------



Re^24: Yrdsteine (Taragon, 16. Jun 1999, 18:17:34):
~#! rn=Morgonate rt=929547287 rg=gilden.zauberer
~#! tid=928519874
# da kennt wer das heimweh nicht.
Von wegen... ich mag das nur nicht direkt nach nem crash z.B. verwenden weil
man es da fuer wichtigere Sachen braucht :-)

# Morgonate
Wer bist Du ueberhaupt ? Noch nie gehoert den Namen.

-----------------------------------------------------------------------------



Identifiziere (Wim, 12. Jul 1999, 00:35:28):
Der Spruch "identifiziere" hat eine kosmetische Korrektur erfahren. Findet es
selber raus, was genau :)


-----------------------------------------------------------------------------



'voruebergehend blind' ? ha :-) (Taragon, 13. Jul 1999, 23:11:21):
Da es ja keine direkte Mailadresse fuer Gildenbugs gibt, und der
'Gildenmagier' noch im Zwangsurlaub ist, also hier her damit :-)
Wenn man mit nachtsicht in einen erhellten raum kommt, wird man bekannterweise
voruebergehend blind...
Passiert das allerdings und man stirbt noch bevor dieses voruebergehende
Erblinden aufgehoben wird, so ist man nach der Wiedergeburt dauerhaft blind...
Nicht dass das ein riesen Problem darstellt (ja ich weiss dass man sich
entblinden kann), aber ich denke dass das trotzdem mal gefixt werden sollte.

Gruss
      T

-----------------------------------------------------------------------------



Zauberstab (Wim, 14. Jul 1999, 16:51:16):
Der hat jetzt ein kleines Feature mehr. Dokumentiert hab ichs auch irgendwo.
Viel Spass beim suchen.

(Tip: man beginne die Suche mit einem t llys. zauberstab)


-----------------------------------------------------------------------------



Re: Zauberstab (Silvana, 14. Jul 1999, 20:50:13):
~#! rn=Wim rt=931963876 rg=gilden.zauberer
~#! tid=931963876
t llys. zauberstab
Hat Boing (so) nicht eingebaut.

Hmm... Und nu?

  Silvana

-----------------------------------------------------------------------------



Re: Re: Zauberstab (Wim, 14. Jul 1999, 20:54:19):
~#! rn=Silvana rt=931978213 rg=gilden.zauberer
~#! tid=931963876

Tja, schade. Musst Du weiter suchen :)


-----------------------------------------------------------------------------



Re: Re: Zauberstab (Hobo, 15. Jul 1999, 11:57:41):
~#! rn=Silvana rt=931978213 rg=gilden.zauberer
~#! tid=931963876
Wieso denn Boing?


-----------------------------------------------------------------------------



Re^3: Zauberstab (Zarniya, 15. Jul 1999, 14:37:55):
~#! rn=Hobo rt=932032661 rg=gilden.zauberer
~#! tid=931963876
ich weiss jetzt ehrlich gesagt auch nicht, was Boings Zauberstab hier soll...
ist das nciht was unter der Guertellinie? Ausserdem... hat der sowas? ich kann
mich nur an einen ausfahrbaren Leuchtstab zum rituellen Morden erinnern
(args... WANN war diese Party nochmal? Bin ich echt schon so lange hier?)

Marc

-----------------------------------------------------------------------------



Re^4: Zauberstab (Grimmborn, 15. Jul 1999, 22:52:59):
~#! rn=Zarniya rt=932042275 rg=gilden.zauberer
~#! tid=931963876
Also, ich kann mich da an einen Stab von einer Laenge erinnern, den man bei
einer Person dieser Groesse eigentlich so nicht erwarten wuerde. 
Von so Dingen wie Pfannen, Messern und Gummisaugnaepfen als Zubehoer ganz zu
schweigen.

Grimmborn der Atheist

-----------------------------------------------------------------------------



Die Gildenseiten (Magenbrot, 18. Jul 1999, 22:12:20):

Hallo Zauberer

Anfang Juli habe ich die Pflege der Gildenseiten von Birdy uebernommen. Nach
jede Menge Aktualisierungen und Aenderungen sind die Seiten jetzt
fertiggestellt. Die neue Adresse lautet:
'http://bibliotheken.freepage.de/zauberergilde'. Natuerlich kommt man auch
ueber die MorgenGrauen-Homepage auf die neuen Seiten.

Viel Spass beim Zaubern wuenscht
 Magenbrot


-----------------------------------------------------------------------------



Re: Die Gildenseiten (Magenbrot, 18. Jul 1999, 22:15:32):
~#! rn=Magenbrot rt=932328740 rg=gilden.zauberer
~#! tid=932328740

noch eines: es gibt zwei neue Seiten: 'Zauberkomponenten' und 'Informationen
ueber die Gildenseiten'

Magenbrot

-----------------------------------------------------------------------------



zhist (Taragon, 21. Jul 1999, 15:58:58):
 > zhist
q
--- Was bisher geschah: ------------------------------------------------------
[...]
--mehr-- (20/659) ANFANG

Hmmm. ob sich das vielleicht _etwas_ kuerzen laesst, oder evtl. die Zeilenzahl
als Argument akzeptiert ? (z.B. 'zhist 50' fuer nur die 50 letzten zeilen).

-----------------------------------------------------------------------------



Re: zhist (Anatol, 21. Jul 1999, 15:59:28):
~#! rn=Taragon rt=932565538 rg=gilden.zauberer
~#! tid=932565538
Toller Vorschlag. 
Schonmal versucht? :)

Anatol


-----------------------------------------------------------------------------



Re: Re: zhist (Taragon, 21. Jul 1999, 16:05:40):
~#! rn=Anatol rt=932565568 rg=gilden.zauberer
~#! tid=932565538
# Toller Vorschlag.
# Schonmal versucht? :)
Nein, aber ich denke dass das eigentlich kein Problem sein sollte, es gibt ja
auch andere Befehle (z.B. 'tail') die genau das machen ... den ouput eines
'tail -50' an more() pipen sollte demnach IMHO machbar sein.

-----------------------------------------------------------------------------



Re^3: zhist (Tanis, 21. Jul 1999, 16:07:24):
~#! rn=Taragon rt=932565940 rg=gilden.zauberer
~#! tid=932565538
Also Anatols artikel nach haette ich es erstmal versucht und evtl
festgestellt, das es GEEEEEHET! :-)

Zauberer ... naja, was solls, solche muss es auch geben :-)


-----------------------------------------------------------------------------



Re^4: zhist (Taragon, 21. Jul 1999, 17:22:27):
~#! rn=Tanis rt=932566044 rg=gilden.zauberer
~#! tid=932565538
Hmmm... naja, so wie sich anatol immer auszudruecken vermag, ist es kein
Wunder dass man ihn da missversteht :-)
Naja, ich hab mittlerweile auch kapiert dass zhist das schon kann... Asche
ueber meinen spitzen Hut :-)

-----------------------------------------------------------------------------



Re: zhist (Hood, 21. Jul 1999, 17:43:18):
~#! rn=Taragon rt=932565538 rg=gilden.zauberer
~#! tid=932565538
ACHTUNG!

kuenftig wird sich die fehlerwahrscheinlichkeit in der gilde erhoehen,
da ich jedes feature 2 mal einbaue. dies erachte ich als noetig, damit
auch jeder zauberer jeden parameter durch die folgliche erhoehung von
aenderungsankuendigungen/mitteilungen mitbekommt :)

------
patryn

-----------------------------------------------------------------------------



los gehts wieder... (Patryn, 26. Jul 1999, 03:36:52):
hi leute,

in der vergangenheit habe ich ja schon eine ganze reihe meldungen in der
art von: 'das kannst du jetzt nicht tun', oder
         'das willst du lieber nicht tun' aus der gilde entfernt.
die letzten 2 sachen, die jetzt diesbezueglich dran glauben mussten sind
'hand' und 'teleport'. zu beachten ist hierbei, dass man nix lernt, wenn
man die spells ausserhalb eines kampfes anwirft.
man lernt ausserdem nix mehr in magierbeschraenkten raeumen oder
an magiebeschraenkten gegnern oder wenn man behindert wird oder wenn ein
spell abgewehrt wird.
in zukunft ist es auch nicht mehr sinnvoll, den eigenen schatten zu
attackieren, was ich deshalb mal mehr oder weniger unterbunden habe.
mehrere schatten eines zauberers in einem raum wirds auch nicht mehr
geben...

------
patryn

ps: weitere aenderungen folgen ab sofort selbstverstaendlich wieder :)

-----------------------------------------------------------------------------



doku (Patryn, 26. Jul 1999, 04:41:35):
geaenderte seiten: zemote, zruf(e), schattenkaempfer, hand, teleport
neue seite: zhist

------
patryn

-----------------------------------------------------------------------------



Re: los gehts wieder... (Teddy, 26. Jul 1999, 17:18:42):
~#! rn=Patryn rt=932953012 rg=gilden.zauberer
~#! tid=932953012
Aehm, es gibt MagiERbeschraenkte Raeume ?

Teddy, voller Hoffnung.

-----------------------------------------------------------------------------



Re: Re: los gehts wieder... (Teddy, 26. Jul 1999, 17:21:29):
~#! rn=Teddy rt=933002322 rg=gilden.zauberer
~#! tid=932953012
Und schon folgt die Antwort auf dem Fusse:

Zaubermaus Patryn teilt Dir mit: nix da :) 

Teddy, der Hoffnung beraubt.

-----------------------------------------------------------------------------



Re^3: los gehts wieder... (Wurzel, 26. Jul 1999, 19:15:23):
~#! rn=Teddy rt=933002489 rg=gilden.zauberer
~#! tid=932953012
doch, gibt es.
viel spass beim suchen.

wurzel

-----------------------------------------------------------------------------



Re^4: los gehts wieder... (Teddy, 26. Jul 1999, 19:16:47):
~#! rn=Wurzel rt=933009323 rg=gilden.zauberer
~#! tid=932953012
Hm, muss ich mich doch nochmal su meiner Ecke bewegen und suchen?

Teddy, sucht nach was, womit er Wurzel bestechen kann.

-----------------------------------------------------------------------------



Re^4: los gehts wieder... (Wim, 26. Jul 1999, 20:34:41):
~#! rn=Wurzel rt=933009323 rg=gilden.zauberer
~#! tid=932953012
> doch, gibt es.
Ich dachte, Du wolltest das geaendert haben, zumindest auf [H]- Niveau :)


-----------------------------------------------------------------------------



aenderungen (Patryn, 27. Jul 1999, 15:48:12):
1) neue klitzekleine gildenquest mit einer netten belohnung
    (nein, nix autoload)
2) ewige guertel werden nicht mehr beschaedigt, auch wenns dasteht
3) magieaura-spell wird bei ein-/ausloggen entfernt, damit man den nicht
   mehr lernt

das wars

------
patryn

-----------------------------------------------------------------------------



Re^5: los gehts wieder... (Mahatmu, 28. Jul 1999, 22:22:15):
~#! rn=Wim rt=933014081 rg=gilden.zauberer
~#! tid=932953012
... diverse Workrooms haben manchmal auch wild umgeschriebenen Code, damit ja
keiner reinkann (obwohl bei denen die das machen ja auch gar keiner reinwill)
...

Gloin

-----------------------------------------------------------------------------



aenderungen (Patryn, 29. Jul 1999, 22:22:40):
hi leute,

(1) der schatten sollte sich automatisch aus dem team entfernen und wieder
    automatisch reinkommen, je nachdem ob zauberer anwesend
(2) schatten haelt erfolgsabhaengig, aber kuerzer als frueher
(3) die aufgabenliste von llys enthaelt die namen der leute, denen ihr
    fuer die quests zu danken habt ;)

------
patryn

-----------------------------------------------------------------------------



spellerweiterung (Patryn,  8. Aug 1999, 19:54:26):
spruchhilfe schattenkaempfer sollte neues offenbaren...

------
patryn

-----------------------------------------------------------------------------



llystrathe (Patryn,  8. Aug 1999, 20:08:06):
die dame kennt ein neues stichwort.

------
patryn

-----------------------------------------------------------------------------



provokation (Nonne, 18. Aug 1999, 09:38:00):

Zauberer-Gile abhaengen!

Nonne, dem die Zeitung zu leer ist ;-)

-----------------------------------------------------------------------------



Struvverteidigung (Bendeigid, 20. Aug 1999, 06:38:09):
Geruechten zufolge hat sich die Struvbesatzung was einfallen lassen, um
Zauberern das Leben zu versauern. Fuer genaueres bitte konspirative Rubriken
in der MPA aufsuchen!


-----------------------------------------------------------------------------



Re: Struvverteidigung (Padreic, 20. Aug 1999, 08:43:49):
~#! rn=Bendeigid rt=935131089 rg=gilden.zauberer
~#! tid=935131089
Hmm... spaetestens jetzt wirds denk ich Zeit fuer eine Gildenquest: "Metzel
den Struv" :)

Padreic, der lachende dritte.

-----------------------------------------------------------------------------



laermbelaestigung (Niete, 20. Aug 1999, 10:18:32):

hi, bin ab montag 23. fuer 4 wochen weg (urlaub). macht's gut und bis dann.
niete


-----------------------------------------------------------------------------



Re: Re: Struvverteidigung (Patryn, 20. Aug 1999, 11:48:42):
~#! rn=Padreic rt=935138629 rg=gilden.zauberer
~#! tid=935131089
es war eigentlich sowas aehnliches in planung, so ne art
struv-metzelzeit-topliste mit leichen abliefern und oeffentlichem verbrennen
der selbigen, aber der luschige haufem wird gerade vom gildenmagier
behaetschelt...

------
patryn

-----------------------------------------------------------------------------



Re^3: Struvverteidigung (Bendeigid, 20. Aug 1999, 13:11:49):
~#! rn=Patryn rt=935149722 rg=gilden.zauberer
~#! tid=935131089
Tjaaaaaa, das sagt der richtige, gell? wieso sind denn die Weichlinge von
Zauberern (sogenannten) immer noch hinter pseudomagischen Barrieren (de facto
hoehere Gewalt) vor dem anstaendigen, kaempfen Teil der Bevoelkerung verborgen
und zusaetzlich (!) unangreifabr? Angst vor Verrat in den eigenen Reihen? Das
bestaetigt wieder saemtliche Vorurteile :)

Bendeigid, ohne z'par Servu, dafuer mit Schild "Oeffnet die Akademie fuer
besichtigungen!"

-----------------------------------------------------------------------------



Re^4: Struvverteidigung (Anatol, 20. Aug 1999, 13:12:35):
~#! rn=Bendeigid rt=935154709 rg=gilden.zauberer
~#! tid=935131089
Es gibt Herausforderungen, die ein kluger Trves nie aussprechen sollte.

Viel Spass, Patryn! :o)

Anatol


-----------------------------------------------------------------------------



Re^4: Struvverteidigung (Patryn, 20. Aug 1999, 13:15:13):
~#! rn=Bendeigid rt=935154709 rg=gilden.zauberer
~#! tid=935131089
wir sind seid laengerer zeit daran, nen neues gebaeude hochzuziehen, wo
dann auch alles begehbar und alles angreifbar sein wird.
das dauert aber seine zeit. ich habe jedoch nicht vor, spezifisch leuten
steine in den weg zu legen, nur weil manche leute die nach um 4.00
rumheulen, dass sie nicht erhoehen koennten fuer ne stunde.
die einzigen male, die das struv meines wissens nach mitten am tag
niedergemacht wurde, war nach aufforderungen von diversen trves,
die danach nen bisschen schmollten, weil trotz aller in den weg gelegten
steinen wie torwache und torgeschlossen keiner gestorben ist...

------
patryn

-----------------------------------------------------------------------------



Re: Re: Struvverteidigung (Caillean, 20. Aug 1999, 14:43:20):
~#! rn=Padreic rt=935138629 rg=gilden.zauberer
~#! tid=935131089
waer auch fuer eine solche gildenquest, vorzugsweise als bedingung fuer lvl 8
(groesserals lvl 7 muss man ja fuer die luschen net sein *GGG* )

caillean, auch ne zaubererstie habend

-----------------------------------------------------------------------------



Raeuber (Rochus, 20. Aug 1999, 17:05:09):
Ich habe ``Casty'' Eladriel mal ein nettes neues Objekt mitgegeben...

  Rochus

-----------------------------------------------------------------------------



Re^5: Struvverteidigung (Ark, 20. Aug 1999, 18:30:59):
~#! rn=Patryn rt=935154913 rg=gilden.zauberer
~#! tid=935131089
Ich finde auch, dass diese unertraeglichen Bierschuettler in ihrer
unsaeglichen Bierlaune einen Denkzettel verdient haben. Die Karatekas z.B.
sind so vollkommen ohne Feindbild, dass es schon wieder bemitleidenswert ist.
Fast jede andere Gilde hat ihr Feindbild, Chaos und Klerus, Zauberer und
Trves, Katzenkrieger und Hundehaare, Abenteurer und Rentner, nur Saeufer und
Kampfkuenstler wursteln so ziellos vor sich hin.
Fazit: Rochus sollte sich mit Shakedbeer anlegen (Vorschlag: Shaky klaut Cola
und ersetzt sie mit Bier!), dann werden diese Gilden endlich wieder lebendig.
Diese "Neuigkeiten" wie ein Ruelpsskill und das Geraffel fuer die Karatekas
kann man dann endlich dahin legen, wo es hingehoert, Ablage Papierkorb.
Also, wohlan liebe Gildenvaeter, jetzt ist Eure Phantasie in Sachen Polemik
und Hetze gefragt. Auf, macht Euch ein bisschen nieder, sonst kommen noch
weitere Artikel dieser Couleur, bis Ihr Euch nicht mehr wehren koennt. Geht
einfach mal mit der Zeit.
Und ihr, Karatekas und Biersaeufer, metzelt mal mehr in Xian oder auf Shaky
Island. Nieder mit Funa und Bruno !

PS:    :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^6: Struvverteidigung (Dieder, 20. Aug 1999, 18:33:16):
~#! rn=Ark rt=935173859 rg=gilden.zauberer
~#! tid=935131089
abenteurer und rentner??? Wo ist da der Zusammenhang??
Ich zieh viel lieber nem vorlauten Jungspund mit meinem Krueckstock eins ueber
als einem wurstigen Abenteurer :-))

Dieder ;)

PS: Rubrik? Hm... eigentlich Schmarrn... aber diese hier ist auch recht :)

-----------------------------------------------------------------------------



Re^3: Struvverteidigung (Grimman, 21. Aug 1999, 13:40:34):
~#! rn=Caillean rt=935160200 rg=gilden.zauberer
~#! tid=935131089
Aeeeeeehm, Caillean, warst du es nicht, die unbedingt nen Kaempfer als Mann
wollte? Oder taeusch ich mich da?
Und ist Ari* nicht auch mit nem Kaempfer verlobt? Oder taeusch ich mich schon
wieder?

GrimMan , schmunzelnd

-----------------------------------------------------------------------------



Re^6: Struvverteidigung (Menace, 24. Aug 1999, 11:11:09):
~#! rn=Ark rt=935173859 rg=gilden.zauberer
~#! tid=935131089
Bruno ist (leider) nicht angreifbar!

Menace, kurz und schmerzhaft.

-----------------------------------------------------------------------------



Re^7: Struvverteidigung (Ark, 24. Aug 1999, 19:02:26):
~#! rn=Menace rt=935493069 rg=gilden.zauberer
~#! tid=935131089
Umso mehr ein Argument, ihn niederzumachen *lall* !

Auch kurz und schmerzhaft ... oder auch laenger und noch schmerzhafter.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^4: Struvverteidigung (Caillean, 24. Aug 1999, 23:36:47):
~#! rn=Grimman rt=935242834 rg=gilden.zauberer
~#! tid=935131089
najaaaaaa
aris kleiner zwerg is ja auch n ganz suesser und vor allem sauber, jedenfalls
jetzt wieder *steckt die zwergenbuerste weg*
aber ich kenn da noch nen kaempfer, der mir n haus bauen wollte!
hmmm?

caillean, mittlerweile etwas ungeduldig und sich bald nen zaubi suchend

-----------------------------------------------------------------------------



Re^6: Struvverteidigung (Songoku, 26. Aug 1999, 13:37:09):
~#! rn=Ark rt=935173859 rg=gilden.zauberer
~#! tid=935131089
Bierschuettler als Trainingspuppen???

das wuerde doch etwas zu langweilig ;)

Sayounara!

-----------------------------------------------------------------------------



Re^7: Struvverteidigung (Ark, 26. Aug 1999, 17:06:09):
~#! rn=Songoku rt=935674629 rg=gilden.zauberer
~#! tid=935131089
Irgendwie spuere ich nicht den richtigen Geist der Beteiligten bei dieser -
noch zu festigenden - Feindschaft. Was ist los ? Alles Fussfoener hier oder
wie ?

Kopfschuettelnd verachtet Euch Euer


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^8: Struvverteidigung (Letic, 26. Aug 1999, 17:09:11):
~#! rn=Ark rt=935687169 rg=gilden.zauberer
~#! tid=935131089
Nicht die richtige .. was auch immer...
NIEDER MIT DEN HIRNLOSEN KAMPFDUMMIES !!!!
 
ES LEBE DIE ARKANE MACHT VON TARAMIS !!!!!
mal wieder los .. und da die kaempfer killen waer schoen..sollte nur kommen,
dass die spieler mitverteidigen koennen..hehehe..schoener volkssport

LeTic, der schonmal die Struve gekillt hat..und jeden dieser NPCs da gern auch
ein 2. mal killen wuerde

-----------------------------------------------------------------------------



Re^9: Struvverteidigung (Ark, 26. Aug 1999, 17:11:13):
~#! rn=Letic rt=935687351 rg=gilden.zauberer
~#! tid=935131089
ARKANE MACHT? Hm, gefaellt mir, auch wenn ich nicht weiss, was ich mit
Wurstzauberern zu tun haben soll.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^10: Struvverteidigung (Letic, 26. Aug 1999, 17:12:43):
~#! rn=Ark rt=935687473 rg=gilden.zauberer
~#! tid=935131089
WURSTzauberern ??? hoffe du meinst nit mich..derzeit bin ich ne
megawurst..naja..nach 1 jahr ausser haus..aber ich gelobe besserung..und werde
wuerste lieber vertilgen :-)

LeTic..

-----------------------------------------------------------------------------



Re^9: Struvverteidigung (Sublime, 26. Aug 1999, 17:13:15):
~#! rn=Letic rt=935687351 rg=gilden.zauberer
~#! tid=935131089
Hi LeTic ;)

Da lachen wir doch alle drueber. Ich weiss nicht mehr wer die Worte
benutzt hat, aber wenn das Struv eine gute Metzelregion ist, dann
hat der Magier gute Arbeit geleistet. Ausserdem was ist so toll
daran die alle ein 2. Mal zu killen ? Die Stupse sind eh weg ;)


in hoechster Verachtung den (winzigen) arkanen Maechten von
Taramis ;) (schoener Satz)

Stolzer Oberfeldkaempfer Sublime

-----------------------------------------------------------------------------



Re^10: Struvverteidigung (Letic, 26. Aug 1999, 17:15:18):
~#! rn=Sublime rt=935687595 rg=gilden.zauberer
~#! tid=935131089
wen interessieren stubse??? ich metzel weil ich leichen mag....und vor einem
jahr war eire gilde noch ne herrausvorderung..naja..wenn ihr heute alle so nen
IQ wie eure gildenchars habt..dann sind struve wirklich nur fussabtreter ...


-----------------------------------------------------------------------------



Re^10: Struvverteidigung (Ark, 26. Aug 1999, 17:16:26):
~#! rn=Sublime rt=935687595 rg=gilden.zauberer
~#! tid=935131089
Arkan sind die im anderen Sinn nur, weil sie keiner sieht, bzw. sehen kann und
vielleicht auch nie zu sehen bekommt *hoehoe* Da sieht man mal wieder, wie
schlecht sich Zauberer in groesseren Projekten tun :-)
Sich bei Silvana schonmal vorher entschuldigend ...


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^11: Struvverteidigung (Ark, 26. Aug 1999, 17:17:24):
~#! rn=Letic rt=935687718 rg=gilden.zauberer
~#! tid=935131089
Wenn ich dezent mal darauf hinweisen darf, dass der Sinn meiner Hetze in der
Gruendung einer Feindschaft zwischen Karatekas und Saeufern lag *huestel*


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^11: Struvverteidigung (Sublime, 26. Aug 1999, 17:18:18):
~#! rn=Letic rt=935687718 rg=gilden.zauberer
~#! tid=935131089
Damit sagst Du, das alle Zauberer schmutzige Fuesse haben und un-
bedingt Kaempfers brauchen,um die Dinger wieder sauber zu kriegen.
Tja, da haben wohl die grossen (!) arkanen Maechte versagt.

Subl

-----------------------------------------------------------------------------



Re^12: Struvverteidigung (Heromcfly, 26. Aug 1999, 17:47:25):
~#! rn=Sublime rt=935687898 rg=gilden.zauberer
~#! tid=935131089

hmmm da fehlte aber etz der biss in dem thread
da wahr ja keine einzigens kaempfer/zauberer abwerten dabei :-P

-----------------------------------------------------------------------------



Re^13: Struvverteidigung (Sorcerer, 26. Aug 1999, 18:28:20):
~#! rn=Heromcfly rt=935689645 rg=gilden.zauberer
~#! tid=935131089
Wie waere es eigentlich, den Eingangsraum der Zauberergilde in eine Arena
umzuwandeln (und vielleicht analog im Struv)? Dann koennte man seine eigene
Gilde verteidigen und niemand kann sich beschweren, dass die eine angreifbar
ist, die andere aber nicht oder wie-auch-immer. Und natuerlich ist der
Durchgang in die innere Gilde solange blockiert, wie noch lebende
Gildenmitglieder in der Eingangshalle sind. 
Der Rest der Gilden sollte davon nicht betroffen sein, da ein GL 1 - Spieler
wohl sonst leicht ins Schwitzen geraten koennte :)

Sorcerer - faende es gut, seiner Gilde "helfen" zu koennen :)

-----------------------------------------------------------------------------



Re^14: Struvverteidigung (Heromcfly, 26. Aug 1999, 18:41:04):
~#! rn=Sorcerer rt=935692100 rg=gilden.zauberer
~#! tid=935131089

in der ueberlegung gibts es aber leider einen kleinen fehler 
wenn ich mal ein voellig aus der luft gegriffenes beispiel nennen darf:
eine beliebiger zauberer nennen wier ihn einfach aeh... trauma braucht um
einen halbwegsstarken kaempfer nennen wir in mal heromcfly oder so grade mal 2
runden bevor dieser trotz maxausruestung recht unueberzeugend vom schlachtfeld
gejagt wird

hmm... is euch schonmal aufgefallen das diese diskussionen am gleichen punkt
enden ? :=

HeroMcFly mit einen Faehnchen winkend.

-----------------------------------------------------------------------------



Re^9: Struvverteidigung (Erdbeere, 26. Aug 1999, 19:08:00):
~#! rn=Letic rt=935687351 rg=gilden.zauberer
~#! tid=935131089
Hmmmm ich weiss nicht so recht, ob man sich da auf Lorbeeren setzen sollte,
wenn man stolz verkuendet: 'Ich hab die Struv-NPCs 2mal gekillt.' 

Andere Spieler haben das schon sicher oefters gemacht und deswegen gibts auch
keine Medaille.

Erdbeere.

-----------------------------------------------------------------------------



Re^10: Struvverteidigung (Novastorm, 26. Aug 1999, 19:08:28):
~#! rn=Erdbeere rt=935694480 rg=gilden.zauberer
~#! tid=935131089
Noch nicht....
  Nova

-----------------------------------------------------------------------------



Re^14: Struvverteidigung (Ark, 26. Aug 1999, 19:14:28):
~#! rn=Sorcerer rt=935692100 rg=gilden.zauberer
~#! tid=935131089
*seufz*


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^15: Struvverteidigung (Heromcfly, 26. Aug 1999, 19:16:18):
~#! rn=Ark rt=935694868 rg=gilden.zauberer
~#! tid=935131089

ja was den ? keiner interessiert sich fuer hampelmaenner oder alkoholiker :)


-----------------------------------------------------------------------------



Re^16: Struvverteidigung (Ark, 26. Aug 1999, 19:17:38):
~#! rn=Heromcfly rt=935694978 rg=gilden.zauberer
~#! tid=935131089
Man merkt's *grummel*

Alle abwerten.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^9: Struvverteidigung (Gnome, 30. Aug 1999, 16:09:13):
~#! rn=Letic rt=935687351 rg=gilden.zauberer
~#! tid=935131089
mensch letic, du bist ja nen ganz toller held...
du hast schon mal die struvbesatzung gekillt und koenntest das auch ein
2. mal? wahnisnn. ich bin beeindruckt. hast du das schon deiner mama
erzaehlt?
solange unsere ausbilder nur jeweils eine waffe und ihren orden als
ausruestung haben, kann sie jeder halbwegs passable lvl-8-zaubi killen.

aber geh dich ruhig weiter mit deiner heldentat bruesten...

gnOme

-----------------------------------------------------------------------------



Re^10: Struvverteidigung (Patryn, 30. Aug 1999, 16:17:03):
~#! rn=Gnome rt=936029353 rg=gilden.zauberer
~#! tid=935131089
offensichtlich hat dich das ganze noch viel mehr mitgenommen, als ich eh
schon vermutet hatte. das nenne ich verbundenheit! wo sonst wird so
rumgeflennt, wenn mal ein paar npc's weggeraucht werden.

------
patryn

-----------------------------------------------------------------------------



Re^11: Struvverteidigung (Taragon, 30. Aug 1999, 16:23:16):
~#! rn=Patryn rt=936029823 rg=gilden.zauberer
~#! tid=935131089
Klerikergilde. Die haben so lange geflennt bis ihr einziger gilden-npc
unverwundbar gemacht wurde.

-----------------------------------------------------------------------------



Re^11: Struvverteidigung (Gnome, 30. Aug 1999, 17:01:12):
~#! rn=Patryn rt=936029823 rg=gilden.zauberer
~#! tid=935131089
sicher nimmt mich das mit, patryn. vor lauter heulen, erkenn ich den
bildschirm gar nicht mehr... mein schnupftuch ist nass, mein teddy
vollkommen zerdrueckt, und alles nur, weil ihr poesen zauberer unsere
struvbesatzung killt. jawohl. ich bin voellig in traenen aufgeloest...

patryn, lies mal zwischen den zeilen und erkenne den unterschied zwischen
wildem rumgeheule und einem ironisch-sarkastischem kommentar...

aber vielleicht verlange ich da auch ein bissel viel von dir...

gnOme

-----------------------------------------------------------------------------



Re^12: Struvverteidigung (Patryn, 30. Aug 1999, 17:05:03):
~#! rn=Gnome rt=936032472 rg=gilden.zauberer
~#! tid=935131089
da bereits deine tatsaechlich vorhandenen zeilen wenig lesenswertes
bieten, kannst du nicht von mir erwarten, dass ich auch noch intelligenz
an dein geschriebs verschwende. selbst wenn ich deinen muell wohlwollend
interpretieren wollte, wuerde sich dem wohl wenig sinnvolles abringen
lassen.
sind wir nu fertig? heul weiter

------
patryn

-----------------------------------------------------------------------------



Re^10: Struvverteidigung (Householder, 30. Aug 1999, 17:13:19):
~#! rn=Gnome rt=936029353 rg=gilden.zauberer
~#! tid=935131089
naja zur verteidigung vom doofn letic muss ich sagen, er dass vor gut einem
jahr gemacht hat... damals war es vielleicht noch etwas womit man sich
bruesten konnte 
HH keine ahnung habend

-----------------------------------------------------------------------------



Re^11: Struvverteidigung (Sting, 30. Aug 1999, 17:13:43):
~#! rn=Householder rt=936033199 rg=gilden.zauberer
~#! tid=935131089
*lach* der war gut :)

Sting

-----------------------------------------------------------------------------



Re^12: Struvverteidigung (Teddy, 30. Aug 1999, 18:10:22):
~#! rn=Gnome rt=936032472 rg=gilden.zauberer
~#! tid=935131089
Jawohl, ganz zerdrueckt bin ich, vom vielen ein letztes Mal knuddeln.

Teddy

-----------------------------------------------------------------------------



Re^12: Struvverteidigung (Trug, 31. Aug 1999, 15:53:50):
~#! rn=Taragon rt=936030196 rg=gilden.zauberer
~#! tid=935131089
Die Klerikergilde hat mehr als einen Gilden-NPC. Offenbar warst du noch nie im
Haupttempel auf der Insel am Ende der Welt. Dort gibts noch zumindest Mindra.
:)

Trug.

-----------------------------------------------------------------------------



Re^13: Struvverteidigung (Taragon, 31. Aug 1999, 16:39:34):
~#! rn=Trug rt=936114830 rg=gilden.zauberer
~#! tid=935131089
Mir ist nicht bekannt dass die gilde mehr als einen gildenraum hat :)

-----------------------------------------------------------------------------



Re^14: Struvverteidigung (Anatol, 31. Aug 1999, 16:40:49):
~#! rn=Taragon rt=936117574 rg=gilden.zauberer
~#! tid=935131089
Ich gebe Trug ja nur ungern recht, Taragon... ;)

Anatol


-----------------------------------------------------------------------------



Re^14: Struvverteidigung (Taragon, 31. Aug 1999, 17:46:11):
~#! rn=Taragon rt=936117574 rg=gilden.zauberer
~#! tid=935131089
Ja ja ... das ist wieder typisch... fall du mir nur in den ruecken...

Taragon - verstaendnislos ;-)

-----------------------------------------------------------------------------



Re^12: Struvverteidigung (Alpha, 31. Aug 1999, 21:43:08):
~#! rn=Ark rt=935687844 rg=gilden.zauberer
~#! tid=935131089
Och...wo doch wir Biernaeschen uns so gut zum KaratekahochuebenHelfen geeigneT
(hatten?). Was sollen wir uns denn hassen?
Alpha - hat Karateka gern.
,

-----------------------------------------------------------------------------



Re^13: Struvverteidigung (Ark, 31. Aug 1999, 21:46:22):
~#! rn=Alpha rt=936135788 rg=gilden.zauberer
~#! tid=935131089
Hm, ich warte auf die naechste Gilde, die angeschlossen wird und noch kein
Feindbild hat :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^14: Struvverteidigung (Jasper,  2. Sep 1999, 02:24:46):
~#! rn=Ark rt=936135982 rg=gilden.zauberer
~#! tid=935131089
geht halt mit allen anwesenden zauberern und kaempfern auf das supertolle
schlachtfeld und findet heraus wer die wahren wuerste sind :)

jasper wedelt mit dem 'chaos hobbits rocken'-faehnchen

-----------------------------------------------------------------------------



feuerball (Patryn,  6. Sep 1999, 23:14:21):
hi ihrs,

beim feuerball wurden die bestrafungen angezogen und mit der staerke
multipliziert, vorsicht also, wer beim ueben ist oder gealkt mit
grossen feuerbaellen um sich wirft...

------
patryn

-----------------------------------------------------------------------------



anregung fuer die komponenten (Letic, 15. Sep 1999, 19:43:15):
immer wenn ich mein inv. oder meinen guertel durchforste, sehe ich , dass
einige komponenten mehrfach aufgelistet sind..so werden gekaufte blutsteine
und die blutsteine die man den shens abnehmen kann getrennt aufgefuehrt..und
die blutsteine sind nicht die inzigen kompos die so auffallen...
waere vielleicht ne idee die mal si zusammen zu fassen, dass die zusammen
stehn .. nur so uebersichtshalber..
LeTi, ders nit boes meint :-)

-----------------------------------------------------------------------------



Re: anregung fuer die komponenten (Patryn, 15. Sep 1999, 20:03:05):
~#! rn=Letic rt=937424595 rg=gilden.zauberer
~#! tid=937424595
ok, du bist dann numer 78426736 der das auffaellt und in die ztiung setzt.
du bist in die ewige liste der aufmerksamen komponentennutzer aufgenommen
und hast damit die inoffizielle zaubererquest bestanden, die zweien
unserer aelteren mitglieder 2 zusaetzliche nicht nachvollziehbarer
zaubererquestpunkte zuschanst. dieser zustand wurde bisher erst 5636
gemeldet. es waere also nett, wenn du das auch noch mal hier reinsetzt.
danke.

------
patryn

-----------------------------------------------------------------------------



Re: Re: anregung fuer die komponenten (Nonne, 16. Sep 1999, 10:07:24):
~#! rn=Patryn rt=937425785 rg=gilden.zauberer
~#! tid=937424595
Mmh, nist du nun Gilden-Mag, oder nicht? Wie waere es, wenn Du an dem Zustand
was aenderst, anstatt bemuehte Bug/Feature-Melder mit deinem sarkastischen
Geschreibsel zu aergern? Debug doch erstmal deine Gilde, bevor Du sie weiter
aufwertest, wie Du das im letzten Jahr so fleissig, an allem Balance-Teams
vorbei, getan hast ;-)

Nonne, mit einem 'Zauberer-Gilde abhaengen'-Faehnchen wedelnd.

P.S: </Ironie>

-----------------------------------------------------------------------------



Re^3: anregung fuer die komponenten (Anatol, 16. Sep 1999, 10:30:38):
~#! rn=Nonne rt=937476444 rg=gilden.zauberer
~#! tid=937424595
Danke fuer Deine konstruktiven Gedanken, Nonne. Wenn die Zauberer
Dich und Deine grenzenlose Weisheit nicht haetten, ...

Anatol


-----------------------------------------------------------------------------



Re^4: anregung fuer die komponenten (Nonne, 16. Sep 1999, 10:34:00):
~#! rn=Anatol rt=937477838 rg=gilden.zauberer
~#! tid=937424595
Och, so wichtig sind mir die Zauberer nicht. Es geht mir eher um die
Spielspasserhaltung im MG. Und da versuche ich schonmal zu provozieren, um den
einen oder anderen zum denken anzuregen. Das Du damit deine Probs hast,
beweist Du ja bei 80% Deiner Postings.

Nonne, sich schon auf die Flames freuend.

-----------------------------------------------------------------------------



Re^3: anregung fuer die komponenten (Patryn, 16. Sep 1999, 11:20:24):
~#! rn=Nonne rt=937476444 rg=gilden.zauberer
~#! tid=937424595
wer sagte, ich sei sarkastisch gewesen?
ich glaub dir auch nich vollends, dass du wirklich ironisch sein wolltest...

------
patryn

PS: jeder rede nur ueber das, wovon er ahnung hat...

-----------------------------------------------------------------------------



Re^4: anregung fuer die komponenten (Mahatmu, 16. Sep 1999, 13:40:37):
~#! rn=Patryn rt=937480824 rg=gilden.zauberer
~#! tid=937424595
Zauberer in die Klerikergilde! Morgoth macht wenigstens noch was ...

Mahatmu grinst. (faellt das noch unter Ironie :-] ? )

-----------------------------------------------------------------------------



Re: Re: anregung fuer die komponenten (Letic, 16. Sep 1999, 15:22:58):
~#! rn=Patryn rt=937425785 rg=gilden.zauberer
~#! tid=937424595
aehm..naja..BUG !!!
ich bin ein aelteres mitglied unserer schoenen gilde..aber die 2
nichtnachvollziehbaren questpunkte hab ich nicht bekommen ... BETRUG!

axo...wenn echt so viele das melden...wieso wird dann nix gemacht...wenn 3
spieler schreien abwerten dauert es nit lange..aber wenn .. aehm .. wieviele
waren es noch...naja..wenn also viele melden dass die kompos ne ueberarbeitung
brauchen..dann waere das mal nen handschlag wert..

P.S. den handschlag aber bitte nit in meinen nacken :-)

LeTic, der auch weiter nichtnachvollziehbara questpunkte sammeln will!

-----------------------------------------------------------------------------



Re: Nachfrage (Mahatmu, 16. Sep 1999, 15:36:09):
~#! rn=Guard rt=937492452 rg=treffen
~#! tid=937492452
Meist liegt es daran, dass der Magier was wichtigeres am Kochen hat, jeden-
falls wichtiger als etwas, was nicht wirklich wehtut oder buggt.

Mahatmu

-----------------------------------------------------------------------------



Re^3: anregung fuer die komponenten (Patryn, 16. Sep 1999, 17:08:10):
~#! rn=Letic rt=937495378 rg=gilden.zauberer
~#! tid=937424595
also bis zu deinem artikel hatte ich auch immer schoen brav geantwortet,
ich sollte es langsam in mein signum aufnehmen :)
also hier noch mal:
die komponenten liegen aus geschichtlichen gruenden in zwei verschiedenen
verzeichnissen. urspurenglich hatte mal li einen grossteil von denen
programmiert, ich hab sie dann aber vollends neu geschrieben und
mit details, aktionen und neuen langbeschreibungen versehen.
wir sind dann dazu uebergegangen, also damals noch silvana und nich,
die in meinem verzeichnis weiter zu pflegen. dadurch entstenden jeweils
zwei kompos. eigentlich sollten alle umgestellt werden, aber nich alle
magier waren superfleissig und deshalb haste haltr manchmal noch zwei
scheinbar gleiche kompos getrennt im inv.
warum wird das nich geaendert? ganz einfach: mir fehlen die entsprechenden
schreibrechte bzw. sie sollten mir fehlen und ich sollte mich dran halten.
ich kann nich ueberall einfach in fremden files rumklieren und ich hab auch
somit auch nich so die maximale lust, die betreffenden files aufzustoebern.

------
patryn

-----------------------------------------------------------------------------



Re^4: anregung fuer die komponenten (Letic, 17. Sep 1999, 08:48:14):
~#! rn=Patryn rt=937501690 rg=gilden.zauberer
~#! tid=937424595
na wenn du soo nett antwortest ist doch alles klar...also..Patryn weghoeren
;-) und die faulen magier mal hergehoert...tut doch auch mal was fuer die
ordnung und aktualisiert eure kompos..wenn ihrs nit tut...auch nit schlimm...

wollt sowieso nurmal wiessen wos chaos herkommt..

LeTic ...

-----------------------------------------------------------------------------



Re^5: anregung fuer die komponenten (Nixihou, 21. Sep 1999, 12:19:07):
~#! rn=Letic rt=937558094 rg=gilden.zauberer
~#! tid=937424595
hmm, 
wenns mit den komponenten so arg ist.... sollten halt einfach alle
"li-komponenten" nicht mehr fuer zaubersprueche zugelassen werden.....
dann gibts nie wieder probleme mit "doppelten" komponenten....

nixihou, nebenwirkungen beabsichtigt

-----------------------------------------------------------------------------



Re^4: anregung fuer die komponenten (Isnogood, 21. Sep 1999, 14:22:01):
~#! rn=Patryn rt=937480824 rg=gilden.zauberer
~#! tid=937424595
Och noeh, bitte nicht, dann waer die MPA ja leer

-----------------------------------------------------------------------------



handschuhe (Patryn,  7. Okt 1999, 16:11:58):
hi leute,

es gibt derzeit zwei verschiedene arten von handschuhen, die man mit
handzauber tragen kann. inzwischen hab ich nen zusatzmaster eingerichtet,
um da strengen ueberblick zu behalten. dabei hab ich gleich mal
eingebaut, dass handschuhe nur mit bestimmten hand-schadensarten
zusammenarbeiten...wenn sie das nich tun, geschieht das uebliche.
es sollte klar sein, was fsth nicht vertragen. universell sind whs,
aber natuerlich haben sie da so einen bloeden nachteil und sind bei weitem
nich so gut wie erstere...

------
patryn

-----------------------------------------------------------------------------



handschuh-problem (Patryn,  8. Okt 1999, 04:46:51):
hi leutchens,

also identifiziere liefert nun ne zusatzinfo ueber handschuhe, nun dreimal
darf man raten, welche...
die dokuseiten zu hand und identifiziere wurden dementsprechend leicht
erweitert/umgestellt.

------
patryn

-----------------------------------------------------------------------------



WEG (Birdy,  8. Okt 1999, 22:38:24):
Hiho werte Kollegen und Kolleginnen !

Es ist leider meine traurige Pflicht, von meinem Posten als Magister des
Zweiges Beherrschung zurueckzutreten.
Ab 1.November werde ich naemlich unserem Vaterland mit der Waffe in der Hand
dienen muessen, zum Glueck nennt man das Armee und nicht KoruShakaStruv oda
so. ;)
Wie ihr alle wisst, bin ich ein friedlicher kleiner Zauberer, ich setze mehr
auf Inteeligenz, als auf meine Muckis, aber Vater Staat lockt mit massig Geld
und nur 10 Monaten, ausserdem moechte ich nicht die Feldjaeger zu Hause haben.
;)
Aus diesen Gruenden moechte ich einem oder einer jungen enthusiastischen
Zauberer/in die Moeglichkeit geben, in meine sehr grossen Fussstapfen zu
treten. *hehe*
Ich hoffe, ihr findet eine wuerdige Vertretung fuer mich ! Ab und zu, vor
allem am Wochenende, werde ich wohl auch mal nachschaun kommen.

Noch etwas Patryn: Wehe die Erzmagister werden angeschlossen, bevor ich wieder
da bin !
Und auch Taramis soll warten, aber ich glaube, da brauche ich wohl niemandem
drohen oder ?! *g*

Wuenscht mir was !:)

Euer kleiner und harmloser Birdy

-----------------------------------------------------------------------------



Re: WEG (Sublime,  9. Okt 1999, 14:09:18):
~#! rn=Birdy rt=939415104 rg=gilden.zauberer
~#! tid=939415104
Na dann mal viel Spass ;)

Und, ... by the way, die Trottel, die sich da Bundeswehrsoldaten nennen, 
sind noch um einiges schlimmer und hirnverbrandter als wir netten
Trves ... wollt's nur mal so hinzufuegen...

Sublime *kopfschuettelnd*

-----------------------------------------------------------------------------



Re: Re: WEG (Taragon,  9. Okt 1999, 14:11:30):
~#! rn=Sublime rt=939470958 rg=gilden.zauberer
~#! tid=939415104
Immer diese vorurteilbehafteten klischeeglaeubigen nichtswisser...

Taragon *kopfschuettelnd*

-----------------------------------------------------------------------------



Re: Re: WEG (Grimman, 10. Okt 1999, 17:24:17):
~#! rn=Sublime rt=939470958 rg=gilden.zauberer
~#! tid=939415104
Oki, Sublime das quatschen wir mal bei Gelegenheit ab, du kleine Ratte, ja?
GrimMan ...

-----------------------------------------------------------------------------



Re: WEG (Patryn, 10. Okt 1999, 20:23:08):
~#! rn=Birdy rt=939415104 rg=gilden.zauberer
~#! tid=939415104
wegen der erzmagister hast du glaub ich nix zu befuerchten, ich warte auch
schon seit monaten auf ne regung :)

------
patryn

-----------------------------------------------------------------------------



Re^3: WEG (Sublime, 10. Okt 1999, 22:24:33):
~#! rn=Grimman rt=939569057 rg=gilden.zauberer
~#! tid=939415104
Ich kann nun mal diesen Verein nicht abhaben. Ich mein, ist gut und schoen,
die Vorstellung, friede, freude oder von mir aus auch eierkuchen klappt so-
wieso nicht. Aber ich muss doch nicht in so'nem daemlichen Verein dienen,
wenn's ne Ausweichmoeglichkeit bzw. Ausweichmoeglichkeiten (Bsp. : Zivi,
Verweigerung) gibt. Das Du, Grimmie, da sowieso ne Sonderposition
hast, ist klar. Ich mein, wer brauch' schon 4 Jahre fuer seinen Wehrdienst ?
Oder
wars mehr ? ;)

Subl, der Bundeswehrhasser und Verweigerer

-----------------------------------------------------------------------------



Re: WEG (Anatol, 11. Okt 1999, 10:41:14):
~#! rn=Birdy rt=939415104 rg=gilden.zauberer
~#! tid=939415104
Fuer wie WICHTIG haeltst Du Dich eigentlich? 

*stoehn* Anatol


-----------------------------------------------------------------------------



Re: Re: WEG (Darkmage, 11. Okt 1999, 10:51:36):
~#! rn=Anatol rt=939631274 rg=gilden.zauberer
~#! tid=939415104
Also, also, Anatol,
wenn Du die Scharen von "jungen, enthusiastischen Zauberern" gesehen haettest,
die mit Traenen der Ruehrung in den Augen diesen barmherzigen Ruecktritt
gewuerdigt haben, wuerdest Du diese Frage nicht stellen.

Tststs, so ein Mist, ich haette nicht gedacht, dass ich Anatol noch mal Recht
geben muss ;)

Neb

-----------------------------------------------------------------------------



Re^4: WEG (Wurzel, 11. Okt 1999, 22:52:00):
~#! rn=Sublime rt=939587073 rg=gilden.zauberer
~#! tid=939415104
klar. eigentlich ganz logisch.
wer aus gewissensgruenden den dienst an der waffe verweigert, mutiert dann im
mud zum wilden kaempfer, der massenmordend (und natuerlich mit militaerischem
drill und allem schnickschnack) durch die gegend zieht, um seine komplexe bei
laune zu halten.
schreib doch mal was neues, sowas kennen wir doch schon zur genuege.

wurzel

-----------------------------------------------------------------------------



Re: Re: WEG (Augra, 17. Okt 1999, 20:39:46):
~#! rn=Anatol rt=939631274 rg=gilden.zauberer
~#! tid=939415104
Dito?

A. Weissnix

-----------------------------------------------------------------------------



uebebugs (Patryn, 30. Okt 1999, 16:50:11):
hi leute,

da nunmehr zahlreiche logs existieren, wird diesmal durchgegriffen.
mehrere leute, die nachweisslich nich die patschehaendchen von einem
uebebug gelassen haben, koennen nun einen entsprechenden skill
sehr viel schlechter. meckern bringt nis, ich habe logs. wer noch rummault,
kann den rest des spells auch ganz gestrichen bekommen.
viel spass beim fairen hochueben.

------
patryn

-----------------------------------------------------------------------------



ruecktritt (Patryn, 31. Okt 1999, 00:27:55):
wegen unueberwindbarer differenzen mit diversen (wichtigen) leuten
trete ich hiermit zurueck. ich hab leider auch kaum noch zeit fuer das
mud und wuensche euch weiterhin viel spass. nun werde ich wohl auch mal
wieder zeit zum spielen haben: also...man sieht sich

------
patryn

-----------------------------------------------------------------------------



Re: ruecktritt (Mupfel, 31. Okt 1999, 00:32:52):
~#! rn=Patryn rt=941322475 rg=gilden.zauberer
~#! tid=941322475
Hm... man koennte meinen, die letzten beiden Artikel haetten etwas miteinander
zu tun...

-mupfel-

-----------------------------------------------------------------------------



Zur Lage der Nation (Wim, 31. Okt 1999, 16:31:38):
Liebe Gildenmitglieder,
um eine gewisse Kontinuitaet zu gewaehrleisten und wenigstens die Wartung der
Gilde sicherzustellen habe ich mich nach kurzer Besprechung mit Patryn und
Silvana entschlossen, die Gildenbetreuung zumindest kommissarisch zu
uebernehmen.

Wim

-----------------------------------------------------------------------------



Re: Re: ruecktritt (Jamalski,  1. Nov 1999, 13:17:21):
~#! rn=Mupfel rt=941322772 rg=gilden.zauberer
~#! tid=941322475
Gewagt Mupfel, gewagt ;)
Jamal+

-----------------------------------------------------------------------------



Re: Zur Lage der Nation (Lug,  3. Nov 1999, 01:33:56):
~#! rn=Wim rt=941383898 rg=gilden.zauberer
~#! tid=941383898

WOW,

wim als Gildenmag, dann gehts endlich bergab mit denen...

Dreist
Lug

-----------------------------------------------------------------------------



Re: Re: Zur Lage der Nation (Wim,  3. Nov 1999, 11:13:29):
~#! rn=Lug rt=941589236 rg=gilden.zauberer
~#! tid=941383898

MEHR KAMPFKRAFT! MEHR KAMPFKRAFT!


-----------------------------------------------------------------------------



Re^3: Zur Lage der Nation (Mahatmu,  3. Nov 1999, 11:21:23):
~#! rn=Wim rt=941624009 rg=gilden.zauberer
~#! tid=941383898
Ich aber bin der Meinung, dass Orkhausen zerstoert werden muss.

Ca^H^HMahatmu

-----------------------------------------------------------------------------



Drakonischer Laden (Wim,  4. Nov 1999, 20:45:58):
Komponenten aus dem Laden in dem Drachenhaus in Drakonien haben derzeit die
Angewohnheit sich mal einfach so aufzuloesen... Inhaber einer Lupe moegen
diese z.Z. ueber die bekannten Alternativen beschaffen.

Klartext: Warten, bis Para was geaendert hat :)

-----------------------------------------------------------------------------



Re: Drakonischer Laden (Paracelsus, 11. Nov 1999, 13:56:20):
~#! rn=Wim rt=941744758 rg=gilden.zauberer
~#! tid=941744758
Done.

-----------------------------------------------------------------------------



Wandler (Liara, 12. Nov 1999, 20:37:47):
Moin.
Ich find's nicht sooo dolle, dass der Wandler in der Paraversion von Auge des
Teufels abhaengt.
Meine Wenigkeit darf da nicht rein, weil ich die Normalversion noch nicht
habe.
Ob der Wandler denn AdT schon gemacht hat? ;-)

Liara, Zwergenzauberine

-----------------------------------------------------------------------------



Re: Wandler (Ark, 12. Nov 1999, 21:31:51):
~#! rn=Liara rt=942435467 rg=gilden.zauberer
~#! tid=942435467
Ist das so? Naja, glaub nur nicht, dass ich ihm das verbiete. Aber ich werde
den Teufel tun, jetzt die logische Loesung dieses Problems vorzuschlagen
*aehem* ;^)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Wandler (Mindblade, 12. Nov 1999, 21:40:08):
~#! rn=Liara rt=942435467 rg=gilden.zauberer
~#! tid=942435467
Ziemlich bloed, dass er da rumhaengt. Aber da stoert er wenigstens keinen.
Viel nerviger ist es, wenn er mal wieder Dein Seherhaus belagert. Waers
nichtmal moeglich im wenigstens DAS zu verbieten? Ich will keine nervigen NPCs
in meinem Seherhaus und ich denke mal da bin ich nicht alleine.

My 2 cents,
Mind*

-----------------------------------------------------------------------------



Re: Re: Wandler (Wurzel, 12. Nov 1999, 22:38:17):
~#! rn=Mindblade rt=942439208 rg=gilden.zauberer
~#! tid=942435467
sowas tut er? das werden wir ihm mal verbieten, denke ich... dauert ein paar
tage, aber dann ist der spuk vorbei.

wurzel

-----------------------------------------------------------------------------



Re^3: Wandler (Wurzel, 12. Nov 1999, 23:49:32):
~#! rn=Wurzel rt=942442697 rg=gilden.zauberer
~#! tid=942435467
hm... der wandler geht, wenn man dem code glaubt, nicht in seherhaeuser.
bist du sicher, dass er bei dir reinkommt?

wurzel

-----------------------------------------------------------------------------



Re^4: Wandler (Sniper, 13. Nov 1999, 00:06:03):
~#! rn=Wurzel rt=942446972 rg=gilden.zauberer
~#! tid=942435467

Der Wandler geht auch Feldversuchen zufolge nicht in Seherhaeuser ;-)
Vielleicht hat er das frueher mal gemacht...

Sniper

-----------------------------------------------------------------------------



Re^4: Wandler (Tarina, 13. Nov 1999, 00:29:23):
~#! rn=Wurzel rt=942446972 rg=gilden.zauberer
~#! tid=942435467

Soweit ich weiss, ging der Wandler mal in Seherhaeuser. Das wurde aber glaube
ich
schon abgeschaltet.

Tarina

-----------------------------------------------------------------------------



Re^5: Wandler (Wurzel, 14. Nov 1999, 15:45:52):
~#! rn=Tarina rt=942449363 rg=gilden.zauberer
~#! tid=942435467
gut, das spart arbeit :)

wurzel ist faul

-----------------------------------------------------------------------------



Re^6: Wandler (Hood, 14. Nov 1999, 18:28:26):
~#! rn=Wurzel rt=942590752 rg=gilden.zauberer
~#! tid=942435467
dass der nicht mehr in seherhaeuser geht, wurde 2 wochen nach anschluss
eingebaut. das ist also ganze ewigkeiten her...
einen bug will ich natuerlich nicht ausschliessen, aber absicht waere das
kaum.


-----------------------------------------------------------------------------



Re^7: Wandler (Mindblade, 14. Nov 1999, 18:58:46):
~#! rn=Hood rt=942600506 rg=gilden.zauberer
~#! tid=942435467
Sodenn, dann wird er zwischendurch vielleicht gebuggt haben. Sofern er nicht
mehr in Seherhaeuser geht, will ich nichts gesagt haben!:-)
Peace and end of thread!;)
Mind*

-----------------------------------------------------------------------------



Re^8: Wandler (Silvana, 14. Nov 1999, 21:17:55):
~#! rn=Mindblade rt=942602326 rg=gilden.zauberer
~#! tid=942435467
Haette was, wenn er auch nicht in Workrooms gehen wuerde...

  Silvana

-----------------------------------------------------------------------------



Re^9: Wandler (Hood, 14. Nov 1999, 22:41:31):
~#! rn=Silvana rt=942610675 rg=gilden.zauberer
~#! tid=942435467
da geht er nur rein, wenn spieler auch da reinkommen.
um magier macht der eh nen grossen bogen, wenn sie allein sind.


-----------------------------------------------------------------------------



Re^10: Wandler (Grimmborn, 14. Nov 1999, 23:38:50):
~#! rn=Hood rt=942615691 rg=gilden.zauberer
~#! tid=942435467
Und Spieler haben, von wenigen Ausnahmen abgesehen (gell, Boing?) in workrooms
ja generell nichts zu suchen...

GdA

-----------------------------------------------------------------------------



*gaehn* (Obermotz, 17. Nov 1999, 16:31:34):
um mal wieder etwas Leben in die MPA zu bringen, mal ein kleiner Vorschlag.

um geht? Die Aussage kann von "ist sicher" bzw. "ist unsicher" ueber "eiss
nicht" bis hin zur falscheinschaetzung gehen.

Obermotz

PS: Flamt doch! Ich habe gerade eine Anti-Flame-Schutzhuelle erschaffen ;-)

-----------------------------------------------------------------------------



Re: *gaehn* (Obermotz, 17. Nov 1999, 16:34:29):
~#! rn=Obermotz rt=942852694 rg=gilden.zauberer
~#! tid=942852694
*fluch* mein telnet mag wohl keine langen zeilen. Darum nochmal.

Da man in einigen Gebiten nicht teleportieren kann, koennte ich mir ein
"schaetz teleport" vorstellen.
Je nach dem, wie gut man "schaetz" und "teleport" kann, bekommt man keine
Aussage, eine richtige (ungefaehr) oder eine falsche.
Was haltet Ihr davon.

OM

PS: Die Anti-Flame-Schutzhuelle steht immer noch.

-----------------------------------------------------------------------------



Re: Re: *gaehn* (Hood, 17. Nov 1999, 16:38:19):
~#! rn=Obermotz rt=942852869 rg=gilden.zauberer
~#! tid=942852694
nette idee, aber 'schaetz teleport'? igitt :)
das sollte eher in 'wahrsagen' ohne argumente, damit wird der
zweigmagisterposten attraktiver, es passt besser zu dem spell und man
kann ja zusammenarbeiten.


-----------------------------------------------------------------------------



Re^3: *gaehn* (Anatol, 17. Nov 1999, 16:40:09):
~#! rn=Hood rt=942853099 rg=gilden.zauberer
~#! tid=942852694
Im Moment ist "teleport" ja auch ohne Kampf (dann aber ohne Lerneffekt)
moeglich. Im Zweifelsfall kann man ja testen - und dann fluchen, wenn
man in der Pampa, in einer... aeh... "Diskussion" oder am Ende der Welt
landet.

Anatol


-----------------------------------------------------------------------------



Re^4: *gaehn* (Anacrion, 17. Nov 1999, 16:42:32):
~#! rn=Anatol rt=942853209 rg=gilden.zauberer
~#! tid=942852694
Solange man das nicht mit einem aggressiven NPC (siehe letzter Beholder,
schwarze Mumie o.ae.) ausdiskutieren muss ....

Anac*

-----------------------------------------------------------------------------



Re^3: *gaehn* (Wim, 17. Nov 1999, 19:43:35):
~#! rn=Hood rt=942853099 rg=gilden.zauberer
~#! tid=942852694
Hmmm... Tja frueher ging das sogar, bis Patryn was geaendert hatte ;)
Also eine Wiederherstellung alter Zustaende unter Beibehaltung der neuen
Funktionalitaet... hmmm... Ich notiers mir mal.

-----------------------------------------------------------------------------



Re: Re: *gaehn* (Grimmborn, 17. Nov 1999, 20:22:49):
~#! rn=Obermotz rt=942852869 rg=gilden.zauberer
~#! tid=942852694
hilfe mpa, Abteilung "wie loesche ich einen Artikel?"

Grimmborn der Atheist

-----------------------------------------------------------------------------



Und ihr habt doch einen an der Waffel (Morgoth, 29. Nov 1999, 09:05:04):
Sator kommt an.
  ....normal/???......... Feuerdaemon.. : Sator........ ******** -- sehr hart
  Der riesige Feuerdaemon trifft Sator sehr hart.
Adidas tippelt herein.
Sator knuddelt den riesigen Feuerdaemon.
Sator verwuschelt Deine Haare.
Sator grinst.
Sator wabert nach Norden.
Adidas tippelt Sator hinterher.
Sator kommt an.
  ....normal/???......... Feuerdaemon.. : Sator........ ******** -- Krachen
  Der riesige Feuerdaemon schlaegt Sator mit dem Krachen brechender Knochen.
Adidas tippelt herein.
Sator zeigt Dir voller Stolz seinen Runenstab:
Dies ist der Runenstab von Sator.
Er ist bereits mit 16 Runen und zwei Symbolen der Macht versehen.
Sator wabert nach Norden.
Adidas tippelt Sator hinterher.
Du teilst Xand mit: supergeiler film
Sator kommt an.
  ....normal/???......... Feuerdaemon.. : Sator........ ******** -- sehr hart
  Der riesige Feuerdaemon trifft Sator sehr hart.
Adidas tippelt herein.
Sator grabbelt an einem riesigen Feuerdaemon herum.
Sator wabert nach Norden.
Adidas tippelt Sator hinterher.
Sator kommt an.
  ....normal/???......... Feuerdaemon.. : Sator........ ******** -- sehr hart
  Der riesige Feuerdaemon trifft Sator sehr hart.
Adidas tippelt herein.
Sator laechelt den riesigen Feuerdaemon an.
Sator wabert nach Norden.
Adidas tippelt Sator hinterher.
Sator kommt an.
  ....normal/???......... Feuerdaemon.. : Sator........ ******** --
Schmettern
  Der riesige Feuerdaemon zerschmettert Sator in kleine Stueckchen.
Adidas tippelt herein.
Sator laechelt den riesigen Feuerdaemon an.
Sator wabert nach Norden.
Adidas tippelt Sator hinterher.

Sator kommt an.
  ....normal/???......... Feuerdaemon.. : Sator........ ******** -- Krachen
  Der riesige Feuerdaemon schlaegt Sator mit dem Krachen brechender Knochen.
Adidas tippelt herein.
Sator fragt den riesigen Feuerdaemon nach Feuerwasser.
Der riesige Feuerdaemon schaut Sator fragend an.
Sator wabert nach Norden.
Adidas tippelt Sator hinterher.


M*

-----------------------------------------------------------------------------



Re: Und ihr habt doch einen an der Waffel (Jamalski, 29. Nov 1999, 19:31:08):
~#! rn=Morgoth rt=943862704 rg=gilden.zauberer
~#! tid=943862704
Ich vermute Mal, Du meinst mit 'ihr' die Zauberer, ne wa?
Bei Freund Sator Arepo handelt es sich allerdings um einen nicht ganz normalen
Zauberer!
Ich moechte sogar behaupten, dass S.A. dem Wort Dummheit eine vollkommen neue
Tiefe gegeben hat, seit der Glanzleistung den Plastiksack zu zerbeissen, als
man ihm in jungen Jahren das Schwimmen beibringen wollte.
Umgehen oder erschiessen. Oder besser: Umgehend erschiessen!
Jamalski
Drogenbeauftragter

-----------------------------------------------------------------------------



...1000 jahre sind ein tag ... :-) (Taragon,  5. Dez 1999, 17:53:05):
Aus einer 'stabhilfe' :

... Das Tal ist derzeit nur durch die Hoehle zu betreten. Ein Sehertor wird
noch in den naechsten Tagen errichtet...

Guter witz, endlich mal ein neues thema :-))

-----------------------------------------------------------------------------



Schacht (Rochus, 22. Dez 1999, 19:11:35):
Man sollte jetzt den Teleport ZIEMLICH gut koennen,
wenn man damit aus dem Schacht rausmoechte...
Nur so als kleine Warnung :-)

  Rochus

-----------------------------------------------------------------------------



Re: Schacht (Cisou, 22. Dez 1999, 22:56:18):
~#! rn=Rochus rt=945886295 rg=gilden.zauberer
~#! tid=945886295
Waaaaah, Rochus, was tat ich Dir ? ;)
Haben wir solche Katzenmusik gemacht? 

Wo ich doch eh schon der running joke bei der Nachbarin der Schwester des
sonstewas bin.

-----------------------------------------------------------------------------



Homepage (Apophis,  6. Jan 2000, 19:46:19):
Hallo Kollegen,

ich will nur mal wieder auf die Homepage unserer wunderbaren Gilde hinweisen.
Zu erreichen ist sie entweder ueber die MG-Homepage oder direkt ueber
http://bibliotheken.freepage.de/zauberergilde.
Damit ich sie immer aktuell halten kann, bin ich auf euer Feedback
angewiesen... ihr wisst ja wie das laeuft...

Apophis - fka Magenbrot

-----------------------------------------------------------------------------



Lebt er oder lebt er nicht?? (Lolli,  3. Feb 2000, 10:19:25):
wie soll man das verstehen?

> t skelett
Ein Skelett ist doch schon tot!
> nimm knochen aus skelett
Aber ein Skelett lebt doch!

hat sich einer da schon mal gedanken gemacht?

Lolli, diese Quelle schmerzlich vermissend

-----------------------------------------------------------------------------



wenn Zwerge jammern (Wim,  8. Feb 2000, 21:19:07):
Liara JAMMERT an alle Zauberer.
Ein entsetzlicher Schrei hallt vom Friedhof herueber.

-----------------------------------------------------------------------------



Homepage (Apophis, 10. Feb 2000, 22:16:19):
Tach Kollegen und Kolleginnen,

die Homepage iss jetzt auch leichter zu erreichen ueber
www.zauberergilde.de... kommt zwar ein doofes Werbefenster, aber das kann man
ja wegklicken.

Apophis

-----------------------------------------------------------------------------



Aenderungen Eismine (Tsunami, 17. Feb 2000, 14:08:45):
Aenderungen in der Eismine
--------------------------

Ich habe auf haeufigen Wunsch (eines Einzelnen...) die Gildenquest
'Rettungsaktion in der Eismine' technisch (nicht aber inhaltlich) etwas
umgebaut. Man kann nun auch ohne zu fragen die Quest beenden, was speziell
gewisse Zauberer freuen wird.

Wenn ihr noch Vorschlaege zur Truhe habt, werde ich mir die gerne mal
anhoeren.

Und nein, es wurde kein einziger NPC umgebaut. Die Werte usw. bleiben so,
wie sie waren.

Tsunami. Fleissig.

-----------------------------------------------------------------------------



Danke, (Thufhir,  6. Mar 2000, 10:42:09):

an alle, die die aufwertung der zwergenmagister moeglich gemacht haben. *den
bloeden elfen ne lange nase zeig*
s'zauberzwerch.

-----------------------------------------------------------------------------



Re: Lupe (Paracelsus,  7. Apr 2000, 16:31:31):
~#! rn=Anacrion rt=955116949 rg=gilden.zauberer
~#! tid=955116949
Aehm ... "ohne kampfwert"? Hast Du den Spruch verstanden?

Para*

-----------------------------------------------------------------------------



Re: Re: Lupe (Anacrion,  7. Apr 2000, 16:32:45):
~#! rn=Paracelsus rt=955117891 rg=gilden.zauberer
~#! tid=955116949
Ich meinte: direktem Kampfwert :)

Anac*- verlaesst sich ungern auf seine Aufzeichnungen aus alter Zeit

-----------------------------------------------------------------------------



Re: Re: Lupe (Hood,  7. Apr 2000, 16:35:07):
~#! rn=Paracelsus rt=955117891 rg=gilden.zauberer
~#! tid=955116949
das ohne kampfwert bezweifle ich jetzt auch mal stark :)
mir soll das auch eigentlich egal sein ob ewig oder nich, aber wie
schon erwaehnt, gehoert zu einer diesbezueglichen aenderung etwas
mehr umsicht als vom ausfuehrenden scheinbar zur anwendung kam.
davon abgesehen: wenn man denn wirklich langeweile hat, da liegt genug
arbeit in diversen fertig zu schreibenden gildenraeumen, da kann man
wirklich kreativ schalten  und walten...

-----------------------------------------------------------------------------



Re: Lupe (Ark,  7. Apr 2000, 22:06:09):
~#! rn=Anacrion rt=955116949 rg=gilden.zauberer
~#! tid=955116949
Einspruch Euer Ehren. a) Vergleiche mit anderen Gilden tuen nichts zur Sache
und verwirren die Geschworenen nur.
b) Auch hier ist ein Zusammenhang mit der Forderung nicht zu erkennen. Nur
weil der Klaeger meint, dass der Spruch seiner Meinung nach keinen Kampfwert
hat, darf das nicht als Begruendung der Aenderung dienen. Desweiteren verweise
ich auf die vielfach geforderte Herstellung des Gildenfeelings, zu der auch
Komponentensuche gehoert.
Wo kaemen wir hin, wenn auch Karatekas "ewige" Spruchrollen verlangen wuerden?

Einspruch stattgegeben. Setzen Sie sich, Klaeger.

Noch viel hochachtungsvoller :-)

Der Supermagier auf Tatamis, ...


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



so. (Wim,  9. Apr 2000, 17:13:41):
Nach einer zu gruendlichen Rundumschlagloesung ist nun ein etwas aelterer Bug
in diversen ewigen Komponenten entfernt worden.
Gildenfremde Nutzung bestimmter Gegenstaende ist nun nur noch
Bestimmungsgemaess moeglich. Moegen diejenigen verflucht sein, die den Fehler
nutzen ohne ihn zu melden.

-----------------------------------------------------------------------------



Re: so. (Apophis,  9. Apr 2000, 17:16:03):
~#! rn=Wim rt=955293221 rg=gilden.zauberer
~#! tid=955293221
war diese rundumschlagloesung das entfernen aller zauberkomponenten bis auf
eine letzte jeder sorte? toll

Apo

-----------------------------------------------------------------------------



Re: Re: so. (Wim,  9. Apr 2000, 17:18:59):
~#! rn=Apophis rt=955293363 rg=gilden.zauberer
~#! tid=955293221
nein

-----------------------------------------------------------------------------



Re^3: so. (Apophis,  9. Apr 2000, 17:20:19):
~#! rn=Wim rt=955293539 rg=gilden.zauberer
~#! tid=955293221
duerfen wir dann erfahren, wieso die kompos verschwunden sind?

-----------------------------------------------------------------------------



Re^4: so. (Amaryllis,  9. Apr 2000, 17:22:14):
~#! rn=Apophis rt=955293619 rg=gilden.zauberer
~#! tid=955293221
siehe Artikel 7 :-)

Ama* -> Schmarrn

-----------------------------------------------------------------------------



Re^5: so. (Wim,  9. Apr 2000, 17:24:40):
~#! rn=Amaryllis rt=955293734 rg=gilden.zauberer
~#! tid=955293221
Gute Antwort. Das ist schwer zu toppen.... hmmm.
Ich schliesse mich Ama* an und erweitere nur noch um ein "Heul Doch."

-----------------------------------------------------------------------------



Re^6: so. (Apophis,  9. Apr 2000, 17:27:10):
~#! rn=Wim rt=955293880 rg=gilden.zauberer
~#! tid=955293221
tollen Gildenmagier haben wir. find ich echt ned schlecht.
und heulen tu ich trotzdem nicht.

-----------------------------------------------------------------------------



Re^7: so. (Wim,  9. Apr 2000, 17:28:44):
~#! rn=Apophis rt=955294030 rg=gilden.zauberer
~#! tid=955293221
Tja, wie es in den Wald hineinruft, so schallt es heraus.

-----------------------------------------------------------------------------



Re^8: so. (Apophis,  9. Apr 2000, 17:30:33):
~#! rn=Wim rt=955294124 rg=gilden.zauberer
~#! tid=955293221
haeh? das wird ja immer besser! schwache leistung. Gildenmagier und Erzmagier
lassen sich nicht vereinen. Einer allein schafft das nicht. Wie waere es einem
talentierten Nachwuchsmagier den Job zu uebergeben? Da gibts doch bestimmt
jemanden...

-----------------------------------------------------------------------------



Re^9: so. (Wim,  9. Apr 2000, 17:32:47):
~#! rn=Apophis rt=955294233 rg=gilden.zauberer
~#! tid=955293221
Ich werde spaeter lachen, auch wenn es schwer faellt.

-----------------------------------------------------------------------------



Re^9: so. (Hood,  9. Apr 2000, 18:34:23):
~#! rn=Apophis rt=955294233 rg=gilden.zauberer
~#! tid=955293221
nen nachwuchsmagier fuer die zauberergilde? auf welchem stern lebst du
denn? ich bin froh, dass wim den job ueberhaupt uebernommen hat,
die moegliche auswahl war naemlich ungefaehr eine person gross :)

-----------------------------------------------------------------------------



Re^7: so. (Trug,  9. Apr 2000, 22:54:09):
~#! rn=Apophis rt=955294030 rg=gilden.zauberer
~#! tid=955293221
Wunderts dich denn eigentlich noch, dass hier Kritik und normale Fragen mit
einen 'Heul Doch!' abserviert werden? 

Trug. sollte sich eigentlich den Titel 'Gastspielerin' setzen.

-----------------------------------------------------------------------------



Re^8: so. (Wim,  9. Apr 2000, 22:57:13):
~#! rn=Trug rt=955313649 rg=gilden.zauberer
~#! tid=955293221
Lieber Trug, Dann sage mir doch bitte mal, wie ich auf sinnfreie Fragen
reagieren soll? 

-----------------------------------------------------------------------------



Re^9: so. (Trug,  9. Apr 2000, 22:58:23):
~#! rn=Wim rt=955313833 rg=gilden.zauberer
~#! tid=955293221
Da wir am nitpicken sind, weise ich darauf hin, dass es 'Liebe Trug' heisst.

Und so sinnfrei ist diese Frage nicht, aber hier wundert mich eh nix mehr.

Trug.

-----------------------------------------------------------------------------



Re^10: so. (Hood,  9. Apr 2000, 22:59:23):
~#! rn=Trug rt=955313903 rg=gilden.zauberer
~#! tid=955293221
loesch dich (c) lug
wie lautete die frage uebrigens gleich noch mal? :)

-----------------------------------------------------------------------------



Re^10: so. (Wim,  9. Apr 2000, 23:06:15):
~#! rn=Trug rt=955313903 rg=gilden.zauberer
~#! tid=955293221
Die Originalfrage war: "war diese rundumschlagloesung das entfernen aller
zauberkomponenten bis auf eine letzte jeder sorte?" mit der korrekten Antwort
"nein". 
Natuerlich haette ich schreiben koennen, "Was meinst Du mit Deiner Frage?"
aber ich bin es Leid, den Leuten immer alles aus der Nase ziehen zu muessen.
Schlechte Fragen bedingen kurze Antworten. 

Darauf hin frug er dann "duerfen wir dann erfahren, wieso die kompos
verschwunden sind?"
Auch wieder ohne zu erwaehen, _wovon_ er eigentlich redet. Also eine sinnfreie
oder wenn es Dir besser gefaellt, informationstechisch unvollstaendige Frage.


-----------------------------------------------------------------------------



Re^11: so. (Hood,  9. Apr 2000, 23:07:38):
~#! rn=Wim rt=955314375 rg=gilden.zauberer
~#! tid=955293221
nun gib doch endlich zu, dass es ein falsches update war ;)

-----------------------------------------------------------------------------



seid mal nicht so (Weatherwax,  9. Apr 2000, 23:10:43):
Hallo Zaubberer, vielleicht sollten wir alle nicht vergessen - bei aller
Kritik, berechtigt oder unberechtigt, - da sich hier Leute ARBEIT machen,
damit andere Leute SPIELEN knnen. Ich jedenfalls schtze das ungemein.

-----------------------------------------------------------------------------



Re^11: so. (Rardian, 10. Apr 2000, 14:08:41):
~#! rn=Wim rt=955314375 rg=gilden.zauberer
~#! tid=955293221
Hm... mir scheint, schlechte Fragen implizieren lange Flame-Threads. Das ist
aber wohl der Nachteil, wenn man versucht, korrekt zu antworten.

Rar, niemanden angreifen wollend.

-----------------------------------------------------------------------------



Striptease (Betty, 14. Apr 2000, 14:52:44):
Hi,
ist das eigentlich ein Bug oder ein Feature, dass man sich 
bei "stecke alles in guertel" jedesmal auszieht ??
Oder gibt es eine andere Moeglichkeit, alle Komponenten auf
einmal in den Guertel zu kriegen ??

Ratlos und schon wieder fast nackt ... Betty

-----------------------------------------------------------------------------



Re: Striptease (Thufhir, 14. Apr 2000, 14:53:54):
~#! rn=Betty rt=955716764 rg=gilden.zauberer
~#! tid=955716764
wie waere es mit: stecke alle komponenten in guertel ??? ;)
kurz und knapp, s'zauberzwerch.

-----------------------------------------------------------------------------



Re: Striptease (Hood, 14. Apr 2000, 15:09:06):
~#! rn=Betty rt=955716764 rg=gilden.zauberer
~#! tid=955716764
das heisst nicht bug oder feature, sondern feature oder absicht :)

-----------------------------------------------------------------------------



Re: Striptease (Wim, 14. Apr 2000, 18:29:15):
~#! rn=Betty rt=955716764 rg=gilden.zauberer
~#! tid=955716764
Schonmal darueber philosophiert, was genau "alles" heisst?
Irgendwie draengt sich mir da das Bild der Schlange auf, die sich selber
verschlucken will.
Also rein daher betrachtet ist das schon korrekt so...

-----------------------------------------------------------------------------



Re: Striptease (Weatherwax, 18. Apr 2000, 20:09:36):
~#! rn=Betty rt=955716764 rg=gilden.zauberer
~#! tid=955716764
ROTFL

-----------------------------------------------------------------------------



Teleport-Sperre in Gors Festung (Vardion, 23. Mai 2000, 00:39:34):
Hi.

Wie gestern festgestellt wurde, ist in Gors Festung Teleport nur noch sehr
eingeschraenkt moeglich. Dazu gibt es weder ein Posting von Gor, noch irgend
eine andere Erklaerung. Deshalb werfe ich mal die Frage in den Raum, ob das
vielleicht irgendwas mit den Ereignissen der vergangenen Tage bezueglich
Amaryllis' Sachen zu tun hat, und zum Teil auch aus Frust geschah. Da sowas
fuer Leute, die davon ausgehen, dass es funktioniert, ziemlich ueble Folgen
haben kann, bitte ich hiermit mal um eine Erklaerung von Gor bzw. den
Verantwortlichen Magiern.

Vardion

-----------------------------------------------------------------------------



Re: Teleport-Sperre in Gors Festung (Gor, 23. Mai 2000, 02:27:31):
~#! rn=Vardion rt=959035174 rg=gilden.zauberer
~#! tid=959035174
Ereignisse: Nein
Frust: Nein
Geheimes Projekt: Ja :)))

-----------------------------------------------------------------------------



Re: Re: Teleport-Sperre in Gors Festung (Hood, 23. Mai 2000, 02:31:26):
~#! rn=Gor rt=959041651 rg=gilden.zauberer
~#! tid=959035174
ein geheimes projekt, welches damit anfaengt, ohne jegliche
rollenspieltechnische begruendung sinnlos teleport zu kappen, und das in
einem bereits angeschlossenem gebiet?
na da sind wir mal gespannt...
ob das jetzt das glaubwuerdige dementi war...ich tip doch eher auf frust.

-----------------------------------------------------------------------------



Re^3: Teleport-Sperre in Gors Festung (Lug, 23. Mai 2000, 02:32:56):
~#! rn=Hood rt=959041886 rg=gilden.zauberer
~#! tid=959035174

Und Du willst von mir sinnvolle Artikel haben Hood? Schreib erst einmal selber
welche...

Tss
Lug

-----------------------------------------------------------------------------



Re: Re: Teleport-Sperre in Gors Festung (Vector, 23. Mai 2000, 11:28:48):
~#! rn=Gor rt=959041651 rg=gilden.zauberer
~#! tid=959035174
Jo, stimmt, das Projekt ist ja noch supergeheim:)
Also, seit da mal dieser ganze Dialog einer gewissen Kaempferin gepostet
wurde, kennt wohl _jeder_ mpa-leser das Projekt.

->schmarrn

-----------------------------------------------------------------------------



Re^3: Teleport-Sperre in Gors Festung (Gor, 23. Mai 2000, 11:32:19):
~#! rn=Vector rt=959074128 rg=gilden.zauberer
~#! tid=959035174
Am Teleport hab ich jetzt die Ideen einiger eurer Mitstreiter einfliessen
lassen. Nach dem naechsten Zwergenangriff solltet ihr euch wieder
teleportieren koennen.

Gor

-----------------------------------------------------------------------------



Re^3: Teleport-Sperre in Gors Festung (Wim, 23. Mai 2000, 18:44:33):
~#! rn=Hood rt=959041886 rg=gilden.zauberer
~#! tid=959035174
Ich weiss nicht, aber irgendwie kann auch ich mich eines Verdachts nicht ganz
erwehren, dass in letzter Zeit zu freimuetig mit der Sperrung des Teleports
umgegangen wird.

-----------------------------------------------------------------------------



Re^4: Teleport-Sperre in Gors Festung (Mupfel, 24. Mai 2000, 01:58:46):
~#! rn=Wim rt=959100273 rg=gilden.zauberer
~#! tid=959035174
Najaaaa... dann sperrenwer halt weniger und machen dafuer mehr "interessante
UMleitungen" ;) aber mal im Ernst: so nett das fuer den Spieler auch sein mag,
als Magier (zumindest manche) sieht man die Leute doch lieber bei sich im
Gebiet sterben, als woanders...

(schon allein wegen dem Killhighscore ;)

-mupfel-

-----------------------------------------------------------------------------



Re^5: Teleport-Sperre in Gors Festung (Gor, 24. Mai 2000, 09:53:26):
~#! rn=Mupfel rt=959126326 rg=gilden.zauberer
~#! tid=959035174
Stimmt Mupfel.. Ich bau es wieder aus....

Gor grinsend.

-----------------------------------------------------------------------------



Re^5: Teleport-Sperre in Gors Festung (Ark, 24. Mai 2000, 21:19:28):
~#! rn=Mupfel rt=959126326 rg=gilden.zauberer
~#! tid=959035174
Hm, diesen 'Score', 'Statistik' oder wie auch immer, kann man ja beliebig
beeinflussen :-)
Ich trau der Statistik eh nur, wenn ich sie selbst manipuliert habe, hehe.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



BUH! (Darkwing, 15. Jun 2000, 10:45:32):
Ist ja klasse dass sich im Moment Leute sperren und ueber Gildenaustritt
nachdenken, die bei den Zauberer ganz oben stehn ... und hier steht NIX ??!
Ich weiss, es gibt da diese Rubrik wo nur die wichtigen Zauberer lesen
duerfen, aber ein paar klitzekleine Infos was sich so tut waeren echt klasse
:-)

Direkt Wim fragen mag ich nicht, hab schon die NPC-Balance gehakt, obwohl es
da eine Menge zu tun gaebe :) 

Nix fuer ungut,
Darkwing/Trauma

-----------------------------------------------------------------------------



Re: BUH! (Niete, 15. Jun 2000, 10:50:21):
~#! rn=Darkwing rt=961058732 rg=gilden.zauberer
~#! tid=961058732
was soll man da schon schreiben? wuerde doch sowieso nur 1000 'heul doch'-
artikel nach sich ziehen...


-----------------------------------------------------------------------------



Re: Re: BUH! (Karis, 15. Jun 2000, 10:54:34):
~#! rn=Niete rt=961059021 rg=gilden.zauberer
~#! tid=961058732
Da koennte ein gewisser Jemand so einiges dazu schreiben. Und ich
finde, er sollte es auch. Eine kleine Begruendung fuer schwerwiegende
Aenderungen faende ich schon angebracht. Danach koennen wir dann gerne
wieder in den Heul-doch-Thread uebergehen.

Karis, Kaempfer.

-----------------------------------------------------------------------------



Re: Re: BUH! (Gor, 15. Jun 2000, 10:54:52):
~#! rn=Niete rt=961059021 rg=gilden.zauberer
~#! tid=961058732
Ganz geil, bei kleinen Aederungen von 50 Raeumen heult man rum und verlangt
nen Artikel und bei grundlegenden Gildenaenderungen ist das allen egal oder
wie? Super Einstellung!!!!

-----------------------------------------------------------------------------



Re^3: BUH! (Karis, 15. Jun 2000, 10:56:58):
~#! rn=Gor rt=961059292 rg=gilden.zauberer
~#! tid=961058732
Du hast das nicht verstanden, Gor. Das 'egal' heisst: selbstverhaengte
Spielsperre und Gildenaustritt. Ach ja - es gibt auch ZAuberer, die grad
die Gilde bestreiken. 

Karis, findet, dass da mal einer Lesen lernen sollte ....

-----------------------------------------------------------------------------



Re^3: BUH! (Niete, 15. Jun 2000, 11:07:09):
~#! rn=Gor rt=961059292 rg=gilden.zauberer
~#! tid=961058732
ganz ruhig, meine 'super einstellung!!!!' ist nicht zwangsweise charakte-
ristisch fuer die restlichen gildenmitglieder. worauf bezieht sich uebrigens
die bemerkung ueber 'kleine aenderungen von 50 raeumen', ich moechte doch gern
wissen, worueber ich da nochmal rumgeheult habe...


-----------------------------------------------------------------------------



Re^4: BUH! (Humni, 15. Jun 2000, 11:17:32):
~#! rn=Niete rt=961060029 rg=gilden.zauberer
~#! tid=961058732
Ja, ich fand auch schade, dass man nix darueber hoert, aber ich kann 
die Leute auch verstehen. Bei den letzten Aenderungen an der Karategilde
hat auch ein (IMHO) harmloser Artikel meinerseits dazu gefuehrt, dass
ich wie bloed von allen Leuten geflamet wurde und dann keine Lust mehr
auf Diskussionen hatte.
Ergebnis: Die Gilde hat ca. 25% Mitgliederschwund seitdem (Topliste) 
und keinen interessierts. Ich hab nicht die geringste Ahnung wie
die Abwertung bei den Zaubis zustandekam und was dahintersteckt,
aber ich kann die Leute verstehen, die sich selbst lieber ne
Spielpause verhaengen oder austreten. Nur: Ich finds um einige
von den Leuten echt schade und hoffe, dass sich bald mal was klaert.
Und zwar so, dass das VIELLEICHT auch mal Zaubi-Zweities mitkriegen
(Trauma z.B. beschwert sich bestimmt nicht ohne Grund).

Und wer das jetzt missversteht: Dieser Artikel ist NICHT gegen
Rochus gerichtet sondern gegen die allgemeine Diskussions- und
Informationskultur in diesem MUD.

(Jetzt bald vermutlich wieder Jammerer) Humni

-----------------------------------------------------------------------------



Re^5: BUH! (Vector, 15. Jun 2000, 11:18:48):
~#! rn=Humni rt=961060652 rg=gilden.zauberer
~#! tid=961058732
Die 25% Mitgliederschwund werden wir toppen... locker

--Vector--

-----------------------------------------------------------------------------



Re^6: BUH! (Hight, 15. Jun 2000, 12:16:41):
~#! rn=Vector rt=961060728 rg=gilden.zauberer
~#! tid=961058732
ob nun 25% schwund oder nicht weiss ich net abbe ich kann verstehen das die
angesprochen spieler den kanal nun endglueltig voll haben ... ich slebst hab
nur nen zwieitie in der gilde der nochnetmal besonders gut ist 
aber auch ich bin am ueberlegen ob ihn net rausnehmen soll ... mit dieser
abwertung habt ihr eine der haupt"waffen" die einem zaubi zur verfuegung
stehen kaputt gemacht 

nachdem wim mir versucht hat seine beweggruende zu erklaeren kann ich nur
nocheinmal sagen, dass das der verkehrteste ansatz war das problem zu beheben
der einem einfallen koennte.


hight auf eine alternative gilde zu den zaubis wartend

-----------------------------------------------------------------------------



Re^3: BUH! (Anatol, 15. Jun 2000, 14:02:06):
~#! rn=Gor rt=961059292 rg=gilden.zauberer
~#! tid=961058732
> Ganz geil, bei kleinen Aederungen von 50 Raeumen heult man rum und verlangt
> nen Artikel und bei grundlegenden Gildenaenderungen ist das allen egal oder
> wie? Super Einstellung!!!!

Ich verstehe Deinen Unmut, Gor, aber bitte versuche auch, die Zauberer
etwas zu verstehen: Gerade die ueberzogenen Aktionen gegen die Zauberer
(sei es nun das Abfangen von 'befriede', 'teleport' oder aehnliches)
hat ein Grossteil des Zaubererdilemmas verursacht: Damals, als die
Zauberer gerade gross wurden, war "verletze" ein vergleichsweise
starker Spruch und wurde (es gab ja noch keine Kompo-Hand) auch gut
genutzt. Zum Leidwesen der Zauberer befand aber ein Teil der Magier, 
dass ihre NPCs auf konventionelle Weise zu bekaempfen sind und in
einigen (leider teilweise bedeutenden) Ecken dieser Welt brachte die
Offensive der Zauberer nichts mehr; man rannte gegen die Grosse Magie
namens P_NOMAGIC oder SpellDefend an. Der Gedanke des damaligen
Gildenmagiers war (er moege mich korrigieren, wenn ich das jetzt
falsch erklaere), mit "hand feuer/eis/saeure" fuer Notfaelle und damit
zumindest einem Teil der betroffenen Gebiete eine Abhilfe zu schaffen:
Die "hand" der Zauberer geht ja nicht ins SpellDefend.

Inzwischen stellte sich heraus, dass "Komponentenknappheit" einfach
kein gutes Mittel ist, einen Spruch zu regulieren: Die Anzahl der
Magister waechst, die Welt waechst auch -- aber weder steht das in
irgendeiner Relation, noch bedeutet "mehr Komponenten", dass die 
groessere Anzahl an Magistern davon gleichverteilt abbekommt. So
scheint es mir zumindest, YMMV. Als mit einer Aenderung in den 
Katakomben der letzte Tropfen Feuerwasser ins Fass fiel, entstand
offenbar Handlungsbedarf, so dass die Zauberer nun gleich zwei grosse
Diskussionspunkte haben statt nur einen: a) Wie muessen wir unsere Akademie
strukturieren, dass es von Kampfkraft und -technik wieder richtig passt,
b) Wie koennen wir die Zweigverteilung besser regeln?

Zu beiden Punkten gibt es wohl schon - wie in der zhist, so sie denn
nicht mal wieder uebergelaufen ist, zu lesen ist - Loesungsansaetze,
die aber moeglicherweise nicht perfekt und verbesserungsfaehig sind.

Anatol


-----------------------------------------------------------------------------



Re^4: BUH! (Gor, 15. Jun 2000, 14:16:18):
~#! rn=Anatol rt=961070526 rg=gilden.zauberer
~#! tid=961058732
Ich habe leider keine Moeglichkeit mir die Infos in der ominoesen Zhist
durchzulesen. Man hat mir nur bisher von verschiedenen Seiten berichtet, wie
gravierend die Abwertungen fuer Zauberer sind. Deshalb kann ich es nicht
verstehen, dass sich keiner, fuer mich sichtbar ruehrt, um etwas dagegen zu
unternehmen. So wie ich das mit meinen Informationen beurteilen kann ist die
Abwertung deutlich ueberzogen und gehoert fuer mich zumindest teilweise wieder
rueckgaengig gemacht. Das aufgrund der Komposchwemme Handlungsbedarf besteht,
daruber brauchen wir sicherlich nicht Diskutieren. Aber um die massige Anzahl
von Kompos in Griff zu bekommen, indem man Zaubersprueche, die sich seit
Jahren bewaehrt haben, zu aendern, ist fuer mich der falsche Loesungsansatz.

Gor contra Abwertung.

-----------------------------------------------------------------------------



Re^5: BUH! (Hood, 15. Jun 2000, 14:30:51):
~#! rn=Gor rt=961071378 rg=gilden.zauberer
~#! tid=961058732
da  ich strikt gegen eine abwertung der komponentenhand bin und auch
gegen ein totales abklemmen, finde ich die loesung mit der
anzahlsbeschraenkten nutzung gar nicht so verkehrt.
sicher: ueber die zahlen kann man noch reden, aber eine spuerbare
bechraenkung der nutzung dieses spells muss her.
nochmals: ich hab den spell damals als ersatz fuer viele items
aus dem fach artellerie gebracht, die uns in grossem umfang verboten
wurden.
die kompohand ist nen ausnahmespell, mal etwas mehr als normal machen,
wenn man vorher etwas aufwand reinsteckt.
er war nie dafuer gedacht, die restlichen angriffsspells unserer
gilde einstauben zu lassen.
das beliebte bevorzugte zaubererbenachteiligen in manchen neueren gebieten
steht hierbei auf einem ganz anderen blatt, das ich natuerlich auch schon
mehrfach kritisierte,
eine loesung ware halt, dass wim als gleichzeitige npc-balance da einfach
mal ein staerkeres auge drauf richtet, schreibt ihm, wenn ihr euch
irgendwo uebermaessig und nicht rollenspielgerecht benachteiligt fuehlt.
eine technische loesung waere das auch bereits von mir vorgeschlagene
einrichten eines masters, was zb teleport-sperren/aenderungen oder
spelldefends abfaengt und filtert, man muss sozusagen dem gildenmagier
kurz fragen, ob das so ok geht, es wird eingetragen und fertig.
viele magier koennen ihr tun in dieser richtung einfach nicht korrekt
einschaetzen und das ergebnis sehen wir...

-----------------------------------------------------------------------------



Re^6: BUH! (Paracelsus, 15. Jun 2000, 14:35:32):
~#! rn=Hood rt=961072251 rg=gilden.zauberer
~#! tid=961058732
> viele magier koennen ihr tun in dieser richtung einfach nicht korrekt
> einschaetzen und das ergebnis sehen wir...

Nun, aber RMs sollten soetwas einschaetzen koennen, oder? Und die sollten
ein Gebiet ja bekanntlich genehmigen, bevor es angeschlossen wird.

Para*

-----------------------------------------------------------------------------



Re^7: BUH! (Hood, 15. Jun 2000, 14:37:54):
~#! rn=Paracelsus rt=961072532 rg=gilden.zauberer
~#! tid=961058732
koennen sie wohl kaum. wer ist denn RM? ausserordentlich faehige leute,
oder doch eher leute, die viel gemacht haben und halt zur verfuegung
stehen?
selbst wenn alles ausserordentlich faehige RMs waeren, ich erwarte von
denen keinesfalls, dass sie jede gilde kennen und die auswirkungen diverser
aktionen die damit in verbindung stehen.

-----------------------------------------------------------------------------



Re^8: BUH! (Paracelsus, 15. Jun 2000, 14:39:41):
~#! rn=Hood rt=961072674 rg=gilden.zauberer
~#! tid=961058732
Dann waere vielleicht eine Art Leitfaden nicht schlecht, in dem
Gildenmagier (in kurzer Form) einige Infos niederschreiben, was man
bezueglich ihrer Gilde beachten sollte, fuer RMs.

Para*

-----------------------------------------------------------------------------



Re^7: BUH! (Morgoth, 15. Jun 2000, 14:41:13):
~#! rn=Paracelsus rt=961072532 rg=gilden.zauberer
~#! tid=961058732
Und was mache ich dann als bekennender Zaubererhasser ;-))

Aber es stimmt schon, was Hood bzgl. der NPC-Balance gesagt hat. Die scheint
irgendwie "nur auf dem Papier" zu existieren ;-(

M*

-----------------------------------------------------------------------------



Re^5: BUH! (Obermotz, 15. Jun 2000, 14:46:51):
~#! rn=Gor rt=961071378 rg=gilden.zauberer
~#! tid=961058732
Wie waere es mit einem Spruch, der die "Magieresistenz" senkt? Man kann das
alte System so lassen, und auch beim Feuerdaemon wuerden dann nicht mehr 9 von
10 verletze-Sprueche geblockt werden.

OM metzelt im Moment nicht so viel

-----------------------------------------------------------------------------



Re^9: BUH! (Anatol, 15. Jun 2000, 14:47:25):
~#! rn=Paracelsus rt=961072781 rg=gilden.zauberer
~#! tid=961058732
''  1. Fuer das Gleichgewicht der Gilden ist ausschliesslich die
       Gildenbalance verantwortlich. ''

Das ist, denke ich, das wichtigste, Para ;)

Anatol

-----------------------------------------------------------------------------



Re^10: BUH! (Karis, 15. Jun 2000, 14:50:19):
~#! rn=Anatol rt=961073245 rg=gilden.zauberer
~#! tid=961058732
Dann sollten aber saemtliche Aenderungen (ja, auch Abwertungen) dort
erstmal vorgelegt werden. Schliesslich ist die Balance ja betroffen - egal in 
weclher Richtung.
Und schliesslich: ich faende das schon mal interessant zu wissen,
nach welchen Kriterien din der Gildenbalance gearbeitet wird.
Und wenn ichs als Spieler net wissen soll - die Magier, die sollten
das wohl wissen.

Karis

-----------------------------------------------------------------------------



Re: BUH! (Wim, 15. Jun 2000, 15:19:27):
~#! rn=Darkwing rt=961058732 rg=gilden.zauberer
~#! tid=961058732
"Eine Menge zu tun"... Tja. Hellsichtig bin ich noch nicht und wenn Du mir
nicht schreibst, was Dir auf der Leber liegt, kann ich mir auch nichts
ansehen. Soviel dazu.

"Leute sperren"? Wer hat sich denn gesperrt ausser Spellfire, der nichtmal im
Log aufgetaucht ist, somit keinerlei Wissen aus erster Hand besitzt. 

Die klitzekleine Info steht im Brett im Zauberberg: Uebermaessiger Gebrauch
von Kompohand hat Nachteile. Das sollte erstmal reichen.

-----------------------------------------------------------------------------



Re^3: BUH! (Wim, 15. Jun 2000, 15:22:18):
~#! rn=Karis rt=961059274 rg=gilden.zauberer
~#! tid=961058732
Ich halte es nicht fuer eine schwerwiegende Aenderung, dennoch ist die
Begruendung, dass aus der Ausnahmeverwendung der Kompohand selbst vor
Veraenderung der Mengen inzwischen schon laengst fuer einige wenige
familienstarke Zauberer ein Dauerzustand wurde. Im Endeffekt richtet sich
diese Sperre (lt. log) derzeit gegen gerade mal 5-8 zauberer. Toll, dass auch
all diejenigen mitschreien, die keinerlei Veraenderung bemerkt haben.

-----------------------------------------------------------------------------



Re^7: BUH! (Wim, 15. Jun 2000, 15:23:57):
~#! rn=Hight rt=961064201 rg=gilden.zauberer
~#! tid=961058732
Welcher bessere Ansatz ist Dir denn eingefallen?

-----------------------------------------------------------------------------



Re^5: BUH! (Wim, 15. Jun 2000, 15:24:41):
~#! rn=Gor rt=961071378 rg=gilden.zauberer
~#! tid=961058732
Hast Du doch. Jeder Magier Level >= 21 kann die zhist lesen. Der Filename ist
kein Geheimnis.

-----------------------------------------------------------------------------



Re^6: BUH! (Wim, 15. Jun 2000, 15:25:13):
~#! rn=Hood rt=961072251 rg=gilden.zauberer
~#! tid=961058732
danke.

-----------------------------------------------------------------------------



Re^8: BUH! (Wim, 15. Jun 2000, 15:26:15):
~#! rn=Morgoth rt=961072873 rg=gilden.zauberer
~#! tid=961058732
Meinst Du? Blos weil ich die zwei von Dir angemeckerten NPCs aus unterwelt
nicht habe aendern lassen, weil ich keinen Handlungsbedarf dazu sah? och...

-----------------------------------------------------------------------------



Re: Re: BUH! (Anarinya, 15. Jun 2000, 20:15:40):
~#! rn=Wim rt=961075167 rg=gilden.zauberer
~#! tid=961058732
Tja, Wim.
Eigentlich hat Dein Artikel es wirklich nichtmal verdient, kommentiert zu
werden, so sehr spricht er eigentlich fuer sich selber und gegen Deine
Gildenpolitik.

Ich halte es fuer eine Frechheit, eine solche Aenderung nicht bekannt zu 
geben. Dein Verweis auf das Gildenbrett und die 
Spruchhilfe ist so absurd, dass ich kaum glauben kann, was
ich da lesen muss. 2 orakelige Saetze sind einfach nichts, was 
irgendwie annaehernd unter Information fallen wuerde. Wenn Du Deine
Gildenleute so behandelst, dann wundere Dich nicht, wenn unsere Gilde vor die
Hunde geht. Und ich spreche damit in erster Linie Deine Infopolitik an und
nachrangig die Aenderungen.

Und diesen Satz, wer sich denn ausser Spellfire gesperrt haette ... naja, was
soll man dazu noch sagen, Spelli ist ja nur einer der aktivsten Zauberer ...
Ausserdem glaube ich nicht, dass du aufgrund von abstrusen Logs beurteilen
kannst, wen diese Abwertung betrifft und wer sich damit auskennt. Es ist
wirklich schade, dass Deine Kommunikation mit den Gildenmitgliedern ueber Logs
laeuft, anstatt ueber Gespraeche. Das sagt eigentlich schon alles.

Ich persoenlich habe mich sehr gefreut ueber den Dialog unter den Zaubis, der
enstanden ist, als die Postenvergabe diskutiert wurde. Der lief uebrigens auf
zhist ab (btw. in der Magisterrubrik steht nix weiter von Interesse fuer die 
aktuelle Problematik).
Was Du daraus gemacht hast, sieht man ja an den Leuten, die vorher aktiv 
mitgesprochen haben und nun auf einmal mit der Gilde nix mehr zu tun haben
wollen. Und zwar nicht nur, weil sie abgewertet wurde 
(das war schon oft so und niemand hat sich gesperrt), sondern halt vor
allem, weil man von Dir behandelt wird, wie ein ueberfluessiges, nicht
informationswuerdiges Spieleranhaengsel. Sprich, man hat als Spieler das
Gefuehl, durch ne Diskussion ueberhaupt nix mehr veraendern zu koennen.

Naja, ich denke, mein Artikel faellt bei Dir ja sowieso unter die Kategorie
'emotionales Gelaber' ;-), was dann auch nur wieder zeigt, dass Du als 
Gildenmag null Fingerspitzengefuehl hast.

Anarinya, in Vertretung fuer Zwergenzauberine Liara


-----------------------------------------------------------------------------



schnauze voll (Wulfgar, 16. Jun 2000, 13:49:39):
Moin,

Wenn ich schon namentlich in Artikeln erwaehnt werde moechte ich dann doch
auch mal was zu dem Thema  schreiben.
Ich war seht guter Dinge und recht motiviert mit an dem strukturellen Wandel
der Gilde (der auch in meinen Augen noetig ist) zu arbeiten und meine Zeit und
Manpower anzubieten. Der erste Schritt in die Richtung war meine Teilnahme an
der mehrstuendigen Diskussion auf zhist ueber die Vergabe der Magisterposten
und das anschliessen Posting der Zusammenfassung in br.zauberer. Man fuehlt
sich dann mehr als verarscht wenn der zustaendige Magier, der einen zuvor noch
aufgefordert hat mitzuarbeiten, hingeht die Gilde dann doch nach eigenem
Duenken undurchdacht veraendert. Also meine Motivtaion konstruktiv zu helfen
ist ein fuer alle mal gebrochen. 
Das Mud ist halt doch ne Zweiklassengesellschaft, Magier die tun was sie
wollen und Spieler die nix zu sagen haben ( achja und dann gibbet die Exoten
die sich Objektbalance nennen, denken sie kennen alles,  Idealisten sind und
zu Boing Geburtstag eingeldaen werden....).
Aber dann es zwingt mich ja keiner in der Zauberergilde zu bleiben, deshlab
werd ich den fuer mich einzig konsequenten Schritt betreiben, Gildenwechsel
sobald es eine braucbare Alternative gibt, und ich weiss auch das ich da nicht
der einzige bin.
Mit Spelli werd ich zumindest nicht bei den Kaempfern betteln damit wer mit in
die Gebiete kommt in denen ich nur einmal pro runde schaden mit verletze
machen kann (Auch Spieler haben Ehre ;>). 
Und Wim ich muss nicht unbedingt mit Spellfire in Logs auftauchen um zu sehn
wie die neuen Zauberer sind.


bis denne Bacchusjuenger Spellfire


-----------------------------------------------------------------------------



Re^3: BUH! (Gloin, 16. Jun 2000, 14:35:43):
~#! rn=Anarinya rt=961092940 rg=gilden.zauberer
~#! tid=961058732
Um mit an der Lanze fuer "die Magier" zu brechen:
- orakelige Saetze fuer Spieler reichen meiner Meinung nach voellig
  aus -> wer Formeln und Werte wissen will, soll gefaelligst Magier
  werden

Und um meine Magierhaltung in einem anderen MUD hier zu wiederholen:
- Diskussionsbeitraege von Spielern sind immer gewuenscht. Sie koennen
  nette Alternativen aufzeigen, an die ein Magier noch nicht gedacht
  hat. Kein Spieler sollte sie jedoch als Abstimmung, massgebliches
  Meinungsbild und zu implementierenden Entscheid verstehen, auch wenn
  Euch das frustrieren mag.

Letztendlich liegt die Entscheidung ueber Wohl und Wehe beim verant-
wortlichen Magier. Dass Wim sich hier nur in Balance-Belangen taetig
zeigt, weil es (noch) nicht sein Gilde ist, ist Euch sicher noch nicht
aufgefallen ...

Gloin

-----------------------------------------------------------------------------



Re: schnauze voll (Anatol, 16. Jun 2000, 15:15:13):
~#! rn=Wulfgar rt=961156179 rg=gilden.zauberer
~#! tid=961156179
Boooooooaaaaaaah Spelli :)

Also nochmal langsam: Du beschwerst Dich, weil Du nach einer
(in meinen Augen notwendigen, YMMV) Anpassung der Gilde nicht
mehr der uebermaechtige Held in Regionen bist, die nur geschrieben
wurden, eben weil es uebermaechtige Helden gab und nur, weil
eben JENE uebermaechtigen Helden das Maul nicht aufkriegen, um 
dem Regionsmagier zu sagen, dass sein Produkt leicht ueberzogen 
ist, weiter in dieser Form existieren?

Mh, ist das nicht so in etwa dasselbe wie "Ich gehe nicht zur
Wahl, rege mich aber ueber die Regierung auf!"?

Anatol


-----------------------------------------------------------------------------



Re^4: BUH! (Nizzl, 16. Jun 2000, 15:24:38):
~#! rn=Gloin rt=961158943 rg=gilden.zauberer
~#! tid=961058732
>orakelige Saetze fuer Spieler reichen meiner Meinung nach voellig aus....
ok ab sofort sag ich dann nur noch: hey magier in deinem gebiet ist ein klasse
bug, kann man tolle sachen mit machen. ich sag aber nicht wo. viel spass beim
suchen.
soweit zum thema kommunikation.
waere es schlimm gewesen zB zu sagen: liebe herren und damen zauberer ab
sofort koennt ihr nur noch 15 mal (oder wie oft auch immer) pro reset eine
kompo-hand casten.
aber stattdessen reicht es ja zu sagen: ..festhalten...ok zauberer <6 sind
bissl abgewertet...ihr werdets merken...oder auch nicht.

Nizzl, geht eigentlich alles mittlerweile am Hut vorbei :)

-----------------------------------------------------------------------------



Re^5: BUH! (Hood, 16. Jun 2000, 15:29:10):
~#! rn=Nizzl rt=961161878 rg=gilden.zauberer
~#! tid=961058732
genaue zahlenwerte wurden an spieler noch nie weitergegeben, was soll
das auch? die info am brett im zauberberg ist eindeutig und sollte
zumindest zu einem test animieren, bevor man sich voller wut in eine
diskussion stuerzt.
ich werde noch mal die handdoku ueberarbeiten, damit dann wirklich alle
unklarheiten beseitigt sind. aber: zahlenwerte werdet ihr auch darin
_nicht_ finden.

-----------------------------------------------------------------------------



Re: schnauze voll (Anatol, 16. Jun 2000, 15:48:26):
~#! rn=Wulfgar rt=961156179 rg=gilden.zauberer
~#! tid=961156179
Ach ja, da war noch was...

S> Das Mud ist halt doch ne Zweiklassengesellschaft, Magier die tun was sie
S> wollen und Spieler die nix zu sagen haben ( achja und dann gibbet die
S> Exoten die sich Objektbalance nennen, denken sie kennen alles,
S> Idealisten sind und zu Boing Geburtstag eingeldaen werden....).

Das ist so, denke ich, nicht korrekt.

JA, es gibt Spieler und Magier und letztere werden in den allermeisten
Faellen das letzte Wort haben. "Institutionen" wie NPC-Balance oder die
Objektbalance sind aber dazu da, auf Hinweise und Argumentation der
(Mit-) Spieler einzugehen und sie in die Entscheidungsprozesse so weit
wie moeglich einfliessen zu lassen. Auch viele Gilden- und Regionsmagier
lassen mit sich reden und sind zur Diskussion bereit.

DEIN Problem, Spellfire, ist, dass auch die Spielerwelt nicht homogen
ist. Vielleicht finden naemlich nur jene Spieler wenig Gehoer, die von
ihrer Grundeinstellung ausgehend GEGEN die Magier arbeiten. Oder jene,
die generell keinen Ton von sich geben (aber die verwundert das nicht).

Oh. Und noch was: Ja, kann durchaus sein, dass die Mitglieder der
Objektbalance aus Deiner Sicht Exoten sind. Es sind Idealisten, die ihr
Moeglichstes tun, laengerfristigen Spielspass zu wahren. Das Ausnutzen
von Programmierfehlern und -schwaechen gehoert da ebensowenig dazu
wie unbaendige Freude ueber ein superabsoluttollstarkes Tool oder 
einen fehldimensionierten Gildenspruch.

Ich weiss, ich habe moeglicherweise ein extrem gefaerbtes Weltbild
(Exot ;)), aber bitte, ich bin gerne zu einem Meinungsaustausch bereit,
ich lerne wirklich gern dazu...

Anatol

-----------------------------------------------------------------------------



Re: Re: schnauze voll (Silvana, 16. Jun 2000, 18:26:07):
~#! rn=Anatol rt=961163306 rg=gilden.zauberer
~#! tid=961156179
Irgendjemand hat mal gesagt, wenn sich die Geschichte wiederhole, dann nur als
Farce. Wenn ich die Rubrik so lese, dann muss ich's glauben...
Ehrlich gesagt, ich bin froh, dass ich fuer die Gilde nicht mehr zustaendig
bin - und ich glaube, ihr koennte da auch froh drueber sein...

  Silvana

-----------------------------------------------------------------------------



Re: schnauze voll (Teddy, 16. Jun 2000, 22:53:42):
~#! rn=Wulfgar rt=961156179 rg=gilden.zauberer
~#! tid=961156179
Nicht viel, das meiste ist von Anatol bereits gesagt.
Eigentlich nur eine Bitte, bleib beim Thema, hau nicht einfach ohne Sinn und
Verstand auf alle drauf, die dir grad in die Quere kommen.

Teddy, der eigentilch mal nen anderen Spellfire kennengelernt hat.

-----------------------------------------------------------------------------



Artikel Aufwertung vs. Abwertung (Hexxer, 17. Jun 2000, 18:58:35):
Ja eigentlich faszinierend wie schnell die MPA sich mit Artikeln fuelltm
wennes Auf- oder Abwertungen in einer Gilde oder Region gibt.

Verstaendlich sind die ungluecklichen Spieler und die teilweise zu Unrecht 
verurteilten Magier. (Ohne Namen nennen zu wollen)

Fuer mich stellt sich aber eigentlich die Frage:
"Warum gibt es auf einmal in den Katas Unmengen von Kopos? Hat sich ein
gewisser MAgier M. nicht mit den Gilenmagier der Zaubis WIM nicht abgestimmt,
dass es mehr Kopos geben wird?"

Ich verstehe nicht so ganz, warum mehr Kompos hingestellt werden und dann als
quasi Strafe dafuer dann die nutzenden Gildenmitglieder bestraft werden oder 
abgewertet werden. Aber IHR habt ja nix weiter zu tun als Euch an den Haaren
zu ziehen
und die Zunge gegenseitig rauszustrecken. Tschuldigung aber wird sind doch
nich aufm
Kinderspielplatz ??!!??

Bringt es Spelli (odewr wem auch immer) etwas, sich mit Haenden und Fuessen
gegen die
Entscheidung des Gildenmagiers zu stellen? Sicher wenig. Waere ja auch bloed,
wenn sich 
die Gildenmags erpressen lassen wuerden...

ABER wie immer.. es gibt Aenderungen (nicht ganz ohne Grund) und die lieben
Speiler heulen rum und wollen alles so, wie es jedem persoenlich am besten
passen wuerde.. Nuja jeder hat seinen Stolz. Bloss aendern wird sich dadurch 
nix wirklich zu Gunsten der Gilden und den Gildenmitgliedern (allen, nicht
einzelnen).
Ich erinnere mich noch ganz vorsichtig an die Aktion "Rattenkoenigin". 

Vielleicht sollten wir ja neben der Balance noch eine Gruppe namens 
"Runder Tisch" ins Leben rufen. Die koennten dann quasi den Schlichter
zwischen den
Spielern und Magiern spielen. Ich hoffe mal, das wir doch bald wieder wie
Mudder 
reden und nicht wie kleine, heulende und sich zu Unrecht bestraft halten.

*ein kopfschuettelnder HEXXER*

-----------------------------------------------------------------------------



artikel rechtschreibung und co (Hexxer, 17. Jun 2000, 19:01:39):
Sorry*
Tut mir leid, das der vorige Artikel von mir leichte Rechtschreib und
Formatierungsfehler ausweisst. Doch sitz ich grad mit nem unmoeglichen Rechner
im Netz.
Ich bitte das zu beruecksichtigen und mir nachzusehen.

*ein tippex-Hexxer*

-----------------------------------------------------------------------------



Re: Artikel Aufwertung vs. Abwertung (Morgoth, 19. Jun 2000, 07:23:37):
~#! rn=Hexxer rt=961261115 rg=gilden.zauberer
~#! tid=961261115
Wenn Du lesen koenntest, haettest Du mitbekommen, dass die Kompo-Aenderung
sehrwohl abgestimmt war. Naja, da Du ja anscheinend nur schreiben (lassen)
kannst, such Dir doch mal jemanden, der Dir das hier vorliest.

M*

-----------------------------------------------------------------------------



Re: Artikel Aufwertung vs. Abwertung (Trug, 19. Jun 2000, 08:09:29):
~#! rn=Hexxer rt=961261115 rg=gilden.zauberer
~#! tid=961261115
Das mit den Handkompos trifft (wieder mal) eh nur die 'oberen' 20% der
Zauberer, die halt wohl etwas extrem mit diesen Komponenten arbeiten. So
selber als durchschnittliche Zaubererin spuert man eh wenig davon, und das war
immer zumeist so, dass da immer jene Leute am lautesten aufheulten und
aufheulen, die da ein bisschen extrem-metzeln. 

Nehmt doch nicht unsere Gilde allzusehr ans Herz, als wuerde die Welt dabei
untergehen. Das hier sollte eigentlich noch ein Spiel sein....

Trug

-----------------------------------------------------------------------------



Re: Re: Artikel Aufwertung vs. Abwertung (Hexxer, 19. Jun 2000, 13:43:51):
~#! rn=Morgoth rt=961392217 rg=gilden.zauberer
~#! tid=961261115
Ok, wenn also die Kompos abgestimmt waren, ist das ja ok. Nur versteh ich dann
die Abwertung der Kompo-Hand nicht ganz. Es sei denn, es war von vornherein so
geplant?
Ich geh doch mal davon aus, dass sowohl M. also auch W. sich im klaren waren,
dass aufgrund der "Flut" von Kompos, sich die hoeheren Zaubis darauf stuerzen
werden und fast ausschliesslich nur noch Kompo-Hand als Angriffszauber
verwenden werden. Und dementsprechend auch seitens W. regiert werden muesse,
z.b. in Form einer Beschraenkung der Kompo-Hand. 
Dann waere die Aenderung nur ein ganz normaler Akt von W., um in der Gilde
einige Sachen zu aendern. Doch jeder regt sich nur auf ... "Ja ... das koennt
ihr nicht machen..." und dann als Antwort.. "Wenn ihr nur noch Kompo-Hand
nehmt .. muss ich die beschraenken.." 
WAR EUCH DAS NICHT VON VORNHEREIN KLAR, DASS DIE KOMPO_HAND AUSARTEN WUERDE
???

*be witched, HEXXER*

-----------------------------------------------------------------------------



Re^3: Artikel Aufwertung vs. Abwertung (Anatol, 19. Jun 2000, 15:41:37):
~#! rn=Hexxer rt=961415031 rg=gilden.zauberer
~#! tid=961261115
Genau, es haette von vornherein klar sein koennen (oder muessen?),
dass eine Regelung der Spruchstaerke, die sich primaer auf die
beschraenkte Verfuegbarkeit der Komponenten stuetzt, ins Seitenaus
rollen musste... Wenn wir x Magister haben und y Komponenten mag 
das fuer den Augenblick stabil erscheinen: Die besseren Magister 
("besser" in diesem Kontext: Metzelfaehiger, kundiger, mehr Vit. B)
kommen an mehr Handkomponenten ran, die schlechteren an weniger.
Schwierig wird es schon mit der Uptime, wenn man mit einer Hand-
komponente zwei andere ermetzeln kann (und noch EPs dafuer in den
Rachen gestopft bekommt). Gaenzlich aus ist es dann meiner Meinung
nach, wenn sich x im Laufe der Zeit aendert - was es ja tut, denn
es werden immer mehr Zauberer Magister, mehr zumindest als Magister
aus dem aktiven Dienst ausscheiden. Mehr x bedeutet: knappere y, 
das war so aber nicht geplant, also auch mehr y, was aber nicht
heisst, dass die auf die neuen Magister verteilt werden, sondern
den o.g. Faehigkeiten der Magister entsprechend: Die "besseren"
Magister kommen ploetzlich an NOCH mehr Handkomponenten heran, 
was nicht zu Unrecht als "Aufwertung" gesehen werden kann.

Mh, kann mich ja auch irren.
Anatol

-----------------------------------------------------------------------------



Re^4: Artikel Aufwertung vs. Abwertung (Hood, 19. Jun 2000, 18:29:04):
~#! rn=Anatol rt=961422097 rg=gilden.zauberer
~#! tid=961261115
ja du irrst. aus dem ruder liefen die zahlen doch nur wegen einiger sehr
weniger stellen, die etwas zu grosszuegig bewilligt wurden.
die jetzige regelung ist doch insofern OK, man koennte jetzt mehr
handkompos anschliessen, natuerlich nicht zu leicht zu holen.
der spell wird trotzdem nicht mehr im uebermass genutzt werden koennen.

-----------------------------------------------------------------------------



Re^5: Artikel Aufwertung vs. Abwertung (Anatol, 19. Jun 2000, 18:35:12):
~#! rn=Hood rt=961432144 rg=gilden.zauberer
~#! tid=961261115
Ich irre? Selbst ich hatte im Normalfall mindestens 50 von jeder Sorte
im Guertel hatte, bevor ich mich "ausgeruestet" bezeichnete... Und 
bitte, nur weil der Missstand vorher nicht so krass und offensichtlich
war, ist das noch keine Gegenargumentation.

Anatol


-----------------------------------------------------------------------------



Re^6: Artikel Aufwertung vs. Abwertung (Hood, 19. Jun 2000, 18:43:03):
~#! rn=Anatol rt=961432512 rg=gilden.zauberer
~#! tid=961261115
es ist immer eine kosten-nutzen-frage.
auch mit nur 10 kompos pro reset kann man ueber die nacht locker auf
50 und mehr kompos kommen, alles eine frage der geduld...

-----------------------------------------------------------------------------



Re^7: Artikel Aufwertung vs. Abwertung (Anatol, 19. Jun 2000, 18:48:09):
~#! rn=Hood rt=961432983 rg=gilden.zauberer
~#! tid=961261115
Eben. :o)

Anatol

-----------------------------------------------------------------------------



Re^8: Artikel Aufwertung vs. Abwertung (Hood, 19. Jun 2000, 18:52:34):
~#! rn=Anatol rt=961433289 rg=gilden.zauberer
~#! tid=961261115
wenn das deine anti-kompohand-haltung unterstreichen sollte, dann kann
ich das nicht ganz nachvollziehen.
wenn einer naechtelang handkompos, wurfsterne oder was weiss ich sammelt
und dann mal eine stunde irgendwo ordentlich abfetzen will, so haette
zumindest ich keine probleme damit :)
der vorteil der jetzigen regelung ist halt, dass man die kompos nicht
zu stark limitieren muss, damit auch weniger kranke leute mal in den
genuss kommen ;)

-----------------------------------------------------------------------------



Re^6: BUH! (Gnome, 19. Jun 2000, 19:43:17):
~#! rn=Hood rt=961162150 rg=gilden.zauberer
~#! tid=961058732
falsch.
ich krame mal...
aus den abwertungen der trves:

- bei Kampftritt, Kniestoss, Ellbogenschlag, Kopfstoss und Schildstoss
  wirkt ein eventueller Bonus auf diese Techniken erst, wenn man die
  Ruestung mindestens 2 Sekunden traegt.

find ich vollkommen ok, die info.
denn zwischen einem orakel und dem src-code gibt es immer noch alter-
nativen.
so gesehen bei der trves-abwertung vor etwa 1,5 jahren.
boing hat die schlechten nachrichten gut ruebergebracht. :)

trug? bitte nicht...

gnOme

-----------------------------------------------------------------------------



Re: Re: BUH! (Panic, 20. Jun 2000, 10:52:34):
~#! rn=Wim rt=961075167 rg=gilden.zauberer
~#! tid=961058732
Zu "Wer hat sich denn gesperrt":
Spellfire und Elendil sind inzwischen sogar ausgetreten. Wenn Du denkst dass
die beiden kein Wissen aus erster Hand haben muss ich ja doch ein wenig
grinsen :-)
Im uenbrigen meinte ich nicht diese komische Sperre wenn man Kompo-Hand einige
Male eingesetzt hat, sondern die Abwertung von Hand / Aufwertung von Verletze.

Zur NPC-Balance:
Keine Lust auf Flame, ich hatte es mehrfach personlich gesagt und Du hattest
miese Laune. So von oben herab ist das nict wirklich konstruktiv und hin und
herschicken mit dem zustaendigen Mag macht auch nicht wirklich Spass. Also
versuch ichs eben anders, irgendwo gibts immer nen Weg bei dern Viechern :)

Schoene Gruesse,
Darkwing

-----------------------------------------------------------------------------



Re^3: BUH! (Wim, 20. Jun 2000, 11:15:25):
~#! rn=Panic rt=961491154 rg=gilden.zauberer
~#! tid=961058732
> Im uenbrigen meinte ich nicht diese komische Sperre wenn man Kompo-Hand
einige 
Male eingesetzt hat, sondern die Abwertung von Hand / Aufwertung von Verletze.

Da muesstest Du doch mit ein paar mehr Worten sagen, was gemeint war. an
"Hand" habe ich noch gar nicht geschraubt, ebenfalls noch nicht an verletze..?


-----------------------------------------------------------------------------



Re^4: BUH! (Gandur, 20. Jun 2000, 11:20:55):
~#! rn=Wim rt=961492525 rg=gilden.zauberer
~#! tid=961058732
also wenn ich mich recht entsinne gibt es ne schadensmeldung die mir
zumindestens bei verletze neu war.
gruss, gandur

-----------------------------------------------------------------------------



Re^5: BUH! (Wim, 20. Jun 2000, 11:26:08):
~#! rn=Gandur rt=961492855 rg=gilden.zauberer
~#! tid=961058732
Oh? *Nachguck* oh... Das ist nur was ins Spellbook hineingerutscht, was noch
nicht haette hineinrutschen sollen. Naemlich mehr und differenzierte Meldungen
fuer Verletze im selben (max) Schadensintervall.

-----------------------------------------------------------------------------



Re^6: BUH! (Tiamak, 20. Jun 2000, 12:17:14):
~#! rn=Wim rt=961493168 rg=gilden.zauberer
~#! tid=961058732
Ahhh, endlich :-)

Hoffentlich in aehnlichen (noch besser: identischen) Intervallen wie bei den
anderen Gilden. Dann koennte ein gewisses unbekanntes TF-Paket vielleicht mal
weniger verwirrend gestaltet werden. ;-)

Ringor

-----------------------------------------------------------------------------



Re^7: BUH! (Anatol, 20. Jun 2000, 12:23:45):
~#! rn=Tiamak rt=961496234 rg=gilden.zauberer
~#! tid=961058732
Genau, den Dein tolles TF-Paket hat nicht unwesentlich zum schlechten
Ruf der Zauberer beigetragen. Wenn dort bei 'verletze' "Maximum!" 
steht, glaubt das gemeine Volk an ganz viel Schaden. Natuerlich, man
kann nachlesen, dass das auch schlechter als "zu Brei schlagen" sein
kann - aber bitte, wer tut das schon...

Anatol - nix fuer ungut ;)

-----------------------------------------------------------------------------



Re^8: BUH! (Tiamak, 20. Jun 2000, 12:25:51):
~#! rn=Anatol rt=961496625 rg=gilden.zauberer
~#! tid=961058732
Wofuer fragst Du vorher ueberhaupt nach, wenn Du es doch falsch schreibst?
Maximum! bedeutet immerhin _mindestens_ zu Brei und niemals schlechter. Und
dass das gemeine Volk keine Anleitungen liest, dafuer kann ich ja nichts. ;-)

Ringor. Kann auch nix fuer die schlecht gestaffelten Meldungen, die neben "zu
Brei" auch mal "vernichtet" heissen koennen.

-----------------------------------------------------------------------------



Re^7: BUH! (Lyra, 20. Jun 2000, 12:43:38):
~#! rn=Tiamak rt=961496234 rg=gilden.zauberer
~#! tid=961058732
Gibt es schon ein Update? ;-)

Lyra schaut gleich mal nach

-----------------------------------------------------------------------------



Liebes Tagebuch,... (Obermotz, 29. Jun 2000, 11:09:57):
gestern war wieder ein bedeutender Tag in meinem Leben: Ich habe meinen ersten
Magisterposten bekommen. Und das sogar im maechtigen Bereich der Illusionen!
Hoch motiviert lernte ich mit eifer den neuen Spruch: Gefaehrt. Endlich nie
wieder allein durchs Morgengrauen reise!
Nach dem Studium der Moeglichkeiten des neuen Gefaehrten schwand meine gute
Laune wieder. Leider kannst Du, liebes Tagebuch,  mir auch nicht sagen, was
ich mit dem gefaehrten nun anstellen kann.
Warum kann man den Gefaehrten nicht als Ohren/Augen fuer einen bestimmten Raum
benutzen? Es wuerde ja auch genuegen, wenn man nur Spieler sehen oder hoeren
koennte (Wer will auch schon bloede Monster aergern).
Liebes Tagebuch, ich kann Dir garnicht all die Gemeinheiten schildern, die ich
mit den Spielern machen wuerde!
Nur wie koennte cih mit dem Gefaehrten in Kontakt treten? Vielleicht mit einem
Telepathie-Geraet? Obwohl solche Geraete einem auch bei Benutzung die
Lebensenergie entziehen koennen. 
Liebes Tagebuch, ich sehe da gerade wieder so einen hoffnungsvollen Anfaenger,
der nur so drum bettelt, geaergert zu werden.

Mach es gut bis Morgen liebes Tagebuch
Dein Obermotzi

-----------------------------------------------------------------------------



Re: Liebes Tagebuch,... (Anatol, 29. Jun 2000, 11:43:17):
~#! rn=Obermotz rt=962269797 rg=gilden.zauberer
~#! tid=962269797
Werd' Bierschuettler.
Nein, besser Karateka.

Genug harte Schlaege auf den Kopf hast Du offenbar schon erhalten.

Anatol, kopfschuettelnd ob mancher Zweities


-----------------------------------------------------------------------------



Re: Re: Liebes Tagebuch,... (Obermotz, 29. Jun 2000, 11:45:34):
~#! rn=Anatol rt=962271797 rg=gilden.zauberer
~#! tid=962269797
Obermotz!=Zweitie
Obermotz=Original

Obermotz zweizeilig!

-----------------------------------------------------------------------------



Re^3: Liebes Tagebuch,... (Anatol, 29. Jun 2000, 11:46:10):
~#! rn=Obermotz rt=962271934 rg=gilden.zauberer
~#! tid=962269797
O Tempora. O Mores. 

Anatol

-----------------------------------------------------------------------------



Re^4: Liebes Tagebuch,... (Obermotz, 29. Jun 2000, 11:46:42):
~#! rn=Anatol rt=962271970 rg=gilden.zauberer
~#! tid=962269797
Hae?

OM

-----------------------------------------------------------------------------



Re^5: Liebes Tagebuch,... (Atoz, 29. Jun 2000, 11:49:42):
~#! rn=Obermotz rt=962272002 rg=gilden.zauberer
~#! tid=962269797
Schon mal was von 'teile mit' gehoert?

-----------------------------------------------------------------------------



Re^6: Liebes Tagebuch,... (Dieder, 29. Jun 2000, 11:50:12):
~#! rn=Atoz rt=962272182 rg=gilden.zauberer
~#! tid=962269797
nee schlechter Vorschlag - Zaubirubrik vollmuellen macht doch Spass :-))

Dieder

-----------------------------------------------------------------------------



Re^7: Liebes Tagebuch,... (Atoz, 29. Jun 2000, 11:52:55):
~#! rn=Dieder rt=962272212 rg=gilden.zauberer
~#! tid=962269797
Na gut, hast ja recht Chefsterber ;)=

-----------------------------------------------------------------------------



Re^5: Liebes Tagebuch,... (Silvana, 29. Jun 2000, 11:56:37):
~#! rn=Obermotz rt=962272002 rg=gilden.zauberer
~#! tid=962269797
qed.

  Silvana

-----------------------------------------------------------------------------



Re^6: Liebes Tagebuch,... (Obermotz, 29. Jun 2000, 12:17:33):
~#! rn=Silvana rt=962272597 rg=gilden.zauberer
~#! tid=962269797
Hm, vielleicht sollte ich meinen Vorschlag in klare Worte fassen:

Man kann den Gefaehrten in einen Raum stellen/bewegen (wie gehabt). Solange
man einen bestimmten Helm (oder sonstwas) aufhat, kann man (fast) alles
mitbekommen, was in diesem Raum passiert.
Fast bedeutet, dass man keine NPCs sieht/hoert oder sonstwie auf diese Weise
orten kann (so also nicht mitbekommen kann, ob der kitzeldrom wieder da ist).
Ich koennte mir auch vorstellen, dass es nur in bestimmten Raeumen geht (z.B.
eigenes Haus).
Solange man den "Steuerhelm" auf hat, werden laufend LPs oder KPs abgezogen.
Da man seinen Geist zu einem anderen Ort schickt, kann man am aktuellen
Standplatz nichts machen.
Mir schwebt also keine Aufwertung fuer den Kampf oder ein
"Aufklaerungsroboter" vor.

Obermotz

-----------------------------------------------------------------------------



Re^7: Liebes Tagebuch,... (Silvana, 29. Jun 2000, 12:25:38):
~#! rn=Obermotz rt=962273853 rg=gilden.zauberer
~#! tid=962269797
So etwas in der Art war in der Tat mal angedacht, ist aber aus Zeitgruenden
damals gescheitert. Zudem hatten wir uns damals gegen diese Methode des
"Snoopen fuer Spieler" entschieden, weil solche Moeglichkeiten fuer kleine
Spieler einfach nicht zu durchschauen sind. Wie das heute aussieht, kann ich
Dir nicht sagen. Mit der Gildenfuehrung hab ich nix mehr zu tun...

  Silvana

-----------------------------------------------------------------------------



Re^8: Liebes Tagebuch,... (Obermotz, 29. Jun 2000, 12:56:45):
~#! rn=Silvana rt=962274338 rg=gilden.zauberer
~#! tid=962269797
Wuerde *allen_willenskraft_aufbring* kratzen, betteln, schleimen, drohen,
bitten, demonstrieren, fordern oder klagen helfen, Dich wieder in die
Gildenfuehrung zu bringen? ;-)

Obermotz erinnert sich an die guten, alten Zeiten

-----------------------------------------------------------------------------



Re^9: Liebes Tagebuch,... (Silvana, 29. Jun 2000, 12:58:03):
~#! rn=Obermotz rt=962276205 rg=gilden.zauberer
~#! tid=962269797
Das willst Du nicht wirklich, glaub's mir...

  Silvana

-----------------------------------------------------------------------------



Re^10: Liebes Tagebuch,... (Anatol, 29. Jun 2000, 13:09:57):
~#! rn=Silvana rt=962276283 rg=gilden.zauberer
~#! tid=962269797
Er nicht...

Anatol 0:^)


-----------------------------------------------------------------------------



Re: Re: Liebes Tagebuch,... (Hood, 29. Jun 2000, 14:50:46):
~#! rn=Anatol rt=962271797 rg=gilden.zauberer
~#! tid=962269797
dabei ist die idee gar nich so schlecht...
zumindest die mit den augen und ohren :)

-----------------------------------------------------------------------------



Re^3: Liebes Tagebuch,... (Anatol, 29. Jun 2000, 14:51:14):
~#! rn=Hood rt=962283046 rg=gilden.zauberer
~#! tid=962269797
Und alt.

Anatol

-----------------------------------------------------------------------------



Re^3: Liebes Tagebuch,... (Wim, 30. Jun 2000, 08:13:16):
~#! rn=Hood rt=962283046 rg=gilden.zauberer
~#! tid=962269797
Wenn die Moeglichkeiten des Missbrauchs (z.B. als Resettrigger) ausreichend
einschraenkbar sind, saehe ich da nicht unbedingt ein Problem drin. Doch eben
jene Probleme sind nicht unbedingt gering :)

-----------------------------------------------------------------------------



Re^4: Liebes Tagebuch,... (Nonne, 30. Jun 2000, 09:35:18):
~#! rn=Wim rt=962345596 rg=gilden.zauberer
~#! tid=962269797
Resettrigger gibt es doch schon als tools. Ich sehe die Gefahr eher in einer
Verletzung der Privatsphaere. Bisher koennen Spieler die A-Gilde belauschen,
das ist aber nur ein Raum. Bei allen Raeumen sehe ich das aber schon ein wenig
kritischer.

Nonne, gegen Big-Brother

-----------------------------------------------------------------------------



Re^5: Liebes Tagebuch,... (Obermotz, 30. Jun 2000, 09:50:41):
~#! rn=Nonne rt=962350518 rg=gilden.zauberer
~#! tid=962269797
Klar, die Privatsphaere moechte ich dadurch nicht verletzen. Aber der
Gefaehrte ist ja nicht unsichtbar und sollte eh nur das mitbekommen, was ich
auch mitbekommen wuerde, wenn ich dirket in dem Raum stehen wuerde.
Was den Resettrigger angeht: kann man die NPCs unsichtbar/unantastbar (keine
"trete Megamonster") machen?

Obermotz den den Gefaehrten als Buttler in seinem Haus haben will

-----------------------------------------------------------------------------



Re^6: Liebes Tagebuch,... (Bambi, 30. Jun 2000, 13:33:55):
~#! rn=Obermotz rt=962351441 rg=gilden.zauberer
~#! tid=962269797
butler im haus ist dann wohl eher ein seherhaus-feature als ein allgemein
verwendbarer "Spion".
Urspruenglich gings hier doch aber unter anderem um einen Nerv-NPC-Verschnitt,
mit dem Du kleine Spieler nerven wolltest. Warum der dann aber unbedingt Zeugs
an Dich schicken soll, versteh ich dann nicht genau, genausowenig, wieso man
dazu einen _neuen_ NPC braucht.

-----------------------------------------------------------------------------



Re^7: Liebes Tagebuch,... (Obermotz, 30. Jun 2000, 13:50:02):
~#! rn=Bambi rt=962364835 rg=gilden.zauberer
~#! tid=962269797
Der Butler war nur als Beispiel gedacht. Und ich dachte, ich hatte irgendwie
geschrieben, dass ich keinen allgemeinen Spion will.
Da man nur mit bekommt, was im Raum wo der Gefaehrte steht passiert, wenn man
sich drauf konzentriert, ist auch kein Dauerlauschen moeglich. Ach so: das
Konzentrieren sollte auch LPs/oder KPs kosten und vielleicht nur mittels eines
Ausruestungsstuecks (nur ueber Quest erhaeltlich?) moeglich sein.
Ich dachte so was in die Richtung: den Gefaehrten in die Fridhofskneipe
stellen, irgendwann mal schauen, ob sich gerade jemand dort aufhaelt und
denjenigen dann vielleicht mittels des Gefaehrten unterhalten/aergern/helfen
oder sonstwas machen. Weil momentan weiss ich nicht so genau, was ich mit den
Gefaehrten in der jetzigen Version anfangen kann.

Obermotz glaubt aber auch nicht, dass sich der Gefaehrte aendern wird

-----------------------------------------------------------------------------



Re^8: Liebes Tagebuch,... (Anatol, 30. Jun 2000, 14:09:06):
~#! rn=Obermotz rt=962365802 rg=gilden.zauberer
~#! tid=962269797
a) Als ob wir Zauberer im Moment keine anderen (groesseren) Probleme haetten.

b) siehe auch "chaos-snoop".

Anatol

-----------------------------------------------------------------------------



Re^8: Liebes Tagebuch,... (Taragon, 30. Jun 2000, 18:01:09):
~#! rn=Obermotz rt=962365802 rg=gilden.zauberer
~#! tid=962269797
> Weil momentan weiss ich nicht so genau, was ich mit den
> Gefaehrten in der jetzigen Version anfangen kann.
Nichts wirksames jedenfalls. Genauso sinnvoll wie erzwinge z.b. ...

-----------------------------------------------------------------------------



Re^8: Liebes Tagebuch,... (Ktar,  1. Jul 2000, 03:49:15):
~#! rn=Obermotz rt=962365802 rg=gilden.zauberer
~#! tid=962269797
Wie waers denn wenn man in den Gefaehrten eine
Alle-Monster-greifen-Ihn-an-Autoumkloppfunktion einbaut... wuerde zwar nix
helfen wenn man das erkennen des resets von Monstern verhindern will, aber das
snoopen von Spielern fuer Spieler doch sehr einschraenken ...
Ausserdem ... gibts den Gefaehrten auch als Gefaehrtin?
Tschuldigt, hab vergessen das Zaubis ja ein so "geschlechtsloses" Leben
fuehren sollten :)
Ktar, der auch mal g.zaubi vollmuellen wollte :)

-----------------------------------------------------------------------------



Re^9: Liebes Tagebuch,... (Liara,  1. Jul 2000, 04:21:21):
~#! rn=Ktar rt=962416155 rg=gilden.zauberer
~#! tid=962269797
Geschlechtsloses Leben?
Dat wuesste ich aber. :-)

Liara, Zwergenzauberine, taetschelt Ktar, den Wurstmagierzweitie ;-)

-----------------------------------------------------------------------------



Re^10: Liebes Tagebuch,... (Mupfel,  1. Jul 2000, 19:30:13):
~#! rn=Liara rt=962418081 rg=gilden.zauberer
~#! tid=962269797
Liara, er meint "enthaltsam" (nehme ich mal an ;)

-mupfel-

-----------------------------------------------------------------------------



Re^5: Liebes Tagebuch,... (Swift,  4. Jul 2000, 22:52:43):
~#! rn=Nonne rt=962350518 rg=gilden.zauberer
~#! tid=962269797
Nicht nur die A-Gilde ist belauschbar. Die Chaoten haben ne Moeglichkeit fuer
sowas, das mehr Moeglichkeiten bietet und Spielern folgt, und es gibt noch
mind. eine Moeglichkeit im MG, einen X-Beliebigen Raum oder Spieler zu
belauschen - und sich ihm bzw. dem Raum mitzuteilen - anonym oder nicht. Auf
ne neue abgekupferte Faehigkeit der Zauberer wuerde es so gesehen auch nicht
ankommen... :)

Swift.

-----------------------------------------------------------------------------



Re^6: Liebes Tagebuch,... (Nevok,  7. Jul 2000, 23:37:48):
~#! rn=Swift rt=962743963 rg=gilden.zauberer
~#! tid=962269797
So Du da auf die Loge der Weisen anspielen solltest, so hat die Padreic zu den
Logen der W+ gemacht... ;)

Nevok

-----------------------------------------------------------------------------



Besondere Ereignisse ... (Liara, 15. Jul 2000, 21:41:22):
Um mal direkt mit der Tuer ins Haus zu fallen: *g*

Ich faende es toll, wenn bestandene Magisterpruefungen in der MPA
(moeglicherweise in dieser Rubrik?) auftauchen wuerden.

Begruendung: Mir hat diese Pruefung noch mehr bedeutet als das Sehertum. Sie
wird zwar ueber zrufe oder die Zaubiebene (vergessen ;) kundgetan, aber wenn
man nicht eingeloggt ist, verpasst man dieses Ereignis natuerlich.
Beim Sehertum habe ich mich sehr ueber die Gratulationen gefreut. Mit den
Magisterpruefungen ging es mir leider meist so, dass ich ausgerechnet an dem
Tag, an dem ein Freund sie bestanden hat, nicht nachgefragt oder gefingert
habe und die Gratulation meist ziemlich verspaetet erfolgte. ;-)

Ich weiss nicht wieviel Arbeit es ist, sowas mit der MPA zu verknuepfen. Die
Pruefung wird auch nicht so haeufig bestanden, dass unnoetige Artikelflut zu
befuerchten waere. (Moeglicherweise waere es fuer die Generalsbefoerderung der
Kaempfer auch interessant.)

Liara, Zwergenzauberine


-----------------------------------------------------------------------------



Re: Besondere Ereignisse ... (Foobar, 16. Jul 2000, 01:26:17):
~#! rn=Liara rt=963690082 rg=gilden.zauberer
~#! tid=963690082
Moin.

Ich moechte hier ins gleiche Horn stossen. Bestandene Magisterpruefungen,
Generalsstatus fuer Kaempfer, Lvl. 17 fuer Karateka und aequivalente Dinge bei
anderen Gilden sollten in der MPA veroffentlicht werden.

Gruss,

   Foobar

-----------------------------------------------------------------------------



Re: Re: Besondere Ereignisse ... (Lug, 21. Jul 2000, 00:42:55):
~#! rn=Foobar rt=963703577 rg=gilden.zauberer
~#! tid=963690082

Was? Bloss nicht! Wenn Euch Eure Statusgeilheit piekt, dann schreibt doch
selber was in die MPA. Ansonsten behelligt Euch mal schoen selber.

Schwachsinnsvorschlag
Lug

-----------------------------------------------------------------------------



Mudlib-Aenderung (Tiamak, 27. Jul 2000, 21:20:21):
Hiho!

Eine kleinere Mudlib-Aenderung hat anscheinend auch gewisse ... nun ... nennen
wir sie "Nebenwirkungen" bei den Zauberern. 

Hackt also nicht sofort wieder auf Wim herum - diesmal bin ich schuld.


Tiamak

-----------------------------------------------------------------------------



Re: Mudlib-Aenderung (Thufhir, 27. Jul 2000, 21:37:55):
~#! rn=Tiamak rt=964725621 rg=gilden.zauberer
~#! tid=964725621
Aeh kleinere Ausnutzungen von Bugs haben groessere Nebenwirkungen bei den
Magiern, nun diesmal is nicht der Driver schuld... ;)


</gwille off>



-----------------------------------------------------------------------------



Re: Re: Mudlib-Aenderung (Paracelsus, 27. Jul 2000, 21:39:13):
~#! rn=Thufhir rt=964726675 rg=gilden.zauberer
~#! tid=964725621
Kleines Aergern von Erzmagiern hat grosse Auswirkungen auf die Existenz
von Savefiles, aber das ist natuerlich Willkuer.

Para*

-----------------------------------------------------------------------------



Re^3: Mudlib-Aenderung (Thufhir, 27. Jul 2000, 21:46:53):
~#! rn=Paracelsus rt=964726753 rg=gilden.zauberer
~#! tid=964725621
nun gut, spieler macht eh nix... also: </egal on>

-----------------------------------------------------------------------------



Ich oute mich (Obermotz,  1. Aug 2000, 14:04:45):
Ich glaube, einige von Euch habe mitbekommen, dass ich manchmal nach
Kompo-Spenden gefragt habe.
Aber ich habe die Frage nie ernst gemeint. Ich wollte einfach mal meinen
Jammerskill auf max. bringen ;)

OM, der erst zu 99,9999% jammern kann.

-----------------------------------------------------------------------------



Re: Ich oute mich (Hight,  1. Aug 2000, 14:18:54):
~#! rn=Obermotz rt=965131485 rg=gilden.zauberer
~#! tid=965131485
sag hm schade ... dann muste dich mit 99,999% begnuegen .... 
abba sie die positive seite !
den Ich-geh-anderen-spieler-tierisch-auf-den-wecker-skill haste bei 200%
mindestens

gruss hight

-----------------------------------------------------------------------------



Re: Re: Ich oute mich (Obermotz,  1. Aug 2000, 14:22:13):
~#! rn=Hight rt=965132334 rg=gilden.zauberer
~#! tid=965131485
Mist, den hatte ich doch schon mal bei 241,06%. Es sieht ganz so aus, als ob
ich weitermachen muss.

OM bracht die Prozente.

-----------------------------------------------------------------------------



Unmotivierte Fehler beim zwer (Wim, 15. Aug 2000, 18:55:15):
Bitte da mal ein Auge (oder zwei) darauf haben, ob der Fehler noch auftritt.

BTW: Erst den Zauberstab neu anfordern, dann erst checken obs noch buggt ;)

-----------------------------------------------------------------------------



handschuhe (Patryn,  2. Okt 2000, 19:05:16):
die wandlerhandschuhe im warok tuns wieder, kurzzeitig waren sie wegen
eines updates bei silvana ausser betrieb, wenn man das so sagen kann...

------
patryn

PS: neu metzeln, oder halt trickreichere offensichtliche methoden *g*

-----------------------------------------------------------------------------



Vorschlag (Orktoeter, 16. Okt 2000, 14:21:49):
Ala erstes: Dies ist ein ernst gemeinter Vorschlag, bitte aeussert sachliche
Kritik, wenn ihr meint, das es noetig waere, aber zerredet ihn nicht und auch
bitte keine Tiefschlaege und abweichungen a la Gilde xxx ist aber
Staerker/schwaecher...

So, nun zum eigentlichen..
Als die letze Abwertung der Zauberer kam, hatte ich den Eindruck, das von der
Vielfalt der Zauberer nicht viel geblieben ist, bzw. sie nur einen kleinen
Teil (wirksam) nutzen koennen.
Das ist aber nicht nur eine Sache der Zauberer, sondern ist durch vielfache
resistenzen der NPC, also durch andere Magier so geworden.

Daher hier nun 4 Punkte, die einer nach dem anderen umgesetzt werden muessten,
damit Zauberer wieder "echte" zauberer werden.

1. Der Gildenmagier muesste bereit sein, noch mal gruendlich alles zu
ueberarbeiten und vermutlich auch noch mal alles spells auf ihre Staerke zu
pruefen.
2. Die Spielrr als solche muessen wieder "echte" Zauberer werden wollen

3. Die Magier des MG sind dann gefordert, ihre bereits bestehenden bzw. neue
NPC so zu ueberarbeiten, das nicht mehr so vile Zaubererfeindlich sind. 
4. Wenn alle 3 Vorhergehenden Punkte zutreffen, dann sollte zu einem
bestimmten Stichtag (der in weiter Ferne liegt, damit die magier entsprechend
Zeit fuer die Ueberarbeitung haben) die Zauberergilde wieder zur "echten"
zauberergilde und gleichzeitig werden dann die geaenderten NPC angeschlossen. 


OrkT, heute mal nicht auf den Zaubis rumhackend.

-----------------------------------------------------------------------------



Re: Vorschlag (Hobo, 16. Okt 2000, 14:34:53):
~#! rn=Orktoeter rt=971698909 rg=gilden.zauberer
~#! tid=971698909
Hi OrkT,
ohne Deinen Vorschlag niedermachen zu wollen, mir ist nur was aufgefallen:
In Deinem Artikel steht eigentlich nur: Macht's bitte besser als bisher!

Was aber genau geaendert werden soll, steht nicht drin. Was bedeutet denn
bitte "echter Zauberer", was wird gruendlich  in welcher Beziehung
ueberarbeitet?

Mit solch schwammigen Vorschlaegen/Vorstellungen bekommst Du wohl keinen zum
Handeln.

    Hobo

-----------------------------------------------------------------------------



Re: Vorschlag (Ark, 16. Okt 2000, 21:08:48):
~#! rn=Orktoeter rt=971698909 rg=gilden.zauberer
~#! tid=971698909
Also zu Punkt 3: falls damit (auch) gemeint ist, Monstern wieder Resistenzen
gegen Sprueche i.A. zu nehmen, schmettere ich das fuer mich ab. Manche Monster
haben eben Magieresistenz und sind somit vielleicht fuer Zauberer schwer oder
alleine evtl. gar nicht zu schaffen. Kann durchaus sein, oder? Hoffentlich
wird daraus jetzt nicht geschlossen, dass ein Monster "zaubererfeindlich"
geschrieben wurde. Und nein, ich meine damit jetzt nicht einen 0815 Goblin,
der im Kampf seinen Gegner auf die Gilde ueberprueft und bei Zauberern
ploetzlich frech die Nase in die Flammen streckt. Das ist Schwachsinn, der im
Ermessensspielraum des programmierenden Magiers liegt. Es geht mir mehr um die
(mehr oder weniger) sinnvoll und erklaerbar gegen Magie geschuetzten Monster
und NPCs. War doch klar, oder? :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Re: Vorschlag (Orktoeter, 16. Okt 2000, 21:50:50):
~#! rn=Hobo rt=971699693 rg=gilden.zauberer
~#! tid=971698909
Ok, also..
Es war so gemeint, das man das Verhaeltnis (kampfkraft), der verschiedenen
Zauber mal ueberprufen sollte und (wenn punkt 3 zustimmung findet (sonst lohnt
das nicht)) den "Hand"-spruch abwertet, da andere spells wie verletze dann
wieder attraktiver sind.

Und zu Ark: Es ist natuerlich nicht noetig, das alle NPC leichte Beute fuer
Zauberer sind, aber den Klagen bei der letzen Abwertung der Zauberer nach zu
urteilen (was meines erachtens nach dadurch bestaetigt wird, das deren Hand
wohl fruher immer aufgewertet wurde, weil die Spells nicht mehr so oft wirksam
waren) sind wohl zu viele NPC Spell-resistent, so das die Zaubis geradezu zur
Hand als Universalwaffe gezwungen werden.

OrkT hofft, damit deutlicher geworden zu sein.

-----------------------------------------------------------------------------



Re^3: Vorschlag (Patryn, 16. Okt 2000, 22:55:12):
~#! rn=Orktoeter rt=971725850 rg=gilden.zauberer
~#! tid=971698909
ja orktoeter, die hand-abwertung macht die zauberer wieder viel
attraktiver. subtiler gehts wohl nicht, oder? :)

-----------------------------------------------------------------------------



Re^4: Vorschlag (Anacrion, 17. Okt 2000, 06:11:36):
~#! rn=Patryn rt=971729712 rg=gilden.zauberer
~#! tid=971698909
Also ich kann OrkT nur zustimmen.

LEIDER ist es jedoch so, dass die monster in immer hoeherem masse P_NO_MAGIC
gesetzt kriegen (oder aequivalentees) . Da hilft leider nur mechanischer
schaden (hand), da man den (zumindest meistens, wie jeder kaempfer weiss) ins
ziel kriegt.
Ich sehe zur zeit leider keine moeglichkeit, alle monster im mg dahingehend zu
aendern, dass vielleicht nicht mehr ueberall p_no_magic gilt.
Die Frage ist jedoch auch: Bis wohin soll Hand dann eigentlich noch reduziert
werden ?? also ich krieg selbst mit normalschlagring und allen relevanten
skills auf 100% (ohne komponente) selten mal am gardi ein krachen oder
schmettern hin ...irgendwie nciht mehr der sinn der saceh .. ich erinnere mich
da an dauerbreien bei den elitesoldaten in moulokin ohne ring und ohne kompos
und .. aeh. ich schweife ab.
Ich habe durchaus mal andere gilden gespielt und finde, dass metzeln mit hand
als zauberer nicht soo die wucht ist .. entweder man atomisiert alles (was
spass macht, auch wenns keine herausforderung ist) oder man wird innerhalb
weniger wochen so weit abgewertet, dass man froh ist, ne ameie auf der HE ..
naja. fast. 
Ich erinnere mich noch an die 'vor-hand-zeit', wo ich mit verletze .. eher
ohne, am ghoulkoenig stand und ewig reinraus tanken war ... ziemlich laestig,
aber es wars wert ... 
ZUR ZEIT jedoch stellt sich das voellig anders dar ..
Teleport geht meist eh nicht oder, falls doch zu irgendwelchen schwarzen
mumien, letzten beholdern, ... ), verletze wird mit einem laessigen 'macht
einen salto rueckwaerts oder aehnlichem, haeufig sogar einem schnoeden'wehrt
Deinen Zauber ab' oder 'verpufft im nichts' ignoriert, selbst die noetige
schutzhuelle geht kaum an.
Nein. Ich will nicht andeuten, dass ich nen Gardewaechter nicht mehr umkriege,
aber die sind auch nicht das Mass der Dinge (wqenn man nicht Lug heisst).

Ein Vorschlag waere es, die Zaubererzauber nicht mehr als Spell zu deklarieren
.. haette den Vorteil, dass dann Spelldefend umgangen werden koennte ..
erspart ne menge Aendern an Monster .. ist aber nicht die feine Art ...

#

Any Comments ?

anac* - spielt aus genannten Gruenden kaum noch


-----------------------------------------------------------------------------



Re^5: Vorschlag (Bambi, 17. Okt 2000, 09:10:41):
~#! rn=Anacrion rt=971755896 rg=gilden.zauberer
~#! tid=971698909
Wieso sollten Spells der Zauberer nicht mehr als Spells erkannt werden?
Damit Magier die Spells nicht mehr abfangen?
Wenn ein Magier bewusst zaubererfeindliche Sachen schreibt, dann macht er im
Zweifelsfall einen workaround.
Nun im Umkehrschluss hinzugehen und zu meinen, dass man genau aus diesem Grund
die Spells der Zauberer als "Nicht-Spells" deklarieren sollte, halte ich fuer
Schwachsinn, weil dann jeder Magier, der einen magieresistenten NPC schreiben
will, hingehen muss und sich 
a. in jedem Spellbook auskennen muss sowie jedesmal, wenn eine Aenderung oder
Erweiterung einer Gilde ansteht nachbessern oder
b. genau dann so "ultimative" Loesungen, wie "falls gilde des spielers ==
zauberer dann ..." benutzt und das ist ja nicht gewollt, oder?;Bambi.

-----------------------------------------------------------------------------



Re: Vorschlag (Wim, 17. Okt 2000, 11:35:48):
~#! rn=Orktoeter rt=971698909 rg=gilden.zauberer
~#! tid=971698909
Eigentlich muesste ich darum bitten, die Gildenbalance zu wort kommen zu
lassen, jedoch kann ich soviel sagen dass nch deren Auskunft die Sprueche
keinesfalls in der bisherigen Form noch gesteigert werden koennen, eher noch
gesenkt werden sollten.

Was eine komplette Umarbeitung angeht, so steht sie durchaus auf meiner Agenda
nur hast Du sicher keine Ahnung wie langwierig soetwas sein kann, weiterhin
wollte ich dazu auch noch Ideen sammeln (lassen *Kollegen anschau*). 
Derzeit ist ersteinmal etwas anderes dran, naemlich der Umbau der Gildenraeume
und auch beschreiben dauert seine Zeit.

Wim, tut was auch wenn es nach Aussen nicht so aussieht.

-----------------------------------------------------------------------------



Re^6: Vorschlag (Jen, 18. Okt 2000, 14:03:36):
~#! rn=Bambi rt=971766641 rg=gilden.zauberer
~#! tid=971698909
Hi Bambi,

die Spells sollten deswegen in der Lage sein ein Spelldefend zu umgehen, weil
die derzeitige Loesung den Zauberern durchaus zur Zeit Kampfkraft zuzurechnen
ist, aber diese eben ueber eine Art unr Weise erreicht wird, die nicht
unbedingt zaubererspezifisch ist. Spelldefend -> Dann nehmen wir halt Hand 
Das kann entweder so bleiben oder es findet sich ein anderer Weg.
CU, Elendil

-----------------------------------------------------------------------------



Re^7: Vorschlag (Bambi, 18. Okt 2000, 14:51:23):
~#! rn=Jen rt=971870616 rg=gilden.zauberer
~#! tid=971698909
ich versteh kein Wort, sorry.

-----------------------------------------------------------------------------



Re^7: Vorschlag (Paracelsus, 18. Okt 2000, 15:09:57):
~#! rn=Jen rt=971870616 rg=gilden.zauberer
~#! tid=971698909
SpellDefend ist nicht zaubererspezifisch, da hast Du recht. Es betrifft
alle Gilden. Wie es genutzt wird, ist aber letztendlich Sache des Magiers,
der das entspr. Objekt (meist einen NPC) programmiert. Und wenn der da
unbedingt ein 'Wenn(Spielergilde=="zauberer") dann MAX-Defend' machen
will, dann ist das in erster Linie Sache des Magiers, seines RMs und
(bei NPCs) der NPC-Balance (welche bekanntlich nur aktiv wird, wenn
sie von Spielern angesprichen wird). Und sein wir mal ehrlich, wenn man
nicht will, dass Zauberer Schaden machen, dann kann man das auf viele
Arten machen, SpellDefend ist nur eine davon (und eine der einfacheren).
Genauso gibt es Beispiele der Form 'Wenn(Spielergilde=="tanjian" oder
"dunkelelfen") dann Schaden/2'.
Wie sollte denn eine "zaubbbererspezifische" Loesung Deiner Meinung nach
aussehen? Ein extra ZaubererDefend? Dann brauchen wir demnaechst wohl
auch AbenteurerDefend, KlerikerDefend, etc. - Schwachsinn!

Paracelsus - heute mit versteckten Loesungsansaetzen.

-----------------------------------------------------------------------------



Re^8: Vorschlag (Patryn, 18. Okt 2000, 15:34:05):
~#! rn=Paracelsus rt=971874597 rg=gilden.zauberer
~#! tid=971698909
ich glaube eigentlich auch, das spelldefend ist in der form wie es jetzt
ist eine technisch vernuenftige loesung, genauso wie zb die
erleichterung zum teleport-umleiten oder sperren technisch sinnvoll und
auch so gedacht ist. so kann man in derliste weitergehen, nomagic, body
resistenzen u.s.w. ...alles sachen die man entweder vernuenftig oder
weniger vernuenftig einsetzen kann.
dass die derzeitig unvernuenftigeren sachen die zauberer besonders stark
beissen liegt eher an dem gildenkonzept selbst, dass zauberer nunmal
nur magischen schaden verursachen, ja bis auf die ausnahme hand und ein
bis zwei exoten.
die meisten gilden haben da weitaus mehr wahlmoeglichkeiten und koennen
damit auch besser umgehen...na ja, zumindest sieht es fuer mich so aus,
der eigentlich nur die zauberer richtig gut kennt.
was muesste man also nun genau aendern? keine ahnung :)
das spelldefend ist ok, die anderen sachen sind ok...dass derzeitig
vorrangig nomagic&co zum zuge kommt liegt durchaus meist im bereich der
gestaltung der npc's, wenn nich halt npc-balance nerven.

------
patryn

-----------------------------------------------------------------------------



Re^9: Vorschlag (Karis, 18. Okt 2000, 16:34:50):
~#! rn=Patryn rt=971876045 rg=gilden.zauberer
~#! tid=971698909
Wenn es den Zaubis nur an mechnischer Schlagkraft fehlt, ist das doch
einfach einzubauen. naja... einbauen nicht. aber die Idee is simpel :)
Man lasse den Zaubis einen Spruch, mit dem sie andere Gegenstaende
bewegen koennen (Telekinese oder sowas). Damit koennten sie dann
herumliegende Steine, Baumstaemme, oder von mir aus auch Speere, Zahnstocher
und sonstwas (vielleicht auch NPCs) aufeinander loslassen.
Das ganze waere magisch motiviert und haette mechanischen schaden.
Die Staerke davon laesst sich ja sicher irgendwie drehen.

Karis

-----------------------------------------------------------------------------



Re^10: Vorschlag (Patryn, 18. Okt 2000, 16:40:10):
~#! rn=Karis rt=971879690 rg=gilden.zauberer
~#! tid=971698909
nun ja...die idee ist zwar nett, aber ich glaub nich, dass es sinn macht.
gilden haben vor- und nachteile, die zauberer kennen ihre nachteile halt
sehr gut, weil sie jeden tag drauf hingewiesen werden.
es gibt gilden, die muessen weitaus gewissenhafter nach ihren nachteilen
suchen, es gibt aber auch welche, die muessen weniger lange als die
zauberer suchen...die tanjian zb haben auch gewisse dinge zu beachten.

------
patryn

-----------------------------------------------------------------------------



Re^11: Vorschlag (Montanus, 18. Okt 2000, 17:10:40):
~#! rn=Patryn rt=971880010 rg=gilden.zauberer
~#! tid=971698909

Ich les hier dauernd nur noch "SpellDefend" und fragmichnichtwasalles - und
das aus Spielermund.
Eigentlich wuenschte ich mir, dass das Ganze (Magie, Kampfsystem) wieder zu
einer groen Black Box wird, von der keiner so genau weiss, wie sie
funktioniert, und damit das Spiel auch noch ueberraschend und nicht so
vorausberechenbar bleibt.

Just my 2 Goldstueckle

-Montanus

-----------------------------------------------------------------------------



Re^12: Vorschlag (Patryn, 18. Okt 2000, 17:49:01):
~#! rn=Montanus rt=971881840 rg=gilden.zauberer
~#! tid=971698909
recht hast du, sorry...das ging irgendwo etwas verloren.

------
patryn

-----------------------------------------------------------------------------



Re: Re: Vorschlag (Nachtwind, 18. Okt 2000, 22:44:07):
~#! rn=Wim rt=971775348 rg=gilden.zauberer
~#! tid=971698909
Wim wrote:

>Eigentlich muesste ich darum bitten, die Gildenbalance zu wort kommen zu
>lassen, jedoch kann ich soviel sagen dass nch deren Auskunft die Sprueche
>keinesfalls in der bisherigen Form noch gesteigert werden koennen, eher noch
>gesenkt werden sollten.

Das ist so unrichtig. Tatsaechlich ist mein bisheriger Vorschlag genau
das: Eine massive Aufwertung aller Direkt-Schadensspells (wie "Verletze"),
verbunden mit einer Streichung oder besser gesagt kompletten
Umkonzipierung von "Hand". Dieser Vorschlag ist allerdings schon Monate
alt und von Dir bisher nicht kommentiert worden. 
Im uebrigen halte ich fuer hohe Zauberer auch eine Senkung der
Magieresistenz des Gegners nicht fuer unmoeglich, immer unter der
Vorraussetzung, dass Zauberer dann keine Super-Karateka mehr sind.

Das alles muss jedoch Wim implementieren, die Gildenbalance steht
solchen Aenderungen alles andere als im Weg, im Gegenteil, ich
fordere sie schon seit langem. Zauberer sollten mal wieder
das Zaubern probieren, anstatt wie die Berserker in vorderster
Reihe mit den blossen Haenden auf Gegner einzuschlagen.

Nachtwind.

Cetero censeo "Hand" delendam esse.

-----------------------------------------------------------------------------



Komponentenspenden (Wolke, 27. Okt 2000, 12:54:19):
Hiho,

mich wuerde mal interessieren, wer so Kompos spendet - waere es aufwendig,
dafuer so eine Art Top-Liste zu bauen ?  (falls es noch andere interessiert
.... ) :)

Wolke

-----------------------------------------------------------------------------



Re: Komponentenspenden (Matis, 27. Okt 2000, 12:55:27):
~#! rn=Wolke rt=972644059 rg=gilden.zauberer
~#! tid=972644059
Bloss nicht, ich will doch nicht geoutet werden. Sonst kann ich mich
im Struv nicht mehr sehen lassen.

Matis

-----------------------------------------------------------------------------



Re: Komponentenspenden (Anatol, 27. Okt 2000, 12:55:31):
~#! rn=Wolke rt=972644059 rg=gilden.zauberer
~#! tid=972644059
Bloss nicht... manche Leute wuerden sich schaemen, wenn sie oeffentlich
dazu stehen muessten, die Zaubererwelt zu unterstuetzen. :o)

Anatol :)

-----------------------------------------------------------------------------



Re: Re: Komponentenspenden (Hight, 27. Okt 2000, 13:15:52):
~#! rn=Matis rt=972644127 rg=gilden.zauberer
~#! tid=972644059
*g* siehe oben ... zumal ich auch ab und an komponenten spende weil der weg
zur gilde fuern zaubi kuerzer is als zu mir

hight

-----------------------------------------------------------------------------



Re^3: Komponentenspenden (Liara, 27. Okt 2000, 13:32:39):
~#! rn=Hight rt=972645352 rg=gilden.zauberer
~#! tid=972644059
Wieso braucht man fuer alles und jedes eine Topliste?

Liara, Zwergenzauberine, angesaeuert

-----------------------------------------------------------------------------



Re^4: Komponentenspenden (Karis, 27. Okt 2000, 13:43:10):
~#! rn=Liara rt=972646359 rg=gilden.zauberer
~#! tid=972644059
Das weisst Du nich????
Also: um sich toll zu fuehlen. Um besser zu sein als andere.
Damit einfach jeder nachguggen kann, dass man in der
Top-Mailing-Liste auf Platz 24 liegt. Oder dass man sich in der
Top-Artikelschreiber-Liste mit diesem Artikel von Platz 85 auf
Platz 84 vorgearbeitet hat. Es ist einfach ein gutes Gefuehl, zu wissen,
dass man wieder jemanden abgehaengt hat. Und stell Dir vor, wie schoen
es dann sein muss, in der Top-Replier-Liste an Anatol
vorbeizuziehen! (Wenn er sich da hoffentlich nicht gleich austragen laesst)

Wie auch immer. Top-Listen sind einfach wichtig. Vielleicht koennte
man ja auch eine Top-Top-Liste einfuehren, auf der dann draufsteht,
welche der Top-Listen am meisten frequentiert wird. Oder auf welcher sich
am meisten aendert. Ach Gott, dass das manche Leute einfach net verstehen ....

Generaelchen Karis, will auf der Top-Idler-Liste endlich ganz nach oben.
Weil auf der Top-Dummschwaetzer-Liste wirds schwierig :)

-----------------------------------------------------------------------------



Re: Komponentenspenden (Patryn, 27. Okt 2000, 13:49:35):
~#! rn=Wolke rt=972644059 rg=gilden.zauberer
~#! tid=972644059
oh oh...das fettnaepfchen. am besten du loeschst den artikel gleich wieder,
es ist hier naemlich unheimlich schick, toplisten jeglicher art doof zu
finden und leute wie dich als toplistengeil abzustempeln.
schliesslich ist das hier ein spiel, da sind toplisten unerwuenscht.

------
patryn zwinkert.


-----------------------------------------------------------------------------



Re: Komponentenspenden (Wolke, 27. Okt 2000, 13:59:41):

nee, werd ich nicht loeschen -

sondern mich lieber ueber die Antworten amuesieren ...

:) - wie eine einfache Frage soviel Aufregung schafft - :)

Wolke

-----------------------------------------------------------------------------



Re: Re: Komponentenspenden (Gloinson, 27. Okt 2000, 15:29:48):
~#! rn=Patryn rt=972647375 rg=gilden.zauberer
~#! tid=972644059
Och, bau mal die Topliste ein. Bitte, bitte :> Hauptsache sie beruecksichtigt
dann auch "topliste nein" (auch wenn das nicht viele machen :>.

Gloin(son)

-----------------------------------------------------------------------------



Top-Ten! Jawollja! (Linflas, 27. Okt 2000, 17:36:07):
Das ist doch mal wirklich eine gute Idee fuer euch Mags: Top-Ten Listen Marke
Eigenbau. Gibts im Laden in PV fuer 20 k!
Ich habe das schon gleich eine gute Idee fuer eine Liste: Top-Jammer-Liste!
(dann komm ich auchmal auf PLatz 1 *hehe*)
Mal im ernst: Wieso eigentlich nicht?
Mal im ernst: Wieso eigentlich nicht?

Linfl* (jammert nun auch in der mpa!)

-----------------------------------------------------------------------------



Re: Komponentenspenden (Puk, 27. Okt 2000, 18:46:15):
~#! rn=Wolke rt=972644059 rg=gilden.zauberer
~#! tid=972644059
Pahhhh
Komponentenspende fuer Zaubis ??
Wer macht den sowas ?

Puk, denkt o O (gib 57 Feuerwasser an Bhuturih)

-----------------------------------------------------------------------------



Re: Komponentenspenden (Wim, 29. Okt 2000, 18:33:28):
~#! rn=Wolke rt=972644059 rg=gilden.zauberer
~#! tid=972644059
Neeee....
Es wird da von mir aus keine Topliste fuer Spenden geben. Das innere Gefuehl,
etwas Gutes getan zu haben sollte reichen.

Wim
(von internen Statistiken reden wir ja hier nicht... *FG*)

-----------------------------------------------------------------------------



schattenkaempfer (Mpaleser, 23. Nov 2000, 15:56:54):
Moin,

wie waere es denn, den 'schattenkaempfer' so zu veraendern, dass
man ihn auch in benachbarte Raeume stellen kann? (analog zur
Schutzzone oder Feuerwalze). Man muesste halt schauen, dass sich
das nicht mit bereits bestehenen Magister-Spells zwickt.
Wie auch immer: Diskussion frei:)

--Vector--

P.S.: Am besten in dieser Rubrik flamen und rumblubbern, das 
ernsthafte kommt dann nach brainstorm.zauberer... da haette
ich im normalfall auch diesen Artikel hin geschrieben, aber komischer-
weise hab ich keine Schreibrechte:))

-----------------------------------------------------------------------------



Re: schattenkaempfer (Patryn, 23. Nov 2000, 16:08:31):
~#! rn=Mpaleser rt=974991414 rg=gilden.zauberer
~#! tid=974991414
technisch kein problem, aus sicht der gilde interessant,
aber dennoch bin ich dagegen.
man sollte es nicht uebertreiben mit dem casten von spells in andere raeume
hinein, nich nur aus balancetechnischer sicht.
die begruessung in starken monstern ist doch grad das interessante, und das
sollte man nicht ueberstark unterwandern *g*
es reicht imho eigentlich, wenn hellsichtsleute die gegner in nachbarraeumen
untersuchen koennen oder von mir aus ein abwehr und angriffsspell, aber
wie gesagt, nicht uebertreiben.

------
patryn

-----------------------------------------------------------------------------



Petition (Birdy, 21. Dez 2000, 14:26:56):
Weil nicht alle Zauberer brainstorm.zauberer lesen koennen:

Wir wollen einen festen Gildenmagier mit allen Rechten und Pflichten !

Birdy
Raventhrone

-----------------------------------------------------------------------------



Re: Petition (Lamarion, 21. Dez 2000, 14:44:36):
~#! rn=Birdy rt=977405216 rg=gilden.zauberer
~#! tid=977405216

Ich kann mich dem Wunsch von Birdy nur anschliessen.
Hiermit unterstuetze ich diese petition.

Lamarion,
Kurz und knapp.

-----------------------------------------------------------------------------



Re: Petition (Thufhir, 21. Dez 2000, 14:51:16):
~#! rn=Birdy rt=977405216 rg=gilden.zauberer
~#! tid=977405216
Allen Zauberern sollte klar sein, dass in naeherer Zukunft was geschehen muss!
Dazu waere es durchaus wuenschenswert, wenn sich ein Magier bereit erklaeren
wuerde die Gilde zu uebernehmen, und das nicht nur kommissarisch. Dies ist
sicher mit viel Arbeit verbunden, da ein Konzept entwickelt werden muss (das
man evtl. mit den Zauberern durchdiskutiert, einige gute Ansaetze von
Spielerseite hat es ja bereits gegeben, die aber leider nicht weiter verfolgt
wurden). Dieses Konzept muesste mit Nachtwind abgesprochen werden. Wenn das
dann steht braucht der entsprechende Magier gute Nerven das knallhart
durchzusetzen, gegen alles gejammer und gegen die anderen Magier. Ich
unterstuetze also prinzipiell Birdys Petition und fordere alle Magier, die
sich das zutrauen, die genug Zeit haben und die Stimmung rueberbringen koennen
auf, sich fuer den Posten zu melden!

s'Zauberzwerch

-----------------------------------------------------------------------------



Re: Re: Petition (Patryn, 21. Dez 2000, 14:53:42):
~#! rn=Thufhir rt=977406676 rg=gilden.zauberer
~#! tid=977405216
es ware wohl deutlich zu erkennen, dass sich ein maguer bereiterklaert,
wenn man brainstorm.zauberer liest. letztlich hat wim alle rechte, das
selbst zu entscheiden.

------
patryn, durchaus bereit...

-----------------------------------------------------------------------------



Re: Re: Petition (Niete, 21. Dez 2000, 14:53:54):
~#! rn=Thufhir rt=977406676 rg=gilden.zauberer
~#! tid=977405216
ok, der artikel ist schonmal gehaltvoller als die vorhergehenden. weil ich das
auch so sehe (und hier geloechert werde ;) ) moechte/soll ich das ganze auch
unterstuetzen. :)



-----------------------------------------------------------------------------



Re^3: Petition (Silvana, 21. Dez 2000, 14:56:31):
~#! rn=Niete rt=977406834 rg=gilden.zauberer
~#! tid=977405216
Ihr tut ja fast so, als haettet Ihr keinen Gildenmagier. Ich jedenfalls hatte
bisher Wim fuer zustaendig gehalten.

  Silvana . o O (Wo ist Anatol, wenn man ihn braucht?)

-----------------------------------------------------------------------------



Re: Re: Petition (Nonne, 21. Dez 2000, 15:00:15):
~#! rn=Thufhir rt=977406676 rg=gilden.zauberer
~#! tid=977405216
Ich glaube nicht, dass Du viele widerstaende von Magierseite erwarten musst.
Schliesslich kommt einem die Gilde momentan konzeptlos vor. Wenn sie
Stimmungsvoll, ein bisschen logischer und ausgewogen daherkommt, wofuer
Nachtwind bestimmt sorgen wird, hat hier bestimmt niemand ein Problem. Denke
ich zumindest.

Nonne, wedelt mit einen Zauberer-Updaten!-Faehnchen *g*

-----------------------------------------------------------------------------



Re^4: Petition (Birdy, 21. Dez 2000, 15:01:29):
~#! rn=Silvana rt=977406991 rg=gilden.zauberer
~#! tid=977405216
Wim ist auch fuer uns kommissarisch zustaendig, leider ist es mit seiner Zeit
nicht so gut bestellt.
Anfangs freute ich mich riesig, dass er die Stelle uebernahm, aber als unser
fester gildenmagier hat er sich nie bezeichnet.
Dann kam auch noch die privatfehde zwischen wurst und ihm dazu ...
und seitdem liegt hier irgendiwe alles auf eis und es herrscht eine gespannt
wartende atmosphaere.
irgendwie wartet hier jeder darauf, dass der andere was sagt, aber keiner
traut sich so recht, der erste zu sein.
heute haben wir uns mal wieder aufgerafft :)


-----------------------------------------------------------------------------



Re^3: Petition (Birdy, 21. Dez 2000, 15:04:20):
~#! rn=Nonne rt=977407215 rg=gilden.zauberer
~#! tid=977405216
ohne einen festen gildenmagier, der das konzept auch umsetzen und bearbeiten
kann, ist das beste konzept sinnlos.
wir brauchen erstmal die basis fuer konstruktive arbeit.
so lange wir nur sagen, was getan werden muesste, aber keine setzt das auch
um, drehen wir uns nur im kreis.

-----------------------------------------------------------------------------



Re^4: Petition (Nonne, 21. Dez 2000, 15:06:12):
~#! rn=Birdy rt=977407460 rg=gilden.zauberer
~#! tid=977405216
Ich wollte doch nur, dass ein etwaiger neuer Gildenmagier nicht sofort Angst
vor dem Boesen Mopp bekommt. *g*
Hatte sich Patryn da nicht angeboten, oder habe ich das falsch verstanden?!

Nonne, sich auf eine erneute Fehde mit Partyn freuend *g*

-----------------------------------------------------------------------------



Re^4: Petition (Silvana, 21. Dez 2000, 15:06:56):
~#! rn=Birdy rt=977407460 rg=gilden.zauberer
~#! tid=977405216
Solang Wim den Posten nicht zur Verfuegung stellt, duerfte sich da wohl kaum
was tun. Und selbst wenn: Wer sollte es tun? Und bevor jetzt jemand "Silvana"
schreit, ueberlegt Euch gut, ob Ihr das _wirklich_ wollt...

   ...selbige.

-----------------------------------------------------------------------------



Re^5: Petition (Birdy, 21. Dez 2000, 15:11:16):
~#! rn=Silvana rt=977407616 rg=gilden.zauberer
~#! tid=977405216
reden wir die sache nicht gleich wieder tot :)
warten wir erstmal ab, wieviel von uns zauberern, meiner petition zustimmen
oder was sie sonst so wollen.
Wenn ihr magier jetzt schon gleich ins kalkulieren geratet, stirbt das hier
wieder ab und ihr wisst wieder nicht, was wir ueberhaupt wollen.
vielleicht verlaefut sich das hier ja, wie viele andere sachen, ja im sand und
ihr magier braucht euch keinen kopf mehr drum zu machen. :(

-----------------------------------------------------------------------------



Re^6: Petition (Vector, 21. Dez 2000, 15:34:42):
~#! rn=Birdy rt=977407876 rg=gilden.zauberer
~#! tid=977405216
...zeig mir den Zauberer (erstie) der _nicht_ fuer Deine
Petition ist, Birdy.

--Vector--

-----------------------------------------------------------------------------



Re^3: Petition (Thufhir, 21. Dez 2000, 15:40:56):
~#! rn=Patryn rt=977406822 rg=gilden.zauberer
~#! tid=977405216
natuerlich hat Wim die Rechte... aber ohne ihm was zu wollen, er hat selbst
immer gesagt, dass er das Amt des Gildenmagiers nur kommissarisch uebernimmt,
niemand kann ihm vorwerfen, dass er wenig Zeit fuer die Gilde hat, aber
objektiv betrachtet muss man das wohl feststellen. ;( Objektiv betrachtet kann
also keiner wirklich dagegen sein, wenn ein motivierter Magier das Amt
uebernehmen moechte.

s'Zauberzwerch

-----------------------------------------------------------------------------



Re^6: Petition (Ark, 21. Dez 2000, 17:18:43):
~#! rn=Birdy rt=977407876 rg=gilden.zauberer
~#! tid=977405216
Hm, wenn ich alles so lese, mag ich mich spontan bereit erklaeren, einen
Abstimmraum namens "Florida" zu schreiben, samt der Wahlurnen ;^)
Nicht hauen ...


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^6: Petition (Anatol, 21. Dez 2000, 18:44:09):
~#! rn=Birdy rt=977407876 rg=gilden.zauberer
~#! tid=977405216
Anstatt oeffentlich "Verbrennt Wim!" zu schreien - und genau das hast Du,
da Du offenbar vorher nicht mit Wim Ruecksprache hieltst, getan -, schlage
Deine Langeweile doch bitte auf andere Art und Weise tot.

Nichts gegen Zauberer, die Interesse an der Gildenentwicklung zeigen. Aber
ein "Hey, wir haben keinen Gildenmagier!" zu schreien, wo ein "Hey, Gilden-
magier, sag mal was!" angebracht waere, halte ich dann doch fuer grob 
fahrlaessig. Nicht zuletzt wegen des Endzeitszenarios: Angenommen, Du
schaffst es, Wim zu vergraulen - wer wuerde eine Gilde uebernehmen wollen,
deren Mitglieder den letzten Gildenmagier systematisch rausgeekelt haben?

Frohes Fest,
Anatol

-----------------------------------------------------------------------------



Re^7: Petition (Birdy, 21. Dez 2000, 22:03:47):
~#! rn=Anatol rt=977420649 rg=gilden.zauberer
~#! tid=977405216
Hallo Anatol !

auf deinen artikel gehe ich nur insoweit ein, dass ich dir ans herz lege,
meine artikel genau zu lesen.

persoenlich werde ich dir gleich eine mail schreiben, da ich weiss, dass du
dich nur zu gern in allen rubriken produzierst und ich das hier vermeiden
moechte.
solche diskussionen enden immer fruchtlos, da man sich im endeffekt nur
gegenseitig runtermacht.

birdy

-----------------------------------------------------------------------------



Re^8: Petition (Elendil, 21. Dez 2000, 22:43:34):
~#! rn=Birdy rt=977432627 rg=gilden.zauberer
~#! tid=977405216
Hi Zaubis,

ich moechte an dieser Stelle nicht gegen oder fuer einen Magier
plaedieren/reden. Wer das nun im Endeffekt macht oder wer deligiert ist
eigentlich irrelevant, wichtig waere mal ein paar Aussagen der Magier im
zaubererumfeld :) Silvana deutet an, sie wuerde es machen (hab ich
zumindestens als Andeutung/Drohung so verstanden ;) ) Patrny hat sich offen
bereit erklaert und Wim hat den Posten inne. Das Problem ist, dass SPieler
nicht sehen ob an etwas gearbeitet wird, ich habe keinen Plan ob Wim fleissig
programmiert oder alles brach liegt. Natuerlich haben Spieler kein Recht auf
Programmierung, keine Frage aber es beruehight den Mopp wenn er weiss ob was
passiert :)
Ergo, es waere toll wenn Wim sich dazu aeussern koennte und eventuell wirklich
Naegel mit Koepfen gemacht werden koennten, da zumindestens Patryn die Sache
uebernehmen wuerde. (ohne das Wissen ueber eventuelle Aktivitaeten von Wim)
Falls Wim die Sache angehen moechte, kann man mit ihm diskutieren udn er
wiederum mit Nachtwind oder wie auch immer. Falls Wim zeitlich nicht in der
Lage ist und bereit ist den Posten abzugeben oder sich mit jemanden zu
koordinieren, wuerde ich gerne wissen wer das macht oder warum das keiner
uebernimmt trotz der Tatsache, dass jemand verfuegbar ist :)

Elendil wuenscht sich vorallem mal Informationen damit er nicht so in der Luft
haengt :)

-----------------------------------------------------------------------------



Re^9: Petition (Anacrion, 22. Dez 2000, 00:14:37):
~#! rn=Elendil rt=977435014 rg=gilden.zauberer
~#! tid=977405216
Hi auch.

Ich habe vor einiger Zeit mit Wim geredet und er hat gemeint, dass er zur Zeit
die Gildenraeume weiterprogrammiert, ihm jedoch zur Zeit die Zeit fehlt auch
noch am Gildenkonzept rumzudoktoren. 

Wieterhin waere im ein RL-Treffen am liebsten, um das Konzept auf die Beine zu
stelln.

das sind meiner Meinung nach doch gar nicht so schlechte Aussichten.

Der einzige Punkt, azu dem ich von wim keine Stellungnahme gekriegt habe (er
musste weg) , ist, dass meiner Meinung nach nicht mehr viele Zauberer da sind,
um in 5 Monaten die schoene neue Gilde zu bewundern, wenn nicht jetzt was am
Konzept gedreht wird.
Aus diesem Grund, und um in die Bresche zu springen, die sich aus Wims
Zeitmangel dahingehend ergibt, hatte ich sc9on auf b.zauberer alle Zauberer
eingeladen, nach Darmstadt zu kommen (29.12), um mal son ein paar Punkte
durchzugehen, Ideen zu sammeln. Das sich daraus ergebende Konzept koennte dann
sowohl mit Wim als auch der Gildenbalance abgestimmt werden. Ich glauzbe, es
gibt genug willige (notfalls auch Spieler mit programmiererfahrung), die sich
der Sache an den Stellen annehmen wuerden, wo die Zeit des Gildenmagiers (wer
auch immer) fehlt.

MfG

Anacrion

-----------------------------------------------------------------------------



Re^10: Petition (Elendil, 22. Dez 2000, 00:48:53):
~#! rn=Anacrion rt=977440477 rg=gilden.zauberer
~#! tid=977405216
Hi zusammen :)

Also am 29.12 hab ich keine Zeit, an Interesse mangelt es nicht.
Ich wuerde ja auch nur gerne wissen ob sich was regt oder nicht. Wenn Du das
weisst hilft Dir das, ich wusste es nicht :)
Ist Wim denn zeitlich in der Lage ein Konzept mit/zuentwickeln und umzusetzen
? Ja/Nein :)
wille
Wenn Ja, bestens. Wenn Nein, wer kommt in Frage, wer nicht, wer entscheidet
wer in Frage kommt ?
Uebrigens sagt doch keiner was gegen Wim, er hat die Gilde uebernommen und
sein moeglichstes getan und jeder der meint das besser zu koennen oder mehr
Zeit zu haben, kann ja Magier werden und auf gehts :)
Thema RL-Treffen: Das ist nu schon 3 mal gescheitert und eigentlich wird doch
genug diskuttiert und genuegend Vorschlaege sind auch vorhanden. Wenn
Kompetenzen abgesteckt sind und klar ist welcher Magier wann wozu berechtigt
ist und natuerlich Zeit hat, kann man die Vorschlaege sammeln, der
entsprechenden Magier streicht die nicht verwirklichbaren/ nicht akzeptablen
und dann muss ein Modus gefunden werden in dem zwischen den restlichen
Konzepten entschieden wird. Entweder der Magier sagt, ich realisieren nur das
(kurzer Entscheidungsfindungsprozess ;) ) oder die Zauberer koennen abstimmen.
Wie waers wenn 1. eine Prioritaetsliste erstellt wird fuer die
reformbeduerftigen Bereiche, dann jeder zu jedem Bereich einen vorschlag
machen kann und die gesammelt werden. Dann haben wir nachher eine Liste: 1.
Angriffspells 2. Gildenflair 3. Gildenraeume 4. Erzmagister (nur mal als
Beispiel) und dann AD 1. Vorschlag Thufhir: blablub, Vorschlag Anatol: blubbla
/// AD 2. Vorschlag Anacrion: asdf, Vorschlag Elendil hjkl ... dann werden die
Vorschlaege auf die sinnvollen reduziert und der Magier sagt entweder wir
koennen abstimmen oder realisiert einfach einen davon in Absprache mit
Nachtwind. Die Frage ist also kann man ein Vorschlagsbrett in die Kneipe
stellen :) ? Damit eben nicht alle Vorschlaege wieder verloren gehen :) ?
Faend ich toll :)

Elendil auf der Suche nach einen effizienten Verfahren ;)

-----------------------------------------------------------------------------



Re^11: Petition (Bambi, 22. Dez 2000, 11:35:07):
~#! rn=Elendil rt=977442533 rg=gilden.zauberer
~#! tid=977405216
nur mal so am rande...
wieso sollen nur (schon existierencde) "zaubis" abstimmen duerfen und warum
sollen nur die da mitreden?

-----------------------------------------------------------------------------



Re^12: Petition (Hight, 22. Dez 2000, 13:50:29):
~#! rn=Bambi rt=977481307 rg=gilden.zauberer
~#! tid=977405216
Ich denke um da nen sinnvollen Beitrag leisten zu koennen, sollte man zumindst
ansatzweise Ahnung von den Zauberern und deren Benutztung (sprichh wie man sie
spielt) haben. Fuer ein Brett wie Elendil es vorschlaegt is die Zaubikneipe
kein schlechter Ort sonst sammelt sich n haufen Muell von Hinz und Kunz die
einfach auch nur mal ihren Senf dazugeben wollen. Allerdings sollte das Ganze
nicht wieder auf einen "elitaeren" Kreis beschrenkt werden, wie bei b.zauberer
bei dem ich mir jedesmal von Jemandem den Inhalt posten lassen muss, wenn ich
auch mal lesen will was los is.

YT Hight

-----------------------------------------------------------------------------



Re^10: Petition (Ark, 22. Dez 2000, 15:58:43):
~#! rn=Anacrion rt=977440477 rg=gilden.zauberer
~#! tid=977405216
Hups, Darmstadt am 29.12.00 ??? Da wusste ich gar nix von. Wenn der
beschauliche kleine Stammtisch wirklich als Sammelbecken der Spitzhutmimosen
benutzt werden sollte, meldet Euch mal. Sooo gross ist der Hotzenplotz nun
auch nicht :-) *aehem*


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^12: Petition (Elendil, 22. Dez 2000, 17:21:29):
~#! rn=Bambi rt=977481307 rg=gilden.zauberer
~#! tid=977405216
Hi :)
Also eine Angelegenheit der Zauberer z.B. mit einem Brett in der AG zu
begegnen empfinde ich als sehr merkwuerdig. Wer einen vernueftigen Vorschlag
hat wird den doch wohl einem Zauberer zutragen koennen, der ihn postet.
Der Entscheidungsprozess (sofern nicht der Gildenmagier entscheidet) ist wohl
eindeutig Zaubererangelegenheit weil es um die Umstrukturierung der Gilde
geht. Die Kaempfer lassen uns auch nicht ihre Berichte bewerten und selbst
Kaempfer muessen glaube ich Gildenlvl 14 sein. Also Gildeninternas in der
Gilde zu halten ist ja wohl normal, zumal es hier um die Gilde ansich geht :)

Das Brett war auch nicht als Diskussionsplattform sondern lediglich als
Sammelstelle der Vorschlaege gedacht, jeder den es interessiert macht sich
einen Lvl 1 Zauberer oder setzt seine Gilde um :) Um Zauberer zu sein muss man
halt was tuen :) 

CU, Elendil der kleine Zauberer :)

-----------------------------------------------------------------------------



Re^11: Petition (Anatol, 22. Dez 2000, 17:59:04):
~#! rn=Ark rt=977497123 rg=gilden.zauberer
~#! tid=977405216
Nur weil Anacrion schreit, wird noch lange nichts zu einem offiziellen
Zauberertreffen. Schon gleich gar nicht (AUSGERECHNET) zwischen Weihnachten
und Neujahr, wo jeder, der nicht NUR ein VL-Leben hat, auch andere Dinge
vorhaben koennte - und eben nicht mal schnell nach Darmstadt reisen kann.

Anatol

-----------------------------------------------------------------------------



Re^12: Petition (Ark, 22. Dez 2000, 18:07:28):
~#! rn=Anatol rt=977504344 rg=gilden.zauberer
~#! tid=977405216
Naja, Darmstadt runtermachen wollte ich jetzt net ;^)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^10: Petition (Liara, 22. Dez 2000, 19:20:29):
~#! rn=Anacrion rt=977440477 rg=gilden.zauberer
~#! tid=977405216
Also, ehrlich gesagt geht mir dieses 'Ich habe mal mit Wim geredet ... ' von
diversen Zaubis langsam echt auf den Wecker. Wieso kann Wim denn nicht einfach
mal eine kurze Stellungnahme fuer alle abgeben?

Liara, Zwergenzauberine, auch interessiert am Fortgang der Gilde

-----------------------------------------------------------------------------



Re: Petition (Birdy, 24. Dez 2000, 18:01:38):
~#! rn=Birdy rt=977405216 rg=gilden.zauberer
~#! tid=977405216
Hiho !

Inzwischen ist wieder Bewegung in die Sache gekommen, genauso, wie wir es uns
erhofften.
Ueber die Weihnachtsfeiertage wird das zwar nicht so schnell weitergehen, aber
danach koennen wir mit ersten Ergebnissen rechnen.
Ich bleib auf jeden Fall dran am Fall. *g*

Frohes Fest und viele Geschenke wuenscht euch euer Kollege Birdy !:)

-----------------------------------------------------------------------------



Re^12: Petition (Anacrion, 25. Dez 2000, 17:44:01):
~#! rn=Anatol rt=977504344 rg=gilden.zauberer
~#! tid=977405216
Lieber Anatol,

nur weil jemand zwischen Weihnachten und Neujahr Zeit hat, bedeutet das noch
lange nihct, dass er kein RL-Leben mehr hat. Es bedeutet nur, dass er am
29.12. Zeit hat. Und es bedeutet, dass sich diejenigen, die kommen, entweder
fuer das MG oder die Zauberergilde im speziellen (letzere wohl beides)
interessieren.

Ich freue mich ueber jeden erscheinenden Zauberer :)

Anac*

P.S. Wenn _Du Deine Freundin auch mitbringst Anatol, dann koennen sich ja
meine und Deine unterhalten, waehrend wir noch ei paar Konzepte ueberlegen.
Ich kann immer noch nicht glauben, dass Du Deinen Titel als 'King of Flame'
wieder zurueckerobern willst :)

-----------------------------------------------------------------------------



Re^12: Petition (Rardian, 26. Dez 2000, 03:00:06):
~#! rn=Bambi rt=977481307 rg=gilden.zauberer
~#! tid=977405216
Warum sollen ueberhaupt Zaubis abstimmen? Stimmen die Kaempfer etwa darueber
ab, ob der Waffenschlag doch noch mehr Schaden macht? Oder stimmen die Tanjian
darueber ab, ob Kokoro viel zu lange dauert??
Natuerlich koennen von Spielern (nicht nur Zaubis) Vorschlaege eingebracht
werden, die auch Beruecksichtigung finden sollten. Bei den Kaempfern klappt
das ja hinsichtlich neuer Berichtsthemen und Lev24-Gestaltung doch recht
gut...

Rar.

-----------------------------------------------------------------------------



Re^13: Petition (Elendil, 26. Dez 2000, 23:17:00):
~#! rn=Rardian rt=977796006 rg=gilden.zauberer
~#! tid=977405216
Hi :)
Ich hab ja extra darauf hingewiesen, dass es keine Wahl geben muss. Eben,
falls der Gildenchef sagt wir koennen abstimmen, ihm waere es gleich. Dann ist
das doch vollig legitim wenn wir uns das aussuchen.  
Sagt der zustaendige Magier, er moechte das entscheiden ist es auch bestens.
Elendil

-----------------------------------------------------------------------------



Re^13: Petition (Liara, 27. Dez 2000, 00:17:00):
~#! rn=Rardian rt=977796006 rg=gilden.zauberer
~#! tid=977405216
Du widersprichst Dir in Deinem Artikel. Und ausserdem hast Du die Situation
der Zauberergilde nicht verstanden, wenn Du einen solchen Artikel schreibst.

LZ

-----------------------------------------------------------------------------



Re^13: Petition (Anacrion, 28. Dez 2000, 19:04:55):
~#! rn=Anacrion rt=977762641 rg=gilden.zauberer
~#! tid=977405216
Ein paar kurze Gedanken zu Kommentaren auf meinen Artikel:

1) Mir lAN	angt es vollkommen, Anatol VL zu kennen. Eine RL-Bekanntschaft
wuerde ich zum Wohle der Gilde in Erwaegung ziehen, aber alles darueber
hinausgehende steht mir fern.

2) Das ich zwischen den Jahren Aktiv werde (im ezug auf die ZGilde) liegt
daran, dass ich sonst ausssch,liesslich in den USA zu finden bin.

3) Ich denke dass sich RL und VL auch zwischen Weihnachten und Neujahr
vereinbaren lassen, wenn man eine nette Beziehung hat :)

Viele Gruesse und Frohen Rutsch (so wir uns nicht am 29.12. sehen) wuenscht
Anacrion

-----------------------------------------------------------------------------



Heulen und Zaehneklappern (Llystrathe,  8. Jan 2001, 22:36:04):
So, meine ungeduldigen, dummen Schaefchen.

Jetzt reichts. Nicht mal mit der Petersilie, die ich Randar immer wieder
abnehme, gelingt es mir noch, Euer unwuerdiges Gejammer zu ignorieren. Also
gut, Ihr habt es nicht besser verdient. 

Es war einiges an wirklich maechtiger Magie noetig, dieses zu bewirken. Magie
die weit jenseits Eurer bescheidener Moeglichkeiten liegt. Also hoert, was ich
bewirkt habe und nervt mich nicht weiter.

Von heute an wird ein magischen Viergestirn ueber unsere Gilde herrschen und
Euch wieder Manieren beibringen. Ich erwarte, dass Ihr Euch zu benehmen wisst!

Ark - ihr wisst alle, was ihr bei seinen Raeumen erwarten koennt - wird sich
darum bemuehen, der Gilde Raeumlichkeiten zu geben, die ihrer angemessen sind.

Patryn - wer erinnert sich nicht an seine Zeit - wird uns Kuratoren und
unseren Angestellten beibringen, sich angemessen zu wehren, wenn wir von einem
Haufen amoklaufender Idioten ueberfallen werden.

Wim wird uns ebenfalls erhalten bleiben. Er wird dafuer sorgen, dass uns das
Lehren noch mehr Spass machen wird... Ihr kennt ja meine Art von Humor.

Und zu guter letzt wird Silvana zu uns zurueckkehren. Sie wird dafuer sorgen,
dass Ihr demnaechst wirklich Grund zum jammern habt. Sie nennt es "das
Gildenkonzept ueberarbeiten" und will das wohl auch durch- und umsetzen.

So, genug davon. Ab sofort will ich nichts mehr davon hoeren. Ihr habt es
nicht besser verdient, also geht in Eure stillen Ecken und jammert. Aber lasst
mich gefaelligst damit in Ruhe.

Llystrathe

-----------------------------------------------------------------------------



Re: Heulen und Zaehneklappern (Elendil,  8. Jan 2001, 22:45:26):
~#! rn=Llystrathe rt=978989764 rg=gilden.zauberer
~#! tid=978989764
Hi ehrwuerdiges Viergestirn und Zauberer/inen,

mein Kommentar :) JAAAAAAAAAAAAAAAAAAAa, endlich :)

Elendil der kleine Zauberer hat den Glauben an Wunder wiederentdeckt :)

-----------------------------------------------------------------------------



Re: Re: Heulen und Zaehneklappern (Anacrion,  8. Jan 2001, 23:22:26):
~#! rn=Elendil rt=978990326 rg=gilden.zauberer
~#! tid=978989764
Jabadabaduuuuuuuuuuuuuu :))

Anac* schliesst sich Elendil an und ruft Eeeeeeendlich ! :)

Danke an alle von euch und so und viel Erfolg und ueberhaupt :)

Anac freut sich wie ein Schneekoenig :)

-----------------------------------------------------------------------------



Re^3: Heulen und Zaehneklappern (Birdy,  8. Jan 2001, 23:33:01):
~#! rn=Anacrion rt=978992546 rg=gilden.zauberer
~#! tid=978989764
OHA !

Ich freu mich drauf !

vielen Dank fuer euer engagement !

Birdy
*huepf*

-----------------------------------------------------------------------------



Re^4: Heulen und Zaehneklappern (Linflas,  9. Jan 2001, 00:25:43):
~#! rn=Birdy rt=978993181 rg=gilden.zauberer
~#! tid=978989764

Linflas jammert.

...und freut sich!

-----------------------------------------------------------------------------



Re: Heulen und Zaehneklappern (Strohalm,  9. Jan 2001, 00:52:32):
~#! rn=Llystrathe rt=978989764 rg=gilden.zauberer
~#! tid=978989764
Und da soll noch einer sagen Jammern waere uneffektiv... jetzt haben wir sogar
gleich 4 faehige (hoff ich doch mal ;)) Mags, die sich mit der
neukonzeptionierung unsrer kleinen Gilde auseinandersetzen *freu*

Vielen lieben Dank an das Viergestirn, und ich bei der momentanen Stimmung
unter den Zaubis koennt ihr euch mit Sicherheit auf kreative Unterstuetzung
von Spielerseite her freuen, die das Proggen hoffentlich ein wenig vereinfacht
;)

Haelmchen, auch nach 6 Mnaten Abstinenz immer noch Zaubi aus Ueberzeugung ;)

-----------------------------------------------------------------------------



Anzeige (Birdy,  1. Feb 2001, 21:18:06):
Hallo Kollegen und Kolleginnen !

Leider habe ich die Pflicht, euch heute ueber das vorzeitige Ableben meines
Freundes, unseres Kollegen Lamarion, in Kenntnis zu setzen.
Haltet einen Moment inne und gedenkt seiner !

Zauberer Birdy
*traurig*

PS: Weitere Informationen in artikel 4 in der rubrik anzeigen.

-----------------------------------------------------------------------------



Meinungsbild gefragt. (Silvana,  8. Feb 2001, 15:06:42):
Liebes unmuendiges Gildenvolk. ;-)

[Vorsicht, langer Artikel!]

Eigentlich kann ich Euch ja vorsetzen, was ich will und ihr habt dann die
Wahl, ob ihr's schluckt, oder austretet. Da aber eine Gilde, in der keiner
mehr meine Killstatistik fuellt, weil ihr schon alle ausgetreten seid,
langweilig ist, wollt ich doch zumindest mal hoeren, was ihr zu dem Thema
sagt. Ich kann mich danach ja immer noch dagegen entscheiden. ;-)

Also: Fakt ist, dass wir uns von der "Combination of death" sehr bald
verabschieden werden. Die groben Zuege dieses Vorgangs sind mit Nachtwind
besprochen, es geht nur noch um Zahlen. Das war zu erwarten und wird dann wohl
im Lauf des naechsten Monats (spaetestens) eintreffen. Dass es eine Form von
Entschaedigung geben wird, sollte klar sein. (Bessere Weine bei Wasserwandlung
vielleicht?)

Fuer mich ist das aber nur eine technische Uebergangsloesung, denn das, was
wir wirklich vor haben, ist in ein paar Monaten selbst bei Vollbeschaeftigung
der drei massgeblich beteiligten Magier nicht zu schaffen.

Wie ihr vermutlich wisst, stiftet uns Ark komplett neue Raeumlichkeiten.
Darueber hinaus aber haben wir uns sehr umfangreiche Gedanken um das Lehren
und Lernen in der Gilde gemacht und auch den Gildenquests, Pruefungen und
Skills voellig neue Bedeutungen im Dasein der Gilde verpasst. (Bisher
natuerlich nur in Form von Konzepten.) Das alles wird viel Arbeit kosten und
daher Zeit brauchen - genaugenommen kommt es einem neu schreiben der Gilde
beinahe gleich.

Und nun stelle ich mir doch mal die ketzerische Frage: Wieso, wenn wir eh fast
alles neu machen, machen wir's nicht gleich richtig, und verpassen auch den
Spells und der Struktur der Gildenraenge ein neues Konzept? Weil dann ein paar
Zauberer-NPCs im Regen stehen? Wohl kaum. Also fuer mich gibt es nur ein
echtes Argument: Es wuerde bedeuten, dass ihr _alle_ beinahe von neuem
anfangen muesstet in der Gilde. Alle Fertigkeiten neu lernen, alle Quests
(sofern noetig) noch einmal... Das einzige Zugestaendnis, dass ich da machen
koennte, ist, dass das bisher insgesamt in der Gilde erreichte (also quasi ein
Schnitt der Fertigkeiten) als Basiswert fuer das neu lernen der Skills und
Spells angerechnet wuerde. Es wuerde also Uebezeit einsparen.

Tja, nun sagt was dazu. Wollt Ihr eine vollstaendig in sich stimmige Gilde?
Oder doch lieber erst einmal Stueckwerk, aber dafuer ohne allzuviel neu lernen
zu muessen?

Also nicht, dass ihr meint, jetzt wirklich eine Wahl zu haben, aber wie
gesagt: Eine Gilde, in der keiner spielt, ist nicht witzig. ;-)


    Silvana

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Anatol,  8. Feb 2001, 15:34:22):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Pro.

Anatol - Zauberer

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Lanfear,  8. Feb 2001, 15:34:42):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Also wenn der bisherige Lern-/Gildenquestaufwand irgendwie gewuerdigt wird,
ist mir eine Komplettumstellung schon recht.
Wenn nacher eine schoene, stilvolle Gilde dabei herauskommt bin ich gerne
bereit, wieder als kleine Zauberine anzufangen. Allerdings wird dadurch der
Druck auf euch ziemlich gross werden, denn es wird schon genug Schreierei
geben und wenn sich dann das Opfer nicht lohnt... aber warten wir erstmal ab.

Ich, fuer mein Fall werde wohl im Mom eh erstmal von meinem alter ego geparkt,
bis klar wird, was sich mit der Gilde so ergibt.

Lanfear

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Strohalm,  8. Feb 2001, 15:46:52):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Ich wuerde mich fuer ne Komplettaenderung aussprechen... auch wenn man wieder
Arbeit in Ueben bzw. Questen stecken muss.
Hauptsache, man bleibt danach gerne Zauberer ;)

Lord Haelmchen, gloeckchenbimmelnd

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Thufhir,  8. Feb 2001, 15:48:52):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
dafuer

s'Zauberzwerch denkt .oO( jeder Neuanfang bedeutet eine Chance... )

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Vampire,  8. Feb 2001, 16:04:55):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Dafuer

Vampire

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Jasmin,  8. Feb 2001, 16:07:45):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
ich bin auch dafuer neu anzufangen ;)

MfG Jasmin

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Solmyr,  8. Feb 2001, 16:22:09):
~#! rn=Jasmin rt=981644865 rg=gilden.zauberer
~#! tid=981641202
*offtopic*

Warte erstmal Deine Abwertung ab :)

*ontopic*

Find ich gut, mein Zweitie wird Zaubi.
Solmyr

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Ahab,  8. Feb 2001, 16:33:49):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Dafuer.  (siehe auch Artikel 6 in dieser Rubrik).

Ahab, zieht wieder Karnickel aus dem Hut.

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Obermotz,  8. Feb 2001, 16:42:05):
~#! rn=Ahab rt=981646429 rg=gilden.zauberer
~#! tid=981641202
Hm, als aeltere faul^H^H^H^Hbequemer Hobbit wuerde ich natuerlich ungern bei
0% anfangen.
Aber wenn es hilft, dass die Gilde ein gutes Feeling bekommt und wir
Zauberer unseren alten Ruf zurueck, immer gerne. Eigentlich muesste
ich natuerlich aus purem Widerspruchsgeist "contra" sagen ;-).

Wann wird eigentlich die Diskussion ueber das neue Konzept ge-
startet? Oder gibt es da schon geheime Ansatzpunkte?

OM wuerde sich ueber einen neuen "Nachteil" freien: Nur noch ohne Kompos
zaubern koennen ;-)

-----------------------------------------------------------------------------



Re^3: Meinungsbild gefragt. (Linflas,  8. Feb 2001, 16:43:01):
~#! rn=Obermotz rt=981646925 rg=gilden.zauberer
~#! tid=981641202
Welche Diskussion?

Linflas, fordert mehr Oligarchie ;)

-----------------------------------------------------------------------------



Re^4: Meinungsbild gefragt. (Foobar,  8. Feb 2001, 16:50:41):
~#! rn=Linflas rt=981646981 rg=gilden.zauberer
~#! tid=981641202
Moin.

Ich als Sekundaerbetroffener begruesse Euer Vorhaben.

Obendrein seid Ihr drei wohl lange genug dabei um einschaetzen zu koennen, was
Ihr Euch da an Arbeit aufhalst :o)

Ein kleines bisschen "Besitzstandswahrung", wie in der von Silvana
angesprochenen Form halte ich fuer notwendig, ferner moechte ich davor warnen
die angekuendigten Aenderungen vorschnell "durchzuziehen", so dass wir dann
noch eine halbfertige Gilde hier rumliegen haben.

Wenn Neuerungen diskutiert werden sollen dann bitte hier oder in einer anderen
oeffentlichen Gruppe, aber bitte nicht in dieser ominoesen brainstorm-Rubrik,
weil dann moegliche konstruktive Vorschlaege von Nicht-Erstie-Zauberen
ausbleiben koennten und es IMHO schon im Vorfeld zu "Trotzreaktionen" kommen
koennte nach dem Motto: "Die neuen Zauberer werden eh wieder viel zu stark.".

Foobar sagt: Go, Dreigestirn, Go!

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Darkwing,  8. Feb 2001, 16:58:50):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
ganz klar dafuer.

Darkwing, packt seinen Zauberer dann vielleicht auch mal wieder fuer was
andere als Huelle und Rueste aus.

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Hardil,  8. Feb 2001, 17:28:12):
~#! rn=Darkwing rt=981647930 rg=gilden.zauberer
~#! tid=981641202
Fuer Vielspieler oder Dauermudder (genannt: Suchtis) mag das ja okay sein,
wied
er ganz bei Null (oder fast) anzufangen. Fuer Gelegenheitsspieler oder alte
Saec
ke, die ab und zu mal vorbeischauen (Ex-Suchtis), waere das katastrophal.
]Es sollte schon nicht nur eine 'gewisse', sondern eine DEUTLICHE
Besitzstandswa
hrung dabei herumkommen.
]Ehrlich gesagt - ich habe werder Lust noch (vor allem) Zeit, noch einmal in
mei
ner gewaehlten GIlde ganz von vorne anzufangen.
]Dies soll jetzt keine Gildenveraenderungen torpedieren, ich begruesse jede
Anpa
ssung - aber es muss fuerdie Betroffenen eine (wie man hier in Dabbeljuh-Land
so
 schoen sagt) 'soft landing' geben.
]
]Just my 2 nickel
]
]Hardil                    
(sorry fuer das katastrophale Lay-Out, man sollte halt nicht seine eigenen
Artikel aus Versehen loeschen, weil man das Alias fuer 'lies ARtikel Nummer
xz' mit dem ALias fuer 'loesche ARtikel Nummer xz' vertauscht hat... Asche
ueber mein Haupt.

-----------------------------------------------------------------------------



Re^3: Meinungsbild gefragt. (Solmyr,  8. Feb 2001, 17:30:46):
~#! rn=Hardil rt=981649692 rg=gilden.zauberer
~#! tid=981641202
Und da soll mir einer sagen, ich wuerde unuebersichtliche Artikel
schreiben :)

Solmyr

-----------------------------------------------------------------------------



Re^4: Meinungsbild gefragt. (Mythran,  8. Feb 2001, 17:53:45):
~#! rn=Solmyr rt=981649846 rg=gilden.zauberer
~#! tid=981641202
Eindeutig dafuer...
Klingt ja nach 'nicht ganz' bei null anfangen..reicht mir!
Alles, was eine stimmige Gilde (mit humorvollen Moeglichkeiten)
ermoeglicht, ist mir recht, dafuer haenge ich einfach zu sehr
an der Idee des Zaubis.

Mythran im Auftrag von Makish, dem russverschmierten Toelpel

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Liara,  8. Feb 2001, 18:14:38):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Dafuer.

Liara, Zwergenzauberine

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Sahadoom,  8. Feb 2001, 18:57:58):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Dafuer.

El Duemchen, hat sich an Neuanfaenge gewoehnt :)

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Trug,  8. Feb 2001, 19:45:23):
~#! rn=Strohalm rt=981643612 rg=gilden.zauberer
~#! tid=981641202
Hm, wenn da nach der Komplettumstellung es auch so eine 'Spezialisierung' auf
einzelne Gildenzweige gibt, die einem dann in dem einen Gebiet halt Boni gibt,
dafuer in anderen Abschlaege? So eben, dass man sich zum Beispiel in Bereich
Illusion man fuer die Spezialisierung verschiedene Nettigkeiten; muessen ja
nicht etwas metzeltechnisches sein, eher etwas fuer die Unterhaltung :)

Trug

-----------------------------------------------------------------------------



Re^3: Meinungsbild gefragt. (Trug,  8. Feb 2001, 19:46:07):
~#! rn=Trug rt=981657923 rg=gilden.zauberer
~#! tid=981641202
Eben dafuer :)

Trug, so oder so ;)

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Apsu,  8. Feb 2001, 20:06:22):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Aber bitte den NPC-Gildedoedeln Stupse verpassen, damit wir uns fuer die
netten Besuche der Zaubiluschen im Struv bedanken koennen ;-)

Apsu --> schmarrn

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Apsu,  8. Feb 2001, 20:10:33):
~#! rn=Apsu rt=981659182 rg=gilden.zauberer
~#! tid=981641202
P.S.: Dafuer
i.A. Zwocklhuber

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Silvana,  8. Feb 2001, 20:26:37):
~#! rn=Apsu rt=981659182 rg=gilden.zauberer
~#! tid=981641202
Sobald Patryn seine Pruefungen hinter sich hat, hat er vor, sich genau darum
zu kuemmern. Auf dass Ihr Trves nicht nur zu Hause, sondern auch auswaerts den
Hosenboden versohlt bekommt. ;-) Ob sie Stupse bekommen, wage ich zu
bezweifeln. Aber angreifbar und sterblich werden sie sein...

  Silvana

-----------------------------------------------------------------------------



Re^3: Meinungsbild gefragt. (Solmyr,  8. Feb 2001, 20:27:43):
~#! rn=Silvana rt=981660397 rg=gilden.zauberer
~#! tid=981641202
Juchhhhhu :) Endlich Zaubi's legal vermoebeln.

Solmyr,gleich Party machen gehend

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Ark,  8. Feb 2001, 21:10:37):
~#! rn=Apsu rt=981659182 rg=gilden.zauberer
~#! tid=981641202
Klar, wird bedacht. Hoffentlich bereut Ihr die Forderung nicht ;^)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Vardion,  8. Feb 2001, 23:20:04):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Hi.

Ich bin prinzipiell auch dafuer. Ich moechte nur darm bitten, dass alte
Dachen erst dann gekappt werden, wenn entsprechender Ersatz _fertig_ ist.
Ich glaub ich bin nicht der einzige, der keine Lust hat laenger als nen
Monat oder so mit einer halben Gilde zu spielen.
Und ich stimmt auch Foobar und Hardil zustimmen - eine gewisse
"Besitzstandswahrung" faende ich sehr wuenschenswert.

Ansonsten viel Erfolg :-)

Vardion

-----------------------------------------------------------------------------



Re^4: Meinungsbild gefragt. (Foobar,  8. Feb 2001, 23:39:39):
~#! rn=Solmyr rt=981660463 rg=gilden.zauberer
~#! tid=981641202
Freu Dich nicht zu frueh, oder hast Du vergessen _wer_ die NPCs schreibt? :o)

Gruss,

     Foobar

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Gwendula,  9. Feb 2001, 00:20:08):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
alles neu lernen?
wo gings doch gleich zu den tanjian?

gwen

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Birdy,  9. Feb 2001, 00:43:27):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Hiho !

Prinzipell Pro.
Aber mit deutlicher Besitzstandswahrung. D.h. keine Methusalem-Uebezeiten.
Stellt euch mal vor, 100 Zauberer fangen vom einen auf den anderen Tag an, zu
ueben.

Allen Zauberern, die keine Zweities haben wird es ausserdem zusaetzlich schwer
fallen.

Birdy *nachdenklich*

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Saul,  9. Feb 2001, 08:22:46):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Wenn ich das richtig verstanden habe, gibt es neue Gildenraeume, neue
Spells und ein neues Konzept. Dann stell ich auch mal eine ketzerische
Frage: Wieso nicht eine neue (eine weitere) Gilde programmieren?

   Saul

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Isi,  9. Feb 2001, 10:28:32):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Auch dafuer - mit bisschen Bestandserhaltung wenns geht

Isi (kompowerfend)

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Pallando,  9. Feb 2001, 11:11:28):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Dafuer.  Und nach Moeglichkeit den bisherigen Uebungs- und Materialaufwand.
beruecksichtigen.  Von Null anzufangen waer nicht so dolle.  Ansonsten
riesiges Danke schon mal fuer die Arbeit und viel Spass bei der Umsetzung!
Pallando

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Hugalf,  9. Feb 2001, 11:14:33):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Bin zwar nur ein kleiner Zweitie, aber trotzdem dafuer. Bisher werde ich
naemlich viel zu wenig gespielt, da mein Erstie mich langweilig findet und
lieber mit Kaempfer und Tanjian metzeln geht.

Hugalf, gespielt werden wollend.

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Elendil,  9. Feb 2001, 12:10:19):
~#! rn=Hugalf rt=981713673 rg=gilden.zauberer
~#! tid=981641202
Hi,

Pro !

Alte Hasen mit wenig Zeit sind natuerlich ein Problem aber man koennte
einen 90% Zauberer ja ersatzweise mit 90% Abenteurerskills ausruesten
wenn er nicht neu anfangen will ;)

*grins fies*

Elendil der kleine Zauberer

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Ariana,  9. Feb 2001, 16:53:41):
~#! rn=Hugalf rt=981713673 rg=gilden.zauberer
~#! tid=981641202
dafuer!

ariana

-----------------------------------------------------------------------------



Meinungsbild gefragt (Mtv,  9. Feb 2001, 17:33:58):
~#! rn=Ariana rt=981734021 rg=gilden.zauberer
~#! tid=981641202
Dafuer

fuer die Bestandeserhaltung bin ich auch :)

MTV, der langsam ein aelterer Zauberer ist, und kaum mehr Zeit zum spielen,
geschweige denn zum vielen ueben hat

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt (Grinur,  9. Feb 2001, 17:39:43):
~#! rn=Mtv rt=981736438 rg=gilden.zauberer
~#! tid=981641202
Pro Umwaelzung, Pro-Bestandserhaltung (Bin zwar miserabel habe aber auch
im Moment keine Zeit zum ueben)

Grinur

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt (Laranis,  9. Feb 2001, 17:53:58):
~#! rn=Grinur rt=981736783 rg=gilden.zauberer
~#! tid=981641202
Dagegen.
Ich habe keine Zeit und auch keine Lust, wieder stundenlang irgendwelche
Skills hochzuueben.
Fuer die "neue" Gilde bin ich aber trotzdem :o)

Laranis

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Weatherwax,  9. Feb 2001, 18:47:09):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Dafuer.

Wx

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Anacrion,  9. Feb 2001, 19:02:51):
~#! rn=Weatherwax rt=981740829 rg=gilden.zauberer
~#! tid=981641202
Sowas laesst sich ja - insbesondere im Hinblick darauf, dass doch einige mit
negativen Folgen rechnen muessen - wirklich gut an.

Da sag noch mal einer, die Zazuberer wuerden nicht zusammenhalten.

Anac*

-----------------------------------------------------------------------------



Re^3: Meinungsbild gefragt. (Grimmborn,  9. Feb 2001, 19:23:13):
~#! rn=Anacrion rt=981741771 rg=gilden.zauberer
~#! tid=981641202
Du meinst: "In Freud und Leid zum Jammern bereit"?

GdA

-----------------------------------------------------------------------------



Re^4: Meinungsbild gefragt. (Anacrion,  9. Feb 2001, 20:33:43):
~#! rn=Grimmborn rt=981742993 rg=gilden.zauberer
~#! tid=981641202
Hab ich was von Jammern gelesen ?

Anac*

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt (Ark,  9. Feb 2001, 20:50:11):
~#! rn=Mtv rt=981736438 rg=gilden.zauberer
~#! tid=981641202
Oeh, jetzt bin ich aber auchmal ganz doll ketzerisch: warum
Besitzstandswahrung, wenn man "kaum mehr Zeit zum Spielen" hat??? Will man auf
hohem Zaubererniveau idlen oder chatten? Ich bin halt schon etwas weiter vom
Spieler entfernt, und suche zu verstehen, wiesowarumweshalb *hust*


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt (Paracelsus,  9. Feb 2001, 20:51:01):
~#! rn=Ark rt=981748211 rg=gilden.zauberer
~#! tid=981641202
Arkilein, sagt Dir der Begriff "Levelgeilheit" etwas? :)

Para*

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt (Anatol,  9. Feb 2001, 20:52:23):
~#! rn=Ark rt=981748211 rg=gilden.zauberer
~#! tid=981641202
Es geht jenen Leuten darum, dass sie gelegentlich doch nochmal gerne
losziehen - auch wenn sie die Zeit, den Charakter nochmal hochzuspielen,
nicht aufbringen koennen oder wollen.

Anatol - so einfach ist das

-----------------------------------------------------------------------------



Re^3: Meinungsbild gefragt (Ark,  9. Feb 2001, 20:58:05):
~#! rn=Paracelsus rt=981748261 rg=gilden.zauberer
~#! tid=981641202
Aber dafuer koennte man ja ganz schnell eine Idlergilde aus dem Aermel ziehen.
Level=Idlezeit, Skills: kleines Macro, das aus verschiedenen Wegmeldungen eine
auswaehlt und anzeigt; intelligente Gespraechsblasen, wenn man von Spielern
angesprochen wird, aber nicht vor der Kiste sitzt; Wandelskripte, um als Idler
unentdeckt zu bleiben.
Fuer das Spielen sind die Level ja sooo wischtisch, aber fuer Anwesenheit,
Rumstehen und Labern? Ich bin weltfremd. Gut, gleich mal wieder ein paar
balancebedenkliche Raeume schreiben gehen ;^)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^4: Meinungsbild gefragt (Wurzel,  9. Feb 2001, 21:45:04):
~#! rn=Ark rt=981748685 rg=gilden.zauberer
~#! tid=981641202
es koennte einem doch zu denken geben.
fast alle sind dafuer, mit nur wenigen besitzstandswahrern, die gilde quasi
auf den muell zu werfen und alles neu zu machen. ohne jetzt viel von den
zaubis zu verstehen, scheint mir das ja nicht so toll zu sein...
warum dann so viele leute noch in der gilde sind, ist mir dann allerdings
ein raetsel :)

wurzel

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt (Weatherwax,  9. Feb 2001, 21:50:34):
~#! rn=Ark rt=981748211 rg=gilden.zauberer
~#! tid=981641202
OKok,

na komm, wer was investiert hat, der moechte auch mal wieder ein bisschen
metzeln, ohne voll auf die Fresse zu kriegen, auch wenn er viel Zeit mit nem
kleinen Schwatz verbringt. Ist doch verstaendlich, oder?

Nu lass uns mal keine Unterschiede machen, ob derjenige, der bei der "neeeee,
ich sag das Wort jetzt nicht" beruecksichtigt wird, unbedingt in letzter Zeit
aktiv gewesen sein muss.

Was alle mit dem Wort, das ich hier nicht wiederhole, meinen, ist, wie ich
vermute, nur, dass sie hinterher nicht als Hanswurs dastehen wollen, und mehr
nicht.

Korrigiere mich, wer da wolle.

Immer noch dafuer.

Wx

-----------------------------------------------------------------------------



Re^5: Meinungsbild gefragt (Weatherwax,  9. Feb 2001, 22:01:00):
~#! rn=Wurzel rt=981751504 rg=gilden.zauberer
~#! tid=981641202
Weil sie Zauberer aus Ueberzeugung sind?

Weil sie die die Atmosphaere der Gilde moegen?

Ich habe, als ich hier als "der hoffnungsvolle Anfaenger" eingestiegen bin,
als einer der ersten Fragen diese gestellt. "Kann man hier auch Zauberer
werden?"

Und so wurde aus dem Erstie das, was daraus werden musste.

Und eins muss man wirklich mal sagen: Wenn dann gleich mehrere interessierte
Magier daherkommen und sagen: Wir kuemmern uns um die Gilde, wir haben
Interesse, wir haben was komplett Neues vor, und das auch noch glaubhaft
rueber bringen, dann sage ich:

OK, einverstanden! Macht!

Ich freue mich auf die Neuerungen, bin sehr gespannt.

Wx

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Raventhrone, 10. Feb 2001, 10:13:28):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Dafuer.

Der Rabe.

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Freya, 10. Feb 2001, 11:20:07):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
sehr dafuer,

schliesslich bin ich zauberine geworden, weil ich unbedingt in die gilde
wollte und nicht, weil ich den preis fuer die meisten Metzelaktionen pro
Sekunde gewinnen wollte,
da stoert auch die umarbeitung nicht, so lange alles stimmig ist und
vielleicht die spieler auch ein paar ideen mit einbringen duerfen

freya, i.A. fuer janisa

-----------------------------------------------------------------------------



Re: Re: Meinungsbild gefragt. (Seno, 12. Feb 2001, 02:32:19):
~#! rn=Saul rt=981703366 rg=gilden.zauberer
~#! tid=981641202
Ich schliesse mich Sauls Meinung an:

Wenn man eh alles neu machen will, warum dann nicht als neue Gilde ?
Ich finde, das ist eine prima Idee.
Es koennte ja auch 2 Zauberer-Gilden geben :-))

Die alte Gilde einfach wegzuwerfen bedeutet auch einen Verlust, auch wenn
Vieles "verkorkst" ist. Wer sagt uns, dass die neue Gilde nicht auch ihre
Schwaechen haben wird ? Dass es nicht auch wieder ein laengerer Prozess sein
wird, bis sie "eingeschliffen" ist und sich ins gesamte MorgenGrauen
einfuegt ?

Schliesslich ist es so, dass das MorgenGrauen herrlich gross ist und dass es
ne Menge guter Questen und noch vieles Anderes hier gibt. Am meisten Bedarf
fuer Neues besteht meiner Meinung nach bei Gilden. Ich wuensche mir schon
lange z.B. eine Druiden- oder Alchimisten-Gilde und hab mich riesig ueber die
Tanjian gefreut.

Zu dem Begriff "Besitzstandswahrung" moechte ich noch sagen, dass ich den
Begriff an sich schon mal ungluecklich finde. Ich bin mit niedriger Stufe in
die Gilde eingetreten und die Figur hochzuspielen war ZIEMLICH hart. Ausserdem
lehne ich Skripten ab und hab daher tatsaechlich meine Figur komplett von Hand
hochgespielt. Ich fang gerade an, die Fruechte dessen zu ernten, worauf ich
hingespielt hab. Ich finde es sehr wichtig, diese Muehen, die einem in den Weg
gelegt wurden, nicht nochmal ueberwinden zu muessen und haette da wenig Lust
drauf. Ich weiss, dass ich es viel leichter gehabt haette, wenn ich mit
hoeherer Stufe in die Gilde eingetreten waere. Aber ich wollte einfach von
Anfang an nen Zauberer spielen.

Ganz allgemein finde ich Gilden mit hoher Kampfkraft und hohem Uebaufwand
problematisch. Mir persoenlich liegt an Kampfkraft nicht allzu viel und
weniger stupides Ueben (das es einem durchaus nahelegt zu skripten) waere
sicher im Interesse aller.

Zusammenfassend: Grundsaetzlich dafuer.
Seno

-----------------------------------------------------------------------------



artikel Zauberergilde v2.0 (Obermotz, 13. Feb 2001, 12:18:59):
Da wir nun ja alle zugestimmt haben, ein Neuaufbau der Gilde muss sein,
kommen hier mal meine Gedanken.
a) skalierbare Sprueche (kennen wir bereits z.B. beim Feuerball) sollte
   es auch in der neuen Gilde geben

b) genuegend Sprueche, damit man als Zauberer auch noch allein einen
   Gardewaechter plaetten kann (wir sind doch nun mal Individualisten)

c) da es ja auch den Team-Kampf gibt und einige fehlgeleitete Geschoepfe
   sich tatsaechlich mit Chaoten, Trves u.ae. abgeben, sollte auch
   dieser Bereich bedacht werden. Vielleicht wirken die Sprueche aus b)
   im Team-Kampf nicht so effektiv, da man ja andauernd angeremmpelt
   wird oder ein Kleriker gerade mal wieder die Sicht auf den Gegner
   im entscheidenen Moment blockiert.
d) jemand hatte ja auch schon mal vorgeschlagen, dass sich ein Zauberer
   spezialisieren kann. Spezialisierung bedeutet natuerlich, dass der
   entsprechende Zauberer auf dem Gebiet supadupagut ist und als Aus-
   gleich auf einem (oder mehreren) Gebiet(en) grottenschlecht ist. Im
   Laufe seiner Entwicklung wird der Zauberer natuerlich auf seinem
   Spezialgebiet immer besser. Die Balance darf dann wohl entscheiden,
   ob die Nachteile gravierender oder durch gesammelte Erfahrung etwas
   gelindert werden. Gefallen koennte mir auch ein System ala Diablo 2:
   sich die Sprueche ueber Punkte 'kaufen' bzw. durch Punkte zu ver-
   staerken. Fuer hoehere Sprueche muesste man kleinere Sprueche auf
   entsprechenden Level haben (-> Spruchbaum).

e) wenn wir etwas mehr Bums bei einem Spruch benoetigen, ist es doch
   schoen, dass mehrere Zauberer zusammen zaubern koennen. Geruechten
   nach zu urteilen, koennen einige Sprueche sogar nur so eingesetzt
   werden.

f) es duerfte sich bestimmt schwer bis garnicht umsetzen lassen: ein
   "Spruchbaukasten" inklusive Einfuehrungsvideo "Wie bastle ich meinen
   eigenen Mega-Monster-Zap-Spruch". Falls das Punktesystem von d) zum
   Einsatz kommt, kostet so ein Spruch mehr Punkte (das Doppelte?).
   (In irgendeinem aelteren CRPG gab es mal sowas. Ich glaube es war
   Daggerfall)

g) weg mit dem Einheitsbrei! Wir wuerde es gefallen, wenn die Rasse des
   Zauberers einen staerkeren Einfluss haette. Ein Zwerg koennte sich
   z.B. nicht auf Hellsicht spezialisieren (was will er auch schon von
   da unten durch seinen Bart sehen? ;-) ). Oder einge Sprueche stehen
   nur einer bestimmten Rasse offen bzw. die Spruchkosten dafuer
   varieren.

h) Komponenten gehoeren abgeschafft oder an OM gespendet! Natuerlich
   nicht wirklich. Was haltet Ihr davon, wenn es die Komponenten in
   verschiedenen Qualitaetsstufen gibt? Je besser die Qualitaet um so
   besser kann ein Spruch gelingen oder um so laenger haelt die Kompo-
   nente. Ich koennte mir auch vorstellen, das die Kompos in ihrem Roh-
   zustand fuers Zaubern unbrauchbar sind. Erst durch die sorgfaeltige
   Vorbereitung der Komponenten koennen sie fuer einen Spruch benutzt
   werden.

i) hm, ja, Gildenfeeling. Brauchen wir wirklich sowas? Es reicht doch
   wenn wir alles plattmachen koennen! Obwohl, es wird dann bestimmt
   den einen oder den anderen geben, der sich dann nicht in einem von
   Feuerbaellen geschwaerzten und ausgebrannten Gildenhaus wohlfuehlt.

Da ich das j im Alfabet (Schreibt man das jetzt nach der neuen Recht-
schreibung so?) noch nicht gelernt habe, kann ich leider auch nichts
mehr zum Thema Ausbildung schreiben.


OM klappert mit der Magisterguertel und haelt das "Kompo-Spenden fuer
Obermotz"-Schild hoch

PS:  Und noch mal ganz deutlich: einge ueberspitzte Meinungen sind
     bitte mit einem kleinen Schmunzeln zu versehen.
PPS: Habt Ihr wirklich alles bis hier her gelesen? Ihr habt wohl nichts
     besseres zu tun!?

-----------------------------------------------------------------------------



Re: artikel Zauberergilde v2.0 (Birdy, 13. Feb 2001, 14:11:31):
~#! rn=Obermotz rt=982063139 rg=gilden.zauberer
~#! tid=982063139
Hiho !

Oha ! Das war ja starker Tobak !
Darueber muss man erstmal in aller Ruhe nachdenken.

Ich habe aber eine Frage an Dich, ist dein Artikel zur Diskussion freigegeben
oder willst du unsa das nur  zeigen und Silvanas Kommentar dazu abwarten ? Das
wuerde uns vielleicht einige unnuetze Diskussionen ersparen. Wer weiss,
vielleicht ist das alles schon so geplant ? Ich ahbe da vollstes Vertrauen in
unsere Gildenmagier.

Gruss
Birdy
*nichts wird so heiss gegessen, wie es gekocht wird*

-----------------------------------------------------------------------------



Re: Re: artikel Zauberergilde v2.0 (Obermotz, 13. Feb 2001, 14:15:30):
~#! rn=Birdy rt=982069891 rg=gilden.zauberer
~#! tid=982063139
Es darf natuerlich nur in einer Richtung diskutiert werden: mir recht geben
;-).

Es sind einfach so meine Gedanken/Ideen fuer die neue Gilde. Dazu
darf natuerlich jeder seine Meinung sagen. Ob und was unsere 
Magier davon umsetzen wird sich zeigen. Vielleicht landet die
eine oder andere Idee ja auch in einer ganz anderen Gilde.

OM, der immer Kompos braucht

-----------------------------------------------------------------------------



Re^3: artikel Zauberergilde v2.0 (Silvana, 13. Feb 2001, 18:37:12):
~#! rn=Obermotz rt=982070130 rg=gilden.zauberer
~#! tid=982063139
> PPS: Habt Ihr wirklich alles bis hier her gelesen? Ihr habt wohl 
> nichts besseres zu tun!?

Schon, aber ich kann ja nicht jeden Tag alles in dieser Rubrik uebergehen. ;-)

Danke, Obermotz, ich hab herzlich gelacht. :) Das mit dem "Komponenten spenden
fuer Obermotz" werden wir bestimmt eingebaut bekommen. Ob ihr von Feuerbaellen
geschwaerzte Raeume wirklich wollt, wenn Ark die programmiert, wage ich etwas
zu bezeifeln, aber meinetwegen... Ark, das hier kannst Du als eine weiter
Genehmigung betrachten. Sie haben es so gewollt. ;-)

Was den Rest angeht: Obermotz, Du denkst immer noch in viel zu kleinem Rahmen.
Think big! Mehr sag ich dazu derzeit nicht. Nachtwind hat durch seine Position
ja das Vorrecht, als erster den Herzkasper wegen des neuen Konzepts zu
bekommen. ;-)

  Silvana

-----------------------------------------------------------------------------



Re^4: artikel Zauberergilde v2.0 (Wurzel, 13. Feb 2001, 19:08:13):
~#! rn=Silvana rt=982085832 rg=gilden.zauberer
~#! tid=982063139
ein punkt ist mir irgendwie haengengeblieben... genauer gesagt, "punkte", um
sich sprueche zu kaufen. das erinnert mich irgendwie an die dritte auflage von
ad&d, wo man neuerdings xp als eine komponente fuer den einen oder anderen
spell braucht. koennte man sicher auch hier zu einem interessanten konzept
machen. je mehr xp man einsetzt, desto staerker wird der spruch... und es ist
auf jeden fall eine limitierte ressource :)

wurzel

-----------------------------------------------------------------------------



Re^5: artikel Zauberergilde v2.0 (Anacrion, 13. Feb 2001, 19:09:51):
~#! rn=Wurzel rt=982087693 rg=gilden.zauberer
~#! tid=982063139
Das fuehrt aber dazu, dass man durch Vielmetzeln ueberpropoprtional stark
werden kann.

Anac* meint: wenn, dann mit einer ressource, die fuer alle gleich vorhanden
ist - geal ob metzler oder pfluecker

-----------------------------------------------------------------------------



Re^6: artikel Zauberergilde v2.0 (Wurzel, 13. Feb 2001, 19:12:07):
~#! rn=Anacrion rt=982087791 rg=gilden.zauberer
~#! tid=982063139
nicht, wenn man die xp genau fuer die heftigen metzelsprueche braucht.
das reguliert sich dann schon von allein :)

wurzel

-----------------------------------------------------------------------------



Re^7: artikel Zauberergilde v2.0 (Anacrion, 13. Feb 2001, 19:12:57):
~#! rn=Wurzel rt=982087927 rg=gilden.zauberer
~#! tid=982063139
Im Gegenteil. Ist eher exponentiell wuerde ich sagen.

Anac*

-----------------------------------------------------------------------------



Re^8: artikel Zauberergilde v2.0 (Tiamak, 13. Feb 2001, 19:13:33):
~#! rn=Anacrion rt=982087977 rg=gilden.zauberer
~#! tid=982063139
Ohne Zahlenwerte zu kennen?

Tiamak

-----------------------------------------------------------------------------



Re^9: artikel Zauberergilde v2.0 (Silvana, 13. Feb 2001, 19:14:03):
~#! rn=Tiamak rt=982088013 rg=gilden.zauberer
~#! tid=982063139
Ohne ueberhaupt das Konzept zu kennen? ;-)
  Silvana

-----------------------------------------------------------------------------



Re^10: artikel Zauberergilde v2.0 (Tiamak, 13. Feb 2001, 19:14:26):
~#! rn=Silvana rt=982088043 rg=gilden.zauberer
~#! tid=982063139
Jetzt komm doch bitte nicht mit solch stoerenden Kleinigkeiten an.

Tiamak. :-)

-----------------------------------------------------------------------------



Re^8: artikel Zauberergilde v2.0 (Wurzel, 13. Feb 2001, 19:14:28):
~#! rn=Anacrion rt=982087977 rg=gilden.zauberer
~#! tid=982063139
hm. seh ich nicht so, beim besten willen nicht.
erstmal 100 gardewaechter umnieten, bis man genug fuer einen drachengott
beisammen hat... die punkte sollten ja dann wohl wieder weg sein.

wurzel

-----------------------------------------------------------------------------



Re^10: artikel Zauberergilde v2.0 (Anacrion, 13. Feb 2001, 19:15:50):
~#! rn=Silvana rt=982088043 rg=gilden.zauberer
~#! tid=982063139
Ja. Einfache logik. Wenn Du Xp zum kaufen eines Spruches verlangst, wird er
bei denen staerker sein, die mehr metzeln (da sie mehr XP kriegen). Damit
haben sie den naechsten Spruch besser und kriegen noch mehr Xp .... usw. usf.

Ausgehend von den Informatiopnen, die Wurzel gibt, Nein icjh kenne das Konept
nicht.

Anac*

-----------------------------------------------------------------------------



Re^11: artikel Zauberergilde v2.0 (Wurzel, 13. Feb 2001, 19:16:24):
~#! rn=Anacrion rt=982088150 rg=gilden.zauberer
~#! tid=982063139
das sind keine informationen. ich kenne das konzept so wenig wie du.

-----------------------------------------------------------------------------



Re^11: artikel Zauberergilde v2.0 (Gloinson, 13. Feb 2001, 19:25:27):
~#! rn=Anacrion rt=982088150 rg=gilden.zauberer
~#! tid=982063139
Und ausgehend von den Informationen, die Du Dir zusammenreimst. Schomma was
von Logarithmisch gehoert? Ausserdem hab ich das nur als Gedanken verstanden,
nicht als ausgereiftes vorgeschlagenes Konzept.

gloin(son)

-----------------------------------------------------------------------------



Re^12: artikel Zauberergilde v2.0 (Anacrion, 13. Feb 2001, 19:26:23):
~#! rn=Wurzel rt=982088184 rg=gilden.zauberer
~#! tid=982063139
Nach kurzer Diskussion mit Wurzel. 

ANGENOMMEN, die XP-Kosten fuer den Srpcuh sind so hoch, dass es keine Spirale
gibt ... dann heisst das nur noch, dass man XP-Stupse in gewissem Masse in
Kill-Stupse umsetzt. Was wiederum heisst, dass man unempfindlicher gegen den
XP-Verlust beimn Tod wird.

Anac*

-----------------------------------------------------------------------------



Re^13: artikel Zauberergilde v2.0 (Wurzel, 13. Feb 2001, 21:19:49):
~#! rn=Anacrion rt=982088783 rg=gilden.zauberer
~#! tid=982063139
war wohl _zu_ kurz, die diskussion.

wurzel

-----------------------------------------------------------------------------



Re^14: artikel Zauberergilde v2.0 (Silvana, 13. Feb 2001, 21:54:07):
~#! rn=Wurzel rt=982095589 rg=gilden.zauberer
~#! tid=982063139
Und aus (fuer mich) offensichtlichen Gruenden ziemlich sinnfrei. ;-)

  Silvana

-----------------------------------------------------------------------------



Re^15: artikel Zauberergilde v2.0 (Wurzel, 13. Feb 2001, 21:54:40):
~#! rn=Silvana rt=982097647 rg=gilden.zauberer
~#! tid=982063139
eben deswegen war sie ja auch kurz :)

-----------------------------------------------------------------------------



Re^6: artikel Zauberergilde v2.0 (Solmyr, 14. Feb 2001, 01:33:18):
~#! rn=Anacrion rt=982087791 rg=gilden.zauberer
~#! tid=982063139
Hmm, schon mal was von oberes Limit gehoert, Anac*?

Solmyr

-----------------------------------------------------------------------------



Re^7: artikel Zauberergilde v2.0 (Cormak, 14. Feb 2001, 08:15:10):
~#! rn=Solmyr rt=982110798 rg=gilden.zauberer
~#! tid=982063139
Zum Thema Spells mit XP kaufen:
Kennt Ihr Earthdawn? IMHO eines der besten Pen&Paper-Fantasy-RPGs, leider von
FASA eingestellt. Darin steigert man Attribute/Faehigkeiten auch mit XP, aber
in einer Fibonacci-Reihe, also: Stufe 1: 100 XP, Stufe 2 200 XP, Stufe 300 XP,
St. 4 500, dann 800, 1300, 2100 usw. Irgendwann werden die Kosten so
astronomisch, dass es sich nicht mehr rentiert, noch mal zu steigern.
Natuerlich sollte auch weiterhin ein Spieler-lvl- oder Gilden-lvl-orientierter
Maximalwert existieren.

Cormak, in ED Cavalier im 5. Kreis, Lichttraeger im 7. Rang

-----------------------------------------------------------------------------



Re^8: artikel Zauberergilde v2.0 (Gloinson, 14. Feb 2001, 08:45:38):
~#! rn=Cormak rt=982134910 rg=gilden.zauberer
~#! tid=982063139
Ansonsten wird Ryne Zauberer und brennt einmalig ein Loch durch ganz
Morgengrauen bis in die Magierwelt.

Gloin(son), sinnfrei

-----------------------------------------------------------------------------



Re^8: artikel Zauberergilde v2.0 (Elendil, 14. Feb 2001, 10:27:52):
~#! rn=Cormak rt=982134910 rg=gilden.zauberer
~#! tid=982063139
Wah, bitte keine Fibonaccizahlen in der ZGilde :)
Die orientieren sich an der Natur, z.B. Anzahl der Blaetter einer
Sonnenblume. Nicht genug, dass es tatsaechliche Personen gibt die
damit Boersenkurse berechnen wollen und bei der Teleboerse auftreten,
nein jetzt sollen die Zauberer dem folgen :) Klares Nein aus Prinzip :)

Elendil der kleine Zauberer :)

-----------------------------------------------------------------------------



Zauberer und Punkte? (Silvana, 14. Feb 2001, 10:41:22):
Salve

Um der Diskussion mal den Boden unter den Fuessen wegzuziehen:
Etwas, das fuer mich ein absoluter Stimmungskiller in der alten Gilde war/ist,
sind die sichtbaren Punkte. Will heissen: "Du musst noch xzy
Gildenquest-Punkte erreichen, bevor Du diesundjenes tun darfst!" ist sehr
technisch und hat null Stimmung. "Du willst den Feuerball lernen? Schoen, aber
so wenig wie die von Feuer verstehst, wird das nicht. Ich mach Dir nen
Vorschlag: Ich haette da eine Vorschungsmission in Feuerebene der SSP. Da
wirst Du sicher einiges ueber Feuer lernen. Danach koennen wir uns ueber den
Feuerball unterhalten." klingt schon viel besser, oder?
Wie das ganze dann technisch aussieht, ist eine ganz andere Frage.
Schliesslich muss es programmiert werden, also wird es sich letztendlich wohl
irgendwie in Form von Zahlen und Bits ausdruecken lassen. Aber als Spieler
sollte man keine konkreten Zahlen mehr sehen. Umschreibungen, ja. Zahlen,
nein.

  Silvana

-----------------------------------------------------------------------------



Re: Zauberer und Punkte? (Obermotz, 14. Feb 2001, 11:33:06):
~#! rn=Silvana rt=982143682 rg=gilden.zauberer
~#! tid=982143682
Und wenn ich nun Fakten, Fakten, Fakten haben will?

OM geht mal schnell zum Kiosk und holt sich eine Zeitschrift mit F*
-> schmarrn

-----------------------------------------------------------------------------



Re: Re: Zauberer und Punkte? (Agony, 14. Feb 2001, 11:55:55):
~#! rn=Obermotz rt=982146786 rg=gilden.zauberer
~#! tid=982143682
zeitung mit F* ? schaem dich...pfui :)

-----------------------------------------------------------------------------



Re: Zauberer und Punkte? (Cormak, 14. Feb 2001, 14:09:52):
~#! rn=Silvana rt=982143682 rg=gilden.zauberer
~#! tid=982143682
Hallo mal wieder!

Das EarthDawn-System sollte ja nur ein Beispiel sein, wie man diese eventuell
zum Steigern benoetigten Punkte staffeln kann. ED ist ein Pen&Paper -System
und nutzt daher klare Zahlen, die wir hier im MG ja verbergen koennen: Eine
Meldung, wie die beim erhoehen der Spielerstufe tuts ja auch.

Cormak, sich auf die naechste ED-Sitzung freuend


-----------------------------------------------------------------------------



Re^9: artikel Zauberergilde v2.0 (Strohalm, 14. Feb 2001, 15:45:33):
~#! rn=Wurzel rt=982088068 rg=gilden.zauberer
~#! tid=982063139
100 gardewaechter metzeln und dann mit den exp einen Drachengott oder
Nekromanten weghaun mit einem Spell? na ich weiss net, die armen Gardies ;)

Haelmchen, sammelt schonmal Gardies ;)

-----------------------------------------------------------------------------



hmbl (Vector, 14. Feb 2001, 15:50:22):
Moin,

erstmal sei gesagt, dass ich mit Absicht auf keinen Artikel antworte, ich
will es Silvana ja nicht zu einfach machen mit Artikel ignorieren:-)

Zur Sache:
Sicher ist es lobenswert, der Zaubergilde ein neues Gesicht plus neue 
Struktur geben zu wollen. Ich als noergelnder Spieler allerdings sehe
natuerlich erstmal die Nachteile, die ich von so einer Aenderung habe.

Alle Spells neu lernen? Ich glaubs ja nicht, warum nicht gleich bei
allen Zauberern die Spielerlevel auf Null setzen, schliesslich wurde
diese mit den alten Spells erreicht.
Wenn ihr wirklich so viel aendern wollt, warum nicht gleich eine
neue Gilde schaffen (wurde glaube ich auch schon vorgeschlagen), die
dann neben der Zaubi-gilde existiert? Das Morgengrauen ist mittlerweile
imho gross genug fuer 2 Gilden dieser Art. (z.b. koenntet ihr die Untoten
proggen, oder die Piraten wiederbeleben...)
Noch viel mehr jedoch wundert mich, dass fast alle Betroffenen (jedenfalls
die, die sich in der mpa dazu aeussern) fuer ein Neu-lernen der Spells sind.
Also entweder habt ihr alle noch Voll-uebe-scripte in alten tf-dateien 
liegen, oder ich habe damals beim Ueben so ziemlich alles falsch gemacht.
Mich hat das Spell-maxen extrem viel Zeit und Nerven gekostet, und ich werde
sicher nicht die Spells nochmal ueben.
Ich denke, die meisten Zaubis sind der (falschen) Meinung, dass die ueber-
arbeiteten Spells staerker werden, als die derzeit vorhandenen.
Desweiteren ist ja schon durchgesickert, dass es in der neuen Gilde wohl
keine 'hand' mehr geben wird. Auch dieses halte ich fuer den falschen Weg.
Sicher ist die derzeitige Kompo-Hand ueberarbeitungswuerdig, aber ich sehe
die Zauberer-hand als (guten) Kontrast zum allgemeinen Waffenkampf etwa der
Kaempfer, Tanijan, Chaoten....
Wie wird das dann in Zukunft aussehen? A la Diablo II? Zauberer die mit
Kampfstoecken und Zauberstab den Monstern auf die Muetze geben? *brrr*

OK, ich weiss so ne Gildenneuschreibung dauert Jahre, und wird dann wohl
gleichzeitig mit Taramis angeschlossen, aber wenn die Zaubis wirklich neu
anfangen muessen, Spells zu ueben, gehe ich am selben Tag zu den Kaempfern
(Anatol darf diesen Satz in seinem mpa-archiv ablegen:-) )

Jo, ich weiss, das ist keine Drohung, nur meine Meinung (war ja nach nem
Stimmungsbild gefragt)
Den einzigen positiven Punkt den ich in so einem Neu-anfang sehe, ist,
dass dann die ganzen Bug-charaktere, die sich mal eben so in nem NO_MAGIC
Raum gemaxt haben, verschwinden.

Trotzdem: Contra

--Vector--


-----------------------------------------------------------------------------



Re: hmbl (Liara, 14. Feb 2001, 16:53:29):
~#! rn=Vector rt=982162222 rg=gilden.zauberer
~#! tid=982162222
Vor Dir lass ich mir nicht unterstellen, dass ich die Gildenumwandlung wegen
staerkerer Spells will. Und diese Bemerkung, dass Du lange Zeit gebraucht hast
(und viel Muehe *waelz*), um irgendwas zu maxen, ist voellig absurd.
Was Du da von Dir gibst, zeigt nur mal wieder, dass Du den Boden unter Deinen
Fuessen laengst voellig verloren hast ... konstruktive Kritik haette gereicht.

LZ, hat sich 2 Jahre Zeit gelassen, um die normalen Sprueche zu ueben ...

-----------------------------------------------------------------------------



Re: hmbl (Montanus, 14. Feb 2001, 17:11:09):
~#! rn=Vector rt=982162222 rg=gilden.zauberer
~#! tid=982162222
Ich kann Dir sagen, warum zwei Zauberergilden nix werden:
kannst Du Dir ein zweites Taramis vorstellen? Ueberleg doch mal, wie gross das
Mud dann wuerde. :-)
(Obwohl ich ja die Idee zweier konkurrierender Zauberergilden mit evtl
konkurrierenden GIldenmags gar nicht so schlecht finde...)

JMHO

Montanus

-----------------------------------------------------------------------------



Re: hmbl (Elendil, 14. Feb 2001, 18:12:42):
~#! rn=Vector rt=982162222 rg=gilden.zauberer
~#! tid=982162222
Hi zusammen,

das neue System von weiter unten zu beginnen halte ich fuer sinnvoll
weil ich bevor ich wieder Zauberer wurde (nach dem Dunkelelf) oft
gefragt wurde wie sich bestimmte Dinge ueben lassen und meine einzige
Antwort aus Erfahrungen anderer bestand oder ich darauf hinweisen
musste, nach dem System nie gelernt zu haben. Ein guter Zauberer
sollte wissen wie sich Gildenfaehigkeiten ueben lassen und das lernt
man am besten mit : learning by doing ;) Ausserdem hat es Spass gemacht
nochmal den Weg in der Gilde zu gehen. Wuenschen sich nicht viele
langjaehrige Mudder nochmal von vorne anzufangen ohne auch nur einen
Schimmer von einem plan zu haben in einer Gilde ? Ich finds toll :)

Elendil spricht nur fuer sich :)

-----------------------------------------------------------------------------



Re: Re: hmbl (Gor, 14. Feb 2001, 18:16:55):
~#! rn=Elendil rt=982170762 rg=gilden.zauberer
~#! tid=982162222
Jo, finde ich auch nicht schlecht. Zumal die Meisten, die sich dazu geaeussert
haben irgendwoe einen Level erreicht haben, wo man sich langsam fragt: 'was
mach ich denn heute abend?'

Gor hat den Artikel nicht geschrieben, nein nein!

-----------------------------------------------------------------------------



Re^3: hmbl (Kaspar, 14. Feb 2001, 18:18:59):
~#! rn=Gor rt=982171015 rg=gilden.zauberer
~#! tid=982162222
Genau, warum nicht alle Gilden alle 2 Jahre Skill-maessig auf Null zurueck-
setzen?! Nicht das die Spieler die Lust verlieren oder nicht mehr wissen,
was sie tun sollen.
Haettest du wirklich Lust, deinen Kaempfer von vorne hochzuspielen?
Entschuldigt meinen Sarkasmus.

-----------------------------------------------------------------------------



Re^3: hmbl (Montanus, 14. Feb 2001, 18:20:05):
~#! rn=Gor rt=982171015 rg=gilden.zauberer
~#! tid=982162222
Wenn man sich fragt 'Was mach ich denn heute abend' sollte eigentlich immer
die Antwort "Nicht mudden" sein. Unabhaengig vom Level.

-----------------------------------------------------------------------------



Re^4: hmbl (Sahadoom, 14. Feb 2001, 18:20:37):
~#! rn=Kaspar rt=982171139 rg=gilden.zauberer
~#! tid=982162222
Hmm, alle Gilden alle 2 Jahre Skill-maessig.. blablablabla.
Hier gehts meiner Meinung nach um ein einmaliges Projekt. Hat also damit -
finde ich - gar nix zu tun.

Saha, senfend.

-----------------------------------------------------------------------------



Re^5: hmbl (Kaspar, 14. Feb 2001, 18:21:31):
~#! rn=Sahadoom rt=982171237 rg=gilden.zauberer
~#! tid=982162222

[] Du kennst den begriff 'Sarkasmus'

-----------------------------------------------------------------------------



Re^4: hmbl (Gor, 14. Feb 2001, 18:21:44):
~#! rn=Kaspar rt=982171139 rg=gilden.zauberer
~#! tid=982162222
Wenn ich mehr Zeit haette auf alle Faelle. Es gibt da naemlich etliche Sachen,
die ich mir aus Faulheit nicht genau angeschaut habe oder einfach nur
uebersehen habe. Fuer Gelegenheitsmetzler (Rentner) is das sicherlich hart und
nicht wuenschenswert. Naja, geht mich ja nix an. :)

Gor

-----------------------------------------------------------------------------



Re^6: hmbl (Strohalm, 14. Feb 2001, 18:26:16):
~#! rn=Kaspar rt=982171291 rg=gilden.zauberer
~#! tid=982162222
Also biste doch dafuer?

-----------------------------------------------------------------------------



Re^7: hmbl (Matis, 14. Feb 2001, 18:27:30):
~#! rn=Strohalm rt=982171576 rg=gilden.zauberer
~#! tid=982162222
Soweit ich das als fast Aussenstehender beurteilen kann, wird die
neue Zauberergilde nur noch sehr wenig mit der alten Gilde gemein 
haben. Da stellt sich natuerlich die Frage,ob man dies den Gilden-
mitgliedern in Form von (fast) kompletten Neulernen aufzwingen kann/
sollte, oder ob nicht doch eine neue Gilde der konsequentere Schritt
waere.

Matis

PS Ich mag Ueben ueberhaupt nicht. In allen getesteten Gilden artete 
   das frueher oder spaeter in stupiden Wiederholungen aus.

-----------------------------------------------------------------------------



Re^8: hmbl (Linflas, 14. Feb 2001, 18:29:30):
~#! rn=Matis rt=982171650 rg=gilden.zauberer
~#! tid=982162222
Ich schlage einfach mal vor, erst das Konzept welches Silvana vorlegen wird,
abzuwarten und dann zu diskutieren. Brotlose Kunst gib es schon genug.

Linflas, muht, will Kuhe und jammert sowieso nur rum.

-----------------------------------------------------------------------------



Re^9: hmbl (Silvana, 14. Feb 2001, 18:36:01):
~#! rn=Linflas rt=982171770 rg=gilden.zauberer
~#! tid=982162222
Gute Idee, das. :) Und der erste, der das Konzept zu sehen bekommt (abgesehen
von Patryn und Ark natuerlich) ist Nachtwind. Erst wenn der sich von seinem
Herzkasper erholt hat, gibt es ein paar Infos mehr dazu. Wie detailiert die
dann sind, ist ne ganz andere Frage...

  Silvana

-----------------------------------------------------------------------------



Re: hmbl (Anatol, 14. Feb 2001, 18:39:12):
~#! rn=Vector rt=982162222 rg=gilden.zauberer
~#! tid=982162222
Ich habe nicht den Eindruck, dass Du, Vector, der Zauberei wegen in der
Zauberergilde bist. Moeglicherweise ist das eine Eigenschaft, die andere
haben und dazu bewegt, die Ueberei nochmals auf sich zu nehmen - wenn sie
dafuer mehr darstellen als nur kampfstarke Schnellfeuerkarateka. Etwas,
das _Dich_ nie gestoert hat.

Anatol

-----------------------------------------------------------------------------



Re: Re: hmbl (Kaspar, 14. Feb 2001, 18:43:09):
~#! rn=Anatol rt=982172352 rg=gilden.zauberer
~#! tid=982162222
_Meine_ Zaubi-faehigkeiten gehen ueber Schnell-handfeuer-Schmerzen
hinaus. Richtig ist, dass bei mir Primaer die Staerke der Gilde im
Vordergrund steht. Ist das schlimm? Ah stimmt, Du wurdst ja Zauberer,
Anatol weil du zaubern wolltest. Bei mir war es nicht anders. Als
ich Zauberer wurde, kannte ich das MG zu wenig, um einen Ueberblick
ueber die Gilden zu haben...
Nach was soll man seine Gildenwahl denn treffen? Nach dem Gildenfeeling?
Dann waeren hier alle trves oder chaoten. Und jeder Mudder wird das
nach der Staerke machen. Die anderen sind fuer mich keine mudder sondern
Chatter.

--Vector--

-----------------------------------------------------------------------------



Re^3: hmbl (Kaspar, 14. Feb 2001, 18:45:47):
~#! rn=Kaspar rt=982172589 rg=gilden.zauberer
~#! tid=982162222
... um noch was konstruktives nachzuschieben:

wenn du meinen artikel richtig gelesen haettest, anatol, waere dir 
nicht entgangen, dass mir die derzeitige hand-situation ebenfalls nicht
gefaellt. hier muss man sich hinsetzen und ueber alternativen nachdenken.
abschaffen der hand hingegen halte ich fuer falsch, weil der handkampf
wie schon erwaehnt einen (notwendigen) gegensatz zum sonst vorherrschenden
waffenkampf bildet

-----------------------------------------------------------------------------



Re^4: hmbl (Gor, 14. Feb 2001, 18:47:48):
~#! rn=Kaspar rt=982172747 rg=gilden.zauberer
~#! tid=982162222
Vielleicht ist nach der Umstellung Handkampf gar nimmer noetig? Aber warum
sich den Kopf ueber ungelegt Eier zerbrechen? Achja, noch eines.
       Jede Gilde stellt fuer sich was dar und hat es nicht noetig
       mit einer anderen verglichen zu werden.

-----------------------------------------------------------------------------



Re^3: hmbl (Tiamak, 14. Feb 2001, 18:49:32):
~#! rn=Kaspar rt=982172589 rg=gilden.zauberer
~#! tid=982162222
Bei der Definition wuerde mich mal brennend interessieren, wie hier das
Verhaeltnis von "Muddern" zu "Chattern" aussieht im MG.

Und mich wuerde es nicht wirklich wundern, wenn bei einer 'Volkszaehlung'
heraus kaeme, dass Vector der einzig wahre Mudder ist.


Tiamak

-----------------------------------------------------------------------------



Re^5: hmbl (Vardion, 14. Feb 2001, 18:49:34):
~#! rn=Gor rt=982172868 rg=gilden.zauberer
~#! tid=982162222
Hmm - interessant, dass gerade Du das sagst, wo man doch als Zaubi zumindest
mit Gildemitteln Deinen Stein ohne Hand nichtmal kitzeln kann...

Vardion meint: Hand ist an verschiedenen Stellen eine absolute Notwendigkeit

-----------------------------------------------------------------------------



Re^5: hmbl (Kaspar, 14. Feb 2001, 18:49:40):
~#! rn=Gor rt=982172868 rg=gilden.zauberer
~#! tid=982162222
solange es in ein und demselben mud mehr als eine gilde gibt,
hat es jede gilde nicht nur noetig, nein sogar die pflicht sich
mit den anderen gilden zu verleichen, stichwort balance, spielfeeling,
verhaeltnismaessigkeit (nettes wort oder?)

-----------------------------------------------------------------------------



Re^6: hmbl (Gor, 14. Feb 2001, 18:50:44):
~#! rn=Vardion rt=982172974 rg=gilden.zauberer
~#! tid=982162222
Ich kenn mich ja bei Zaubern nicht aus, aber sowas wie nen Feuerball
(Abenteuer koennen sowas sogar) werdet ihr wohl sonst auch noch auf dem Kasten
haben oder?

-----------------------------------------------------------------------------



Re^7: hmbl (Vardion, 14. Feb 2001, 18:51:22):
~#! rn=Gor rt=982173044 rg=gilden.zauberer
~#! tid=982162222
Klar - nuetzt nur nix, wenn die per Spelldefend zu 99% abgewehrt werden.

Vardion

-----------------------------------------------------------------------------



Re^8: hmbl (Kaspar, 14. Feb 2001, 18:52:09):
~#! rn=Vardion rt=982173082 rg=gilden.zauberer
~#! tid=982162222
ich warte jetzt auf den kommentar aus der vor-95er-ecke: 
frueher gings auch ohne hand :)

-----------------------------------------------------------------------------



Re^8: hmbl (Agony, 14. Feb 2001, 18:53:01):
~#! rn=Vardion rt=982173082 rg=gilden.zauberer
~#! tid=982162222
also frueher war alles besser...da haben wir bei sowas immer eine
kombination aus hoellenfeuer, mjoelnir, robins pfeilen und wurfsternen
benutzt: dass spaeter hand ausweichmittel nr. 1 wurde, liegt wohl
nicht zuletzt am zusammenstreichen diverser anderer moeglichkeiten.

-----------------------------------------------------------------------------



Re^8: hmbl (Montanus, 14. Feb 2001, 18:53:03):
~#! rn=Vardion rt=982173082 rg=gilden.zauberer
~#! tid=982162222

Koennt ihr bitte mal aufhoeren hier? Das hier ist gilden.zauberer, nicht
gilden.dingdong. Bitte postet diese ueberfluessigen 'ich bin ein besserer
Mudder als Du" - Diskussionen doch dort.

-Montanus (als Urlaubsvertretung von Grimmborn)

-----------------------------------------------------------------------------



Re^9: hmbl (Linflas, 14. Feb 2001, 18:55:03):
~#! rn=Montanus rt=982173183 rg=gilden.zauberer
~#! tid=982162222
William Shakespeare,

"Viel Laerm um nichts"

ca. 16 Jh. nach Christi Geburt.

Linflas hat kein Popcorn.

-----------------------------------------------------------------------------



Re^10: hmbl (Kaspar, 14. Feb 2001, 18:55:47):
~#! rn=Linflas rt=982173303 rg=gilden.zauberer
~#! tid=982162222
genau, bis die gilde in der neuen form angeschlossen wird
spielt von den jetzt aktiven zauberern eh keine mehr....
ok ausser anatol natuerlich:)

-----------------------------------------------------------------------------



Re^3: hmbl (Panic, 14. Feb 2001, 18:57:24):
~#! rn=Kaspar rt=982172589 rg=gilden.zauberer
~#! tid=982162222
Du hast was vergessen: Chatten ist UNEFFEKTIV! 

nunja, /irony off

-----------------------------------------------------------------------------



Re^4: hmbl (Gnome, 15. Feb 2001, 00:36:25):
~#! rn=Tiamak rt=982172972 rg=gilden.zauberer
~#! tid=982162222
vielleicht ist vector der einzig wahre mudder, aber bestimmt nicht der
einzige, der bei der volkszaehlung herauskaeme...
chatten? das ist doch das, was die im IRC machen, oder?

gnOme

-----------------------------------------------------------------------------



Re^5: hmbl (Sky, 15. Feb 2001, 00:37:49):
~#! rn=Gnome rt=982193785 rg=gilden.zauberer
~#! tid=982162222
:nickt Gnome zu.

-----------------------------------------------------------------------------



Re^5: hmbl (Elberet, 15. Feb 2001, 00:40:15):
~#! rn=Gnome rt=982193785 rg=gilden.zauberer
~#! tid=982162222
Also ich weiss gar nciht was ihr habt. Silvana hat nach Meinung gefragt, und
die haben jetzt ziemlich viele abgegeben inzwischen. Aber was ich gesehen hab,
gibt es doch eine deutliche Mehrheit fuer die von Silvana vorgeschlagenen
Aenderungen. Dass auch einige dagegen sind war doch klar, aber eigentlich ist
das Meinungsbild zumindest in der mpa ziemlich deutlich ausgefallen, auch wenn
die Artikel derjenigen, die dagegen waren laenger waren als derjenigen die
dafuer waren. Aber das ist irrelevant fuer ein Meinungsbild.

Elbi 

-----------------------------------------------------------------------------



Re^6: hmbl (Agony, 15. Feb 2001, 00:44:00):
~#! rn=Elberet rt=982194015 rg=gilden.zauberer
~#! tid=982162222
na ja...es ist halt ihre meinung.
nehmen wir an, wir sind im jahre 2042 und ihr macht einen touristikausflug
zum mars, euer gleiter stuerzt ab, 15 mann ueberleben.
10 mann entscheiden, die lage sei zu hoffnungslos, also wird man selbstmord
begehen. die restlichen 5 sind jetzt tatsaechlich dazu verpflichtet,
selbiges zu tun?! ;)

-----------------------------------------------------------------------------



Re^7: hmbl (Elberet, 15. Feb 2001, 00:46:24):
~#! rn=Agony rt=982194240 rg=gilden.zauberer
~#! tid=982162222
Darum gehts doch nciht, ich hab ja nicht gesagt, sdass sie ihre Meinung nicht
aeussern sollen. Aber nur weil einer denkt, er sollte Selbstmord machen,
muessen das die anderen nicht tun, oder? Das faend ich den besseren Vergleich

-----------------------------------------------------------------------------



Re: Re: hmbl (Seno, 15. Feb 2001, 04:22:06):
~#! rn=Montanus rt=982167069 rg=gilden.zauberer
~#! tid=982162222
Man muesste doch nicht extra eine Stadt errichten fuer eine 2. Zauberergilde ?
Ich kann mir gut vorstellen, dass es in Taramis eine alte und eine neue
Akademie geben koennte :-)
Wenn sich die alte eruebrigt, weil die neue tatsaechlich viel besser und die
alte ueberholt ist, kann man die alte immer noch einreissen.

Seno.

-----------------------------------------------------------------------------



Re^4: hmbl (Seno, 15. Feb 2001, 04:42:04):
~#! rn=Tiamak rt=982172972 rg=gilden.zauberer
~#! tid=982162222
Ganz offensichtlich gibt es leider noch diverse andere "wahre Mudder". Den
Preis fuer deren "effektive" Spielweise zahlen andere.

Ich wuenschte, Du haettest Recht,
Seno.

-----------------------------------------------------------------------------



Re^3: hmbl (Anacrion, 15. Feb 2001, 05:02:58):
~#! rn=Seno rt=982207326 rg=gilden.zauberer
~#! tid=982162222
Erstmal eine Stadt schreiben, bevor man ueber ne zweite nachdenkt ..


Anac* - ist dafuer Seno biszum Anschluss von Taramis zu spielpausen ;).

-----------------------------------------------------------------------------



Re^4: hmbl (Seno, 15. Feb 2001, 06:47:00):
~#! rn=Anacrion rt=982209778 rg=gilden.zauberer
~#! tid=982162222
Erstmal richtig lesen, bevor man antwortet ...
Genau das hab ich geschrieben, naemlich dass man wegen ner 2. Zauberergilde
nicht ueber ne 2. Stadt nachdenken muss. Ich bezog mich dabei auf den Artikel
von Montanus (sag ich einfach noch mal, obwohl es im Kopf des Artikels steht).

Seno

-----------------------------------------------------------------------------



Ach du gruene Neune (Apollonia, 15. Feb 2001, 09:42:54):
Sagt mal, meint ihr nicht, dass die Diskussion hier ein _bisschen_ aus dem
Ruder laeuft? Zum einen ist doch noch ueberhaupt nichts wirklich entschieden.
Und wer sagt, dass altgediente Zauberer nicht einen Vorsprung kriegen, wenn
die Gilde geaendert wird, um ihren Uebeaufwand zu honorieren, den sie bis
dahin hatten? Abgesehen davon kann ich mich noch recht deutlich dran erinnern,
dass sich viele Zauberer endlich nen Gildenmagier gewuenscht haben, der was
fuer die Gilde tut. Jetzt isses endlich soweit und ihr regt Euch ueber
ungelegte Eier auf. Wartet doch einfach erstmal ab, ob Nachtwind seinen
Herzanfall ueberlebt ;o)

Apo*
(mit dem Konzept fuer ne Gildenquest in der Tasche)

-----------------------------------------------------------------------------



Re^6: artikel Zauberergilde v2.0 (Zarniya, 15. Feb 2001, 10:55:50):
~#! rn=Anacrion rt=982087791 rg=gilden.zauberer
~#! tid=982063139
Hmmm, 

also ich denke, Zauberer sollte Teile ihrer Stats einsetzen koennen... die
sind dann weg, aber man kann ihnen ja dann neue ZTs zuweisen.... 

Marc

-----------------------------------------------------------------------------



Re^3: hmbl (Elendil, 15. Feb 2001, 14:58:35):
~#! rn=Seno rt=982207326 rg=gilden.zauberer
~#! tid=982162222
Hi,

darf ich darauf aufmerksam machen, dass eine Gilde aus mehr als nur
Zauberspruechen besteht ? Wer schreibt denn die neuen Gildenraeume
fuer die alte Gilde ? Die NPCs sind alt etabliert und lieb gewonnen,
die werden mit in die neue Gilde genommen nehm ich mal an. Ebenso
werden Llystrathe und Randar mitumziehen :) Die kenne ich nun schon fast
persoenlich :) Nie wuerde die einer anderen als der echten Zauberergilde
angehoeren.
Dann der Name :) Also Zauberer bleibt ihr nicht ;) VETO VETO :)
Zaubererkarateka oder so vielleicht ;) 

Achja und es werden wohl ne Menge Sprueche auch bestehen bleiben.
Wenn dann werdet ihr wohl der ungeliebte Altzweig der Zauberer sein.

Neu hochspielen wuerde ich meinen Char auch nur ungerne von vorne in einer
mit schon bekannten Gilde. Die Zauberergilde jedoch zu grossen teilen neu-
entstehen und an dem Umfang der Neustrukturierung bemisst sich auch der neue
Spass :) Eben nicht alter Spass von vorne, neuer Spass :)

CU, Elendil


-----------------------------------------------------------------------------



Re^4: hmbl (Seno, 15. Feb 2001, 18:23:42):
~#! rn=Elendil rt=982245515 rg=gilden.zauberer
~#! tid=982162222
Hallo Elendil,

Du hast Recht, die alte Gilde neben der neuen bestehen zu lassen braechte
einiges an Schwierigkeiten und Aufwand mit sich, das sehe ich wie Du und ich
erwarte deshalb nicht, dass mein Vorschlag auf positive Resonanz bei den
Magiern stoesst. Wie gross dieser Aufwand waere, kann ich allerdings nicht
beurteilen, weil ich nicht weiss, wieviel eh neu geschrieben werden soll und
inwieweit sich das Neue mit dem Alten beissen wuerde.

Es gibt allerdings Gruende, die dafuer sprechen, die alte Gilde (zumindest
uebergangsweise) neben der neuen bestehen zu lassen:

- das MorgenGrauen bietet im Verhaeltnis zu seiner Groesse relativ wenig
Moeglichkeiten bei der Gildenwahl und die alte Gilde einfach wegzuwerfen waere
trotz allem auch ein Verlust
- wer seine Figur nicht neu hochspielen will oder kann, kann trotzdem weiter
von dem profitieren, was er erreicht hat
- wenn es einem nicht freisteht, ob man in die neue Gilde ueberwechseln und
seine Figur neu hochspielen will, kann es leicht wieder Enttaeuschungen und
Aerger geben. Wer etwas opfert, erwartet auch etwas dafuer.
- waehrend der Zeit, die die neue Gilde benoetigt, um sich in der Praxis zu
bewaehren und sich ins gesamte Mud einzufuegen (mit allen damit verbundenen
Reibereien), besteht eine Alternative

Ich wuensche mir, dass es mit der neuen Gilde weniger Frust, weniger
Streitigkeiten und Flickschusterei gibt und dass Zauberer sein in der neuen
Gilde wieder (mehr) Spass macht, am besten als zusaetzliche Bereicherung des
Muds. Die alte Gilde dafuer zu opfern faende ich aber genau wie Du die Sache
wert.

Seno

-----------------------------------------------------------------------------



Re: Meinungsbild gefragt. (Skipper, 15. Feb 2001, 21:19:11):
~#! rn=Silvana rt=981641202 rg=gilden.zauberer
~#! tid=981641202
Moin

Dafuer - mit deutlicher 'Besitzstandswahrung'

Skipper

-----------------------------------------------------------------------------



Re: hmbl (Amaryllis, 16. Feb 2001, 20:24:48):
~#! rn=Vector rt=982162222 rg=gilden.zauberer
~#! tid=982162222
> ..., aber ich sehe
> die Zauberer-hand als (guten) Kontrast zum allgemeinen Waffenkampf etwa der
> Kaempfer, Tanijan, Chaoten....

Das ist jetzt nicht Dein Ernst oder - Chaoten mit "Waffenkampf" in Verbindung
zu bringen?

Ama*, fassungslos :)

-----------------------------------------------------------------------------



Re: Re: hmbl (Sky, 17. Feb 2001, 21:12:38):
~#! rn=Amaryllis rt=982351488 rg=gilden.zauberer
~#! tid=982162222
da vector von waffenkampf und nicht von waffenskills sprach, halte ich diese
formulierung fuer durchaus ok.
mir scheint, du hast hier (leider mal wieder) einen artikel inhaltlich nicht
richtig gelesen bzw. nicht richtig verstanden.

-----------------------------------------------------------------------------



Re: Re: hmbl (Orktoeter, 17. Feb 2001, 21:17:42):
~#! rn=Amaryllis rt=982351488 rg=gilden.zauberer
~#! tid=982162222
> ..., aber ich sehe
> die Zauberer-hand als (guten) Kontrast zum allgemeinen Waffenkampf etwa der
> Kaempfer, Tanijan, Chaoten.... 

Was ich viel weniger sehe ist der Kontrast. Fuer mich sieht die Zaubererhand
viel eher genau so aus wie Waffenkampf halt mit blossen Haenden. Und da ist zu
Recht die Frage wozu ein Zauberer das haben sollte.

Aber das ist denke ich muessig. Die Zauberer werden ueberwarbeitet und sollten
konstruktive Vorschlaege an Silvana und Co. weiterleiten und ansonsten
Abwarten oder die Hand geniessen so lange es sie noch so gibt.

OrkT, der Vector in dem Punkt einfach nicht verstehen kann.

-----------------------------------------------------------------------------



Re^3: hmbl (Amaryllis, 18. Feb 2001, 14:51:04):
~#! rn=Sky rt=982440758 rg=gilden.zauberer
~#! tid=982162222
Das bisschen Kratzen, das beispielsweise ein Chaot mit einer Waffe verursacht,
wuerde ich nicht als Waffen"kampf" bezeichnen. Insofern habe ich durchaus
richtig gelesen. Im uebrigen laesst sich von meiner kleinen Anmerkung zu einem
winzigen Teil des Artikels nicht auf ein grundsaetzliches Nichtverstehen des
Ganzen schliessen.

Ama*

PS: Das "leider mal wieder" haettest Du Dir sparen koennen, insofern gebe ich
es dankend zurueck.

-----------------------------------------------------------------------------



Re^4: hmbl (Solmyr, 18. Feb 2001, 15:46:57):
~#! rn=Amaryllis rt=982504264 rg=gilden.zauberer
~#! tid=982162222
Erfahren wir noch mehr von Euren Auseinandersetzungen oder verschont
Ihr uns in Zukunft? :)

Solmyr,-> Rubrik: MPA Arena

-----------------------------------------------------------------------------



Magisterpruefung (Silvana, 18. Apr 2001, 15:36:10):
Salve

Ich kann derzeit nur dringend davon abraten, sich an der Magisterpruefung zu
versuchen. Sie ist aufgrund eines technischen Fehlers derzeit unter Umstaenden
nicht loesbar. Ich kann das allerdings erst wieder aendern, wenn der
FTP-Zugang wieder funktioniert, was hoffentlich bald der Fall sein wird. Ich
geb dann aber in dieser Rubrik Entwarnung.

Silvana

-----------------------------------------------------------------------------



Ihr werdet es nicht fassen ... (Ark, 21. Mai 2001, 22:38:18):
... und einige werden mich hassen, aber egal. Ich beschreibe grade mal den
ersten Raum und sehe mit Schreck, dass es viele viele Details werden *huch* Da
hab ich mir mal gedacht, schreibst Du bei der Gelegenheit mal einen kleinen
Update wie es so steht mit der Ueberarbeitung.
Die Langbeschreibungen der vielen Raeume sind zu etwa 60% fertig, dann gibt es
eine interne Begutachtung und Verabschiedung, denke ich mal. Dann geht es an
die Feinarbeit *schreck*
Das ist auch schon alles, was es Neues gibt von dem Neubau der Gilde. Der
kampf-/spruchtechnische Teil ist konzeptmaessig soweit fertig und bedarf der
Absegnung/Anpassung durch die Gildenbalance, dann geht es auch hier in
Taramis-artigen Schritten weiter. Mehr gibt es immer mal in unregelmaessigen
Abstaenden.

We work for you ;^)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Ihr werdet es nicht fassen ... (Wurzel, 22. Mai 2001, 09:48:39):
~#! rn=Ark rt=990477498 rg=gilden.zauberer
~#! tid=990477498
taramis-artige schritte? also ankuendigungen und nichts weiter?
oder anders gesagt, schrittlaenge von 10 jahren? weia...

wurzel

-----------------------------------------------------------------------------



Re: Re: Ihr werdet es nicht fassen ... (Obermotz, 22. Mai 2001, 10:27:50):
~#! rn=Wurzel rt=990517719 rg=gilden.zauberer
~#! tid=990477498
Sehe doch nicht alles so optimistisch Wurzel. Aber wer will eigentlich
Details? Wir brauchen nur einen Spruch: Bei Benutzung ein Zap auf alle NPC im
MG!!!

OM hofft, dass Kompos abgeschafft werden

-----------------------------------------------------------------------------



Re: Ihr werdet es nicht fassen ... (Foobar, 22. Mai 2001, 11:18:11):
~#! rn=Ark rt=990477498 rg=gilden.zauberer
~#! tid=990477498
Hab' ich was verpasst?

Bin ich im falschen Mud?

Seit wann werden denn Spieler ueber den aktuellen Stand von umfangreicheren
Projekten informiert? ]:o)

Ich kann das nur ausdruecklich begruessen. Besten Dank, Ark ;o)

Zwar bin ich kein Zauberer, freu mich aber trotzdem schon aufs Forschen in den
neuen Gildenraeumen und darauf, dort beim Forschen Sachen zu entdecken die
mancher Zauberer wahrscheinlich nie sehen wird ;o)

Gruss,

     Foobar

-----------------------------------------------------------------------------



Re: Re: Ihr werdet es nicht fassen ... (Thufhir, 22. Mai 2001, 12:14:33):
~#! rn=Foobar rt=990523091 rg=gilden.zauberer
~#! tid=990477498
> ... dort beim Forschen Sachen zu entdecken die mancher Zauberer
wahrscheinlich nie sehen wird ;o) ...

pffff, willst du alle zauberer des questmuds beleidigen? ;)

s'Zauberzwerch Muhfhir

-----------------------------------------------------------------------------



Re: Ihr werdet es nicht fassen ... (Birdy, 22. Mai 2001, 14:20:41):
~#! rn=Ark rt=990477498 rg=gilden.zauberer
~#! tid=990477498
Danke fuer die Info, Ark ! :)

Birdy

-----------------------------------------------------------------------------



Re: Re: Ihr werdet es nicht fassen ... (Solmyr, 22. Mai 2001, 21:12:03):
~#! rn=Birdy rt=990534041 rg=gilden.zauberer
~#! tid=990477498
Mensch, da sind se' alle nacheinander am Schleimen...*seufz*. WEITERARBEITEN
ARK ! DAS IST HIER DOCH KEIN ZIRKUS!

Sol*, so geht das ! :=)))

-----------------------------------------------------------------------------



Re^3: Ihr werdet es nicht fassen ... (Anacrion, 22. Mai 2001, 21:12:31):
~#! rn=Solmyr rt=990558723 rg=gilden.zauberer
~#! tid=990477498
Solmyr, loesch dich.
Anac* - weiss auch wies geht.

-----------------------------------------------------------------------------



Re^4: Ihr werdet es nicht fassen ... (Solmyr, 22. Mai 2001, 21:13:13):
~#! rn=Anacrion rt=990558751 rg=gilden.zauberer
~#! tid=990477498
Nur wenn Du mitmachst und Dich auch verfriemelst...

-----------------------------------------------------------------------------



Re: Re: Ihr werdet es nicht fassen ... (Apsu, 25. Mai 2001, 22:38:04):
~#! rn=Foobar rt=990523091 rg=gilden.zauberer
~#! tid=990477498
Und darauf, den Zaubidoedeln artig fuer die Besuche im Struv zu danken }:>

Apsu

-----------------------------------------------------------------------------



Re^3: Ihr werdet es nicht fassen ... (Foobar, 25. Mai 2001, 22:38:36):
~#! rn=Apsu rt=990823084 rg=gilden.zauberer
~#! tid=990477498
Ach was, die NPCs kommen doch von Patryn. :o)

Gruss,

     Foobar

-----------------------------------------------------------------------------



Re^4: Ihr werdet es nicht fassen ... (Ark, 25. Mai 2001, 23:21:06):
~#! rn=Foobar rt=990823116 rg=gilden.zauberer
~#! tid=990477498
Moep, wir schuetzen die neuen Zauberer gemeinsam!
Hm, das "!" sollte ich lieber lassen, sonst kommt keiner ;^)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^5: Ihr werdet es nicht fassen ... (Foobar, 25. Mai 2001, 23:31:22):
~#! rn=Ark rt=990825666 rg=gilden.zauberer
~#! tid=990477498
Hach, ich freu' mich schon richtig auf den Moment wo mich der erste
Anti-Forsch-Zauberer fragt, wo denn in seiner Gilde was ist :o)

Gruss,

     Foobar

-----------------------------------------------------------------------------



Re^6: Ihr werdet es nicht fassen ... (Vardion, 25. Mai 2001, 23:58:45):
~#! rn=Foobar rt=990826282 rg=gilden.zauberer
~#! tid=990477498
*schluck* :-)

-----------------------------------------------------------------------------



Re^7: Ihr werdet es nicht fassen ... (Liara, 26. Mai 2001, 10:25:50):
~#! rn=Vardion rt=990827925 rg=gilden.zauberer
~#! tid=990477498
GdA, wieso verschiebste die vorigen Artikel eigentlich nicht? Muss man sich
das anhoeren als Zaubi in der eigenen Rubrik?

LZ ;-)

-----------------------------------------------------------------------------



Re^8: Ihr werdet es nicht fassen ... (Grimmborn, 26. Mai 2001, 10:32:01):
~#! rn=Liara rt=990865550 rg=gilden.zauberer
~#! tid=990477498
Sowohl die Regions- als auch die Gildenrubriken sind nicht mein Problem, da
gibts jeweils zustaendige Regions- und Gildenmagier die auf die Konsistenz
"ihrer" Rubriken achten koennen.

GdA

-----------------------------------------------------------------------------



Re^5: Ihr werdet es nicht fassen ... (Moep, 26. Mai 2001, 18:02:07):
~#! rn=Ark rt=990825666 rg=gilden.zauberer
~#! tid=990477498
Was hat das mit mir zu tun?

Moep

-----------------------------------------------------------------------------



Re^9: Ihr werdet es nicht fassen ... (Ark, 28. Mai 2001, 10:52:11):
~#! rn=Grimmborn rt=990865921 rg=gilden.zauberer
~#! tid=990477498
Moep, moep, moeeeeeep. Nix. Aber es klingt in dem Zusammenhang richtig bloed
:-)
Und darauf kommt es ja an. Einige arkln hier ja auch schon, wenn ich online
bin, also nix fuer ungut *g*


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^7: Ihr werdet es nicht fassen ... (Elberet, 29. Mai 2001, 00:09:02):
~#! rn=Gast1 rt=991087724 rg=gilden.zauberer
~#! tid=990477498
nehmt gaesten die mpa weg

-----------------------------------------------------------------------------



Re^8: Ihr werdet es nicht fassen ... (Grimmborn, 29. Mai 2001, 12:31:40):
~#! rn=Elberet rt=991087742 rg=gilden.zauberer
~#! tid=990477498
Wird immer wieder diskutiert. Zumindest werden Artikel von Gaesten unabhaengig
vom Inhalt sofort geloescht, sobald ich sie sehe. Natuerlich nur wenn ich in
der entsprechenden Rubrik Loeschrechte habe...

Grimmborn der Atheist

-----------------------------------------------------------------------------



alchemist (Patryn, 29. Mai 2001, 16:36:45):
hi,

mit ein bisschen glueck (habs nicht getestet *g*) merkt sich der
alchemist nun auch ueber reboots, was fuer sachen er schon bei der
guertelquest erhalten hat.
hab auch mal paar bugs rausgehaun, aber evtl. auch wieder neue eingebaut.

------
patryn wirft Alpha-Versionen ;)

-----------------------------------------------------------------------------



Re^9: Ihr werdet es nicht fassen ... (Silvana, 29. Mai 2001, 16:49:07):
~#! rn=Grimmborn rt=991132300 rg=gilden.zauberer
~#! tid=990477498
Immer wieder erheiternd, wie man als Gast hier behandelt wird. Macht so
richtig Lust, irgendwann doch noch mal was kreatives hier zu tun.

(Jemand) - (hat ne etwas andere Auffassung von Gastlichkeit)

-----------------------------------------------------------------------------



Re^9: Ihr werdet es nicht fassen ... (Pilgrim, 29. Mai 2001, 16:58:42):
~#! rn=Grimmborn rt=991132300 rg=gilden.zauberer
~#! tid=990477498
Ich weiss auch nicht, was dieses GaesteLaestern soll ...
Ist doch ganz einfach ... ne MPA Gruppe 'gast.*' und Gaeste bekommen
nur Schreibrechte da ... und schon ist das Problem - wenns ueberhaupt
eins ist - geloest ... 

Pilgrim 
PS.: Gastfreundlichkeit ist allerdings was anderes ;-)

-----------------------------------------------------------------------------



Re^10: Ihr werdet es nicht fassen ... (Tsunami, 30. Mai 2001, 03:04:41):
~#! rn=Pilgrim rt=991148322 rg=gilden.zauberer
~#! tid=990477498
Ich fass es nicht! Es laufen hier tatsaechlich Zauberer ohne Zaubererhut rum!
Wo kommen wir denn da hin? Ich muss mich ja richtig konzentrieren wenn ich 
einen Hut knicken will damit ich nicht aus der Ferne in die leere Luft ueber
meinem Opfer greif.

Ich fordere mehr Zaubererhuete (die dann von auch Zauberern getragen werden)!

Tsunami. Meint es ernst.

-----------------------------------------------------------------------------



Re^11: Ihr werdet es nicht fassen ... (Elbereth, 30. Mai 2001, 03:07:09):
~#! rn=Tsunami rt=991184681 rg=gilden.zauberer
~#! tid=990477498
Meiner ist erst gestern im Sumpf versunken. Kein Bock nen neuen zu holen.

Elbi(h) (im Urlaub)

-----------------------------------------------------------------------------



Re^12: Ihr werdet es nicht fassen ... (Anacrion, 30. Mai 2001, 03:08:21):
~#! rn=Elbereth rt=991184829 rg=gilden.zauberer
~#! tid=990477498
Es gibt auch schwarze Helme, gruene Masken und Eisstirnbaender.

Anac* - traegt keine Huete

-----------------------------------------------------------------------------



Re^13: Ihr werdet es nicht fassen ... (Tsunami, 30. Mai 2001, 03:10:51):
~#! rn=Anacrion rt=991184901 rg=gilden.zauberer
~#! tid=990477498
*mit der Hand abschaetzig wedelnd*

Ein Zauberer ohne spitzer Hut ist kein Zauberer.

Kaempfer tragen Helme, Chaoten Masken und Kleriker Stirnbaender.

Wer was anderes behauptet veraegert mich.

Tsunami. Meint es ernst.


-----------------------------------------------------------------------------



Re^14: Ihr werdet es nicht fassen ... (Tsunami, 30. Mai 2001, 03:14:28):
~#! rn=Tsunami rt=991185051 rg=gilden.zauberer
~#! tid=990477498
wegen der vielen Pappnasen hier die immer alles fuer bare Muenze nehmen sei
sicherheitshalber noch ein Vermerk angebracht:

Tsunami. Meint es ernst (grinst aber auf seinen Stockzaehnen).  

-----------------------------------------------------------------------------



Re^15: Ihr werdet es nicht fassen ... (Elberet, 30. Mai 2001, 03:15:12):
~#! rn=Tsunami rt=991185268 rg=gilden.zauberer
~#! tid=990477498
Elberet muss jetzt doch grinsen :)


-----------------------------------------------------------------------------



Re^11: Ihr werdet es nicht fassen ... (Elbereth, 30. Mai 2001, 03:16:38):
~#! rn=Tsunami rt=991184681 rg=gilden.zauberer
~#! tid=990477498
och ich haett auch gern wieder nen Hut, ob geknickt oder nciht, waer mir in
dem Fall egal :)

Elbi(h) 

-----------------------------------------------------------------------------



Re^12: Ihr werdet es nicht fassen ... (Anacrion, 30. Mai 2001, 03:40:35):
~#! rn=Elbereth rt=991185398 rg=gilden.zauberer
~#! tid=990477498
Ich vergas ... Myung hat nen Hut :-) Kommt wer mit ? ;-)

Anac* - unernst

-----------------------------------------------------------------------------



...und es bewegt sich doch! (Silvana, 30. Mai 2001, 17:00:12):
Salve Zauberers.

Ein paar von Euch werden es vielleicht bemerkt haben: Ich habe meinen Urlaub
vom MG beendet und werde sogar ab Mitte naechsten Monats ein bisschen mehr
Zeit haben. Dementsprechend wird es wohl Zeit, Euch mal wieder ins Bilde zu
setzen:

Vor ein paar Tagen ist Nachtwinds Mail eingetroffen, in der er zwar einige
Anmerkungen zum neuen Konzept zusammengestellt hat, aber zumindest generell
gruenes Licht gibt. Konkrete Zahlen gibt's zu diesem Stand natuerlich keine.
Aber das hat zweierlei zur Folge:

1) Ich kann endlich anfangen, die neue Gilde zu schreiben. :)
   Nebeneffekt: Ark braucht nicht laenger fuerchten, fuer die Tonne zu
   arbeiten.

2) Ich kann mir ueber die Zukunft der _alten_ Gilde Gedanken machen.

Letzteres wird ein paar Veraenderungen mit sich bringen, die sicher nicht
jedem schmecken werden. Ich versuche dabei aber zumindest darauf zu achten,
dass alle Teilschritte in sich logisch sind, so dass die Gilde hinterher
wenigstens eine schluessige Geschichte hat. ;-)
Erster fuer Spieler sichtbarer Punkt besteht darin, dass Patryn und ich
versuchen werden, technisch saubere Loesungen fuer die in den letzten Monaten
zusammengekommenen Bugs zu finden und umzusetzen. Der zweite Schritt duerfte
dann die umbewertung gewisser Sprueche darstellen. Moege Nachtwind uns gnaedig
sein...

In jedem Fall werde ich mich von Zeit zu Zeit mal melden und Euch ueber die
Fortschritte informieren - so es welche zu vermelden gibt.

  Silvana

PS: Ich hab von einigen Leuten Mail bezueglich eines gewissen Tal-Projekts
bekommen. Diesen Mails werd ich mich in den naechsten Tagen (hoffentlich)
widmen koennen und sie dann auch entsprechend beantworten.

-----------------------------------------------------------------------------



Re: ...und es bewegt sich doch! (Ark, 30. Mai 2001, 17:41:11):
~#! rn=Silvana rt=991234812 rg=gilden.zauberer
~#! tid=991234812
Ich arbeite sowieso nicht fuer die Tonne, ich haette es "umgemodelt" ;^)
Wider sinnlos herumliegende Files ...


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^11: Ihr werdet es nicht fassen ... (Trug, 30. Mai 2001, 20:19:41):
~#! rn=Tsunami rt=991184681 rg=gilden.zauberer
~#! tid=990477498
Na, vielleicht waere eine groessere Variation an Kleidung sinnvoller. Die
neuen Zauberersachen muessen ja ned unbedingt toller/besser/mehr Sprueche
unterstuetzen, sondern halt einfach "nur" ungefaehr gleich gut zu sein.

Ist schon komisch, dass da hier das MUD eigentlich sehr gross ist, und dann
die Zauberer wirgendwie in einer Einheitsuniform rumlaufen... 

Trug

-----------------------------------------------------------------------------



aenderungen (Patryn, 11. Jun 2001, 16:34:57):
- erdbeben und daemonenfratze treffen nur noch erfolgsabhaengig viele
  gegner, nicht mehr unendlich viele...sonst bugs in manchen gegenden
- welcher dropps hat anfaengerbuch entsorge-gescriptet? :)
  na ja, weg wars, war eh nen bug weil eigentlich schon mal eingebaut
- paar allbekannte forscherpunkte der gilde sind offensichtlichen
  forscherpunktlisten zum opfer gefallen. ich waer wirklich dankbar,
  die weitergabe oeder ueberhaupt erstellung von diesem unfug zu lassen.
  machte eigentlich arbeit

------
patryn

-----------------------------------------------------------------------------



Re: aenderungen (Tivi, 19. Jun 2001, 13:18:50):
~#! rn=Patryn rt=992270097 rg=gilden.zauberer
~#! tid=992270097
Ich wars :)
Und wenn Du das schon aenderst, dann bitte so, dass ich nicht immer noch die
Strassen mit Anfaengerhandbuecher zupflastern kann.
  
Tivi (Meldet gerne Fehler)

-----------------------------------------------------------------------------



zauberstab (Patryn,  4. Aug 2001, 12:32:03):
wer sich einen neuen zauberstab holt (tm llystrathe zauberstab z.B.),
der muss danach unbedingt den stab neu benennen (benenne zauberstab ...).

-- 
patryn

-----------------------------------------------------------------------------



selbstverwandlung (Patryn,  4. Aug 2001, 12:41:23):
selbstverwandlung funktioniert zur zeit aus technischen gruenden nicht.
sollte in den naechsten tagen behoben sein.

-- 
patryn

-----------------------------------------------------------------------------



Re: selbstverwandlung (Grimmborn,  4. Aug 2001, 12:45:33):
~#! rn=Patryn rt=996921683 rg=gilden.zauberer
~#! tid=996921683
> tm llystrathe zauberstab
Du teilst Llystrathe mit: zauberstab
Llystrathe teilt Dir mit: Als Nichtzauberer kannst Du mich nur nach
Llystrathe teilt Dir mit: 'Zauberkomponenten' fragen!

tm llystrathe Relativitaetsttheorie?
Llystrathe teilt Dir mit: Als Nichtzauberer kannst Du mich nur nach
Llystrathe teilt Dir mit: 'Zauberkomponenten' fragen!

Das lustige ist: Ich kann sie nach allem Fragen. Sie luegt mich an. Ja wie
find ich denn das...

GdA

-----------------------------------------------------------------------------



Re: Re: selbstverwandlung (Wurzel,  4. Aug 2001, 12:49:45):
~#! rn=Grimmborn rt=996921933 rg=gilden.zauberer
~#! tid=996921683
vielleicht liegts am typo?

-----------------------------------------------------------------------------



Re^3: selbstverwandlung (Grimmborn,  4. Aug 2001, 12:50:52):
~#! rn=Wurzel rt=996922185 rg=gilden.zauberer
~#! tid=996921683
Du meinst ohne typo koennte ich sie nicht mehr danach fragen? Gewagte These...

GdA

-----------------------------------------------------------------------------



Ehering (Elendil,  7. Aug 2001, 21:12:51):
Hi Zaubi,

kann bitte jemand meinen Ehering mit einer Handunterstuetzung belegen :) ?
Eine brauchbare bitte :)

Mal Scherz beiseite, das Abhaengen der Dunkelelfen trifft natuerlich
auch die Zauberer. Schlagringe sind beide weg, ewige Kompos dort auch,
wobei die Kompos kein wirklicher Verlust sind, da substituierbar.
Die Schlagringe sind schon bitter. Daher meine Bitte, den Zauberern
ein paar Ringe mehr an die "Hand" zu geben :)
Fuer Hand ist meiner Meinung nach die maximal im MUD erhaeltliche
Unterstuetzung ist der Schlagring von Morgoth mit "sehr gut",
das ist sicher nicht zu verachten aber die Auswahl ist sehr
gering.

Wie waers wenn wir in diesem Zuge den Zauberstab aufwerten :) ?

Ringe, die unterstuetzen koennten gaebe es ja genug :) Ich liefer
gerne ein Liste, falls wer welche einbauen mag :)

Cu, Elendil :)

-----------------------------------------------------------------------------



Re: Ehering (Patryn,  7. Aug 2001, 21:14:31):
~#! rn=Elendil rt=997211571 rg=gilden.zauberer
~#! tid=997211571
ich habe padreic bereits gefragt wie lange er seine aktion dort fortfuehren
will und ob alternativen noetig seien. er meinte nein, es kaeme schon
wieder ran. wir warten einfach mal ne woche...

-- 
patryn

-----------------------------------------------------------------------------



Re: Re: Ehering (Wurzel,  8. Aug 2001, 09:22:34):
~#! rn=Patryn rt=997211671 rg=gilden.zauberer
~#! tid=997211571
interessanterweise gibt es ja leute, die trotz crash gestern diese ringe
haben. und das aus einem derzeit nicht angeschlossenen gebiet. scheint also
die aufregung nicht wert zu sein :)

wurzel

-----------------------------------------------------------------------------



Re^3: Ehering (Anatol,  8. Aug 2001, 09:42:52):
~#! rn=Wurzel rt=997255354 rg=gilden.zauberer
~#! tid=997211571
Auch Abhaengen will gelernt sein.

Anatol

-----------------------------------------------------------------------------



Re^4: Ehering (Gloinson,  8. Aug 2001, 10:22:26):
~#! rn=Anatol rt=997256572 rg=gilden.zauberer
~#! tid=997211571
Hehe. Ist ja lustig. War Padreic eigentlich schon existent als das Abhaengen
der SSP im ersten Versuch ebenfalls fehlschlug?

Gloin(son)

-----------------------------------------------------------------------------



Re: Re: Ehering (Asteroth,  8. Aug 2001, 19:01:40):
~#! rn=Patryn rt=997211671 rg=gilden.zauberer
~#! tid=997211571
Tja...aber nun hat ers gelernt ;)

-----------------------------------------------------------------------------



Schlagring (Strohalm,  9. Aug 2001, 11:05:38):
Koennte sich vielleicht mal ein zaubifreundlicher Magier dazu erbarmen, eine
Alternative zum momentan nicht verfuegbaren Schlagring zu proggen? ;)

Haelmchen, sich nackt fuehlend

-----------------------------------------------------------------------------



Re: Schlagring (Patryn,  9. Aug 2001, 18:52:38):
~#! rn=Strohalm rt=997347938 rg=gilden.zauberer
~#! tid=997347938
liest du eigentlich auch bevor du was schreibst?

-- 
patryn, aergerlich

-----------------------------------------------------------------------------



party (Patryn,  9. Aug 2001, 22:15:24):
wenn mich nich noch die ganz grosse langeweile hascht werde ich diesmal
wohl nicht zur party erscheinen. ihr koennt also ungestoert bugs zur gilde
austauschen *spaeher aussend* ;)

-- 
patryn

-----------------------------------------------------------------------------



Re: party (Anacrion, 10. Aug 2001, 07:08:54):
~#! rn=Patryn rt=997388124 rg=gilden.zauberer
~#! tid=997388124
Ooooooooooooooooooooooooooooooooooooooch ... :((

anac*

-----------------------------------------------------------------------------



Re^3: Ehering (Kellybundy, 10. Aug 2001, 10:49:36):
~#! rn=Asteroth rt=997290100 rg=gilden.zauberer
~#! tid=997211571
eben nicht!

-----------------------------------------------------------------------------



selbstverwandlung (Patryn, 12. Aug 2001, 15:23:27):
selbstverwandlung tuts wieder, nun auch stilecht mit plural... ;)

-- 
patryn

-----------------------------------------------------------------------------



aenderungen (Patryn, 28. Aug 2001, 00:43:59):
bitte mal wieder das brett konsultieren, normal schreibe ich das hier ja
nicht mehr, aber es koennten ein paar trigger kaputtgegangen sein.
meckereien an /dev/null oder -jammerei

-- 
patryn

-----------------------------------------------------------------------------



Re: aenderungen (Obermotz, 28. Aug 2001, 10:33:48):
~#! rn=Patryn rt=998952239 rg=gilden.zauberer
~#! tid=998952239
Wie soll ich das da lesen? Ich habe seit mindestens 2 Reboots und einem
mein Haus nicht mehr verlassen.

OM traut sich nicht ohne Kompos vor die Tuer

PS: Habt Ihr heute schon Designer-Kompos gespendet? ;-)

-----------------------------------------------------------------------------



Re: Re: aenderungen (Obermotz, 28. Aug 2001, 10:35:01):
~#! rn=Obermotz rt=998987628 rg=gilden.zauberer
~#! tid=998952239
eigentliche wollte ich ja "... und einem Crash..." schreiben.

OM ist etwas vergesslich. Liegt wohl auch daren, das er keine Designer-Kompos
hat.

-----------------------------------------------------------------------------



Re: Re: aenderungen (Patryn, 28. Aug 2001, 10:35:13):
~#! rn=Obermotz rt=998987628 rg=gilden.zauberer
~#! tid=998952239
in diesem fall werden dich die aenderungen zweifelsohne auch gar nicht
interessieren :) neue seherhaus-spells gibts zumindest nicht.

-- 
patryn

-----------------------------------------------------------------------------



trigger (Patryn,  5. Sep 2001, 08:19:51):
hoi,

gemein wie ich bin hab ich nun schon die 2. woche nacheinander ein paar
trigger diverser leute zerschossen, schaetz ich.
weitere infos am gildeninternen brett.

-- 
patryn

-----------------------------------------------------------------------------



scripterei (Patryn, 16. Sep 2001, 19:14:24):
hi ihrs,

ich wollte noch mal daran erinnern, dass unbeaufsichtigte ueberscripte
nicht erlaubt sind. es sind in letzter zeit durch die umbauarbeiten mehrere
leute aufgefallen, deshalb sag ichs hier noch mal.
auch andere spieler sprachen mich schon auf die problematik an, und das
heisst fuer mich, dass es schon ziemlich uebertrieben wird.
wer ideen hat, wie man die scripterei technisch einschraenken kann, ohne
die anderen zu sehr einzuschraenken, nur her damit, nur behaltet bitte den
arbeitsaufwand im hinterkopf.

-- 
patryn

-----------------------------------------------------------------------------



lehrlingsanforderungen: lvl 20? (Whitetiger, 21. Sep 2001, 18:58:14):
Hi!

Ich finde Spielerstufe 20 fuer einen Lehrling ein *bisschen* hoch, Stufe 15
wuerd ich besser finden. (Vielleicht liegts ja nur da dran, dass ich gern
lehrling geworden waer...)

WT.

P.S.: Wer hat denn das geaendert?

-----------------------------------------------------------------------------



Re: lehrlingsanforderungen: lvl 20? (Vardion, 21. Sep 2001, 19:00:52):
~#! rn=Whitetiger rt=1001091494 rg=gilden.zauberer
~#! tid=1001091494
> P.S.: Wer hat denn das geaendert?

'Unser Gildenmagier' waere eine ziemlich gute erste Naeherung fuer die Loesung
dieses Problems ;-)

Vardion

-----------------------------------------------------------------------------



Re: Re: lehrlingsanforderungen: lvl 20? (Anacrion, 21. Sep 2001, 19:22:04):
~#! rn=Vardion rt=1001091652 rg=gilden.zauberer
~#! tid=1001091494
Hmm. also LVL20 fuer GLG 5 ist recht heftig .. ANDERERSEI)TS hat man
allerdings mit LVL5 ziemlich power ....  vorher allerdings hoechst wenig ;)
... wuerde die levelanforderunen grundsaetzlich parabelfoermig machen. halt
ehr starken anstieg zwischen 6 und 10, aber vorher recht mau

anac* - findet VL20 fuer GLVL5 schon recht heftig

-----------------------------------------------------------------------------



Re^3: lehrlingsanforderungen: lvl 20? (Nonne, 21. Sep 2001, 19:29:53):
~#! rn=Anacrion rt=1001092924 rg=gilden.zauberer
~#! tid=1001091494
Ihr habt doch nur 9 Level? Ab wann willst Du das denn steigern? Irgendwann
bekommst Du eh den Sprung. Und von 15 nach 20 ist man schneller als von 50
nach 55 (c:

-----------------------------------------------------------------------------



Re^4: lehrlingsanforderungen: lvl 20? (Anacrion, 21. Sep 2001, 20:52:00):
~#! rn=Nonne rt=1001093393 rg=gilden.zauberer
~#! tid=1001091494
Hmm.

LVL -> ZLVL
2 -> 1 (ist eh so
10 -> 3
15 -> 5
30 -> 6
40 -> 7
50 -> 8
60 -> 9
100 -> 10 ;o)

vielleicht kann man die spells auf LVL3 und 4 tauschen ... hand und schutz
sind recht gut, und evtl. erst apeter lernbar ... 

eins ist sicher: ein zauberer mit hand unter 50% braucht sich kaum wo sehen
lassen zzum metzeln

anac*

-----------------------------------------------------------------------------



Re^5: lehrlingsanforderungen: lvl 20? (Anacrion, 21. Sep 2001, 20:53:17):
~#! rn=Anacrion rt=1001098320 rg=gilden.zauberer
~#! tid=1001091494
Oder einfach Seher fuer LVL6 fordern :o)

anac* .. hatte mal nen kaempfer lange auf LVL14

-----------------------------------------------------------------------------



Re^5: lehrlingsanforderungen: lvl 20? (Pale, 21. Sep 2001, 20:55:21):
~#! rn=Anacrion rt=1001098320 rg=gilden.zauberer
~#! tid=1001091494
Nein, nein, nein. Ich freue mich, dass ich fast lvl 50 bin und hoffentlich nch
vor der 55 auf zlvl9 komme ...

Pale

-----------------------------------------------------------------------------



Re: lehrlingsanforderungen: lvl 20? (Seno, 22. Sep 2001, 05:29:08):
~#! rn=Whitetiger rt=1001091494 rg=gilden.zauberer
~#! tid=1001091494
Ehrlich gesagt, bin ich erschuettert, was die Spielerstufen-Voraussetzungen
fuer die Gildenlevel angeht. Worin liegt der Sinn ? Dass zwischen allgemeiner
Mud-Erfahrung und Gildenstaerke/-faehigkeiten ein gewisses Verhaeltnis gewahrt
sein muss, sehe ich auch so. L 20 fuer GL 5 halte ich jedoch fuer WEIT
ueberzogen. Anacrion meint, mit GL 5 haette man schon ziemlich Power. Mit Hand
und Giftpfeil als Angriffsspells, Schutz und Wille fuer die Verteidigung ?
Ohne Extrahand, Blitz, Feuerball, angepasste und unterstuetzende Ruestungen,
ganz zu schweigen von der Komponenten-Hand und den GL 8-Spells, die nach
meiner Erfahrung erst wirklich Kampfstaerke bringen ? Und die Basissprueche,
die man hat, also Schutz und Hand, kann man noch recht unzureichend lernen.

Wenn man bisher einen Zauberer so gespielt hat, dass man die Levelbedingungen
ausgereizt hat, war man bis etwa einschliesslich GL 6 bzgl. Kampfstaerke
schlechter gestellt als ein Abenteuerer, da man nur sehr schwache Waffen /
Ruestungen benutzen kann. Ich weiss das aus eigener Erfahrung, weil ich meinen
Zauberer so gespielt hab. Ich wollte einfach zaubern koennen und hab mich
ueber jeden neuen Spruch erstmal riesig gefreut. Mir kam es nicht auf Staerke
an, ich hatte allerdings teilweise ziemliche Probleme bei Gildenquesten und
ZTs, weil ich fuer einiges einfach zu schwach war. Ich habe auch einen
Abentuerer bis L 12 gespielt, hab also wirklich den Vergleich.

Also, warum diese gravierenden Verschaerfungen ? Wenn man die Levelforderungen
derart heraufschraubt, erreicht man entweder, dass (Erst-)Spieler mit so viel
Unterstuetzung, wie sie kriegen koennen, durch die Questen rennen, anstatt
diese wirklich zu erleben und, so weit sie koennen, selbst zu loesen (was ja
wohl eigtl. so gedacht ist und auch eine reizvolle Herausforderung ist), oder
dem Spieler wird es von vornherein oder binnen kurzer Zeit vergaellt, einen
Zauberer zu spielen, weils viel zu langwierig, aufwendig und unbefriedigend
ist. Mein Zweitie ist mit L 11 den Tanjian beigetreten, und die Gilde gefaellt
mir von der Atmosphaere und vom Hintergrund her sehr gut. Als ich dann aber
fuer die Gildenstufe 3 Level 17 (!) erfuellen sollte, bin ich wieder
ausgetreten. So macht das keinen Spass und was kann er dann schon !

Deshalb hoffe ich, dass das Ganze bei den Zauberern noch mal ueberdacht wird,
oder mir einfach das Wissen ueber noch umzusetzende Konzepte fehlt, die das
dann im Zusammenhang mehr oder weniger wieder sinnvoll werden lassen.

Seno

PS: Nochmal zu Anacrion: "Einfach Seher fuer GL 6 fordern": Fuer Spieler, die
Questen weitgehend selbststaendig loesen, kaeme das einer Forderung nach L
40-50 gleich, wg. der Forscherpunkte, die sie dabei finden. Questen, die man
so spielt, brauchen aber ihre Zeit und bis GL 6 kommt man dann erst sehr, sehr
spaet ...

PPS: Meiner Meinung nach sollten die Anforderungen so bleiben wie bisher. Nur
bei GL 8 und 9 koennte man hoehere Levelanforderungen stellen. GL 8 konnte man
bisher mit L 15 erreichen, andererseits ist man aber auf die Kampfkraft dieser
Sprueche angewiesen (Waffen-/Ruestungsbeschraenkung), waehrend sie auch erst
noch geringes Potential entfalten koennen, weil man sie nicht weit lernen kann
und dies sehr aufwendig und teuer ist. Deshalb faende ich max. L 20 fuer GL 8
angemessen. Fuer GL 9 koennte man dagegen schon Seher fordern, dafuer sollte
die Anforderung, dass die Architektenquest geloest sein muss, entfallen. Das
ist eine riesige Quest, die man zu dritt loesen muss. Deshalb wurde diese
Quest verstaendlicherweise wohl von Manchem nicht so absolviert, wie es
gedacht war ...

-----------------------------------------------------------------------------



Re: Re: lehrlingsanforderungen: lvl 20? (Anacrion, 22. Sep 2001, 06:06:05):
~#! rn=Seno rt=1001129348 rg=gilden.zauberer
~#! tid=1001091494

Hmm. Also mein LVL15/7-Zauberer duerfte wesentlich staerker sein als alles,
was man mit LVL15 in anderen Gilden erreichen kann

Anac*

-----------------------------------------------------------------------------



Re^3: lehrlingsanforderungen: lvl 20? (Gnome, 22. Sep 2001, 07:49:04):
~#! rn=Anacrion rt=1001131565 rg=gilden.zauberer
~#! tid=1001091494
anacrion, deine kommentare zeugen irgendwie von ueberheblichkeit, gepaart
mit einer spur ignoranz.

NATUERLICH bist du jetzt in der position, aberwitzige lvl-anforderungen
zu fordern, was soll dir schon passieren? dass deine vorschlaege
jenseits der vernunft liegen, scheint dich dabei nicht zu interessieren.

und NATUERLICH ist dein lvl7-zaubi weitaus besser als alles andere.
aber atens, waeren deine "vorschlaege" schon in die tat umgesetzt worden,
als er sich noch hochspielen musste, waere er jetzt nicht lvl 7 und
btens war er bestimmt nutzniesser durch seinen 1tie, der die gilde schon
perfekt kennt und 'mal eben' alle gildenrelevante items vorbeibringen
kann oder 'mal schnell' diesen oder jenen NPC, den dein kleiner zaubi
nicht schafft, aus dem weg raeumen.

echten zaubi-erstspielern, die auch vielleicht mal nicht mit einem
"frufe kann mir mal jmd die gelbe robe hauen? und ausserdem fehlt mir
noch ZT im schacht ganz unten..." alles schaffen, werden damit nur
fast unueberwindbare hindernisse in den weg gelegt.
ich hab es selbst erlebt, als die zaubererqueste neu eingefuehrt
wurden: zum aufsteigen brauchte ich questpunkte, diese grenze war aber
so enorm hoch, dass ich haette queste machen muessen, die damals noch
nicht schaffbar fuer mich waren. ich haette aufsteigen muessen...
die grenze wurde etwas gesenkt und siehe da, es ging.

selbst die neuen glvl-anforderungen erscheinen mir einen tick zu hoch,
wie auch vielleicht anderen; im zuge dessen darfst du deine vorstellungen
der realitaet anpassen.

gnOme

-----------------------------------------------------------------------------



Lehrlingsanforderungen (Cinderella, 22. Sep 2001, 08:38:27):
Ich frag mich grade warum wegen der Lvl-Anforderungen so ein Geschrei gemacht
wird.
Bei den Tanjian brauch man nicht nur bestimmte Spielerlevel zum Aufsteigen,
nein da muss man auch die Stats auf einen Mindestwert bringen und bekommt
vorgeschrieben welche Quests man geloest haben muss (jaja solche Anforderungen
gibt es bei den Zauberern auch ich weiss. Aber deutlich harmloser).

Ist doch garnicht so schlecht, wenn man paar Spielerlevel mehr hat (die in den
niedrigeren Leveln viel schneller erreicht werden als in den hoeheren).
Man kennt sich im Mud besser aus, und kann die erlernten Sprueche dann viel
besser umsetzen. Dann weiss man auch wo es mal ein nettes Monster fuer deren
Anwendung gibt, und muss nicht die armen Ameisen auf der HE mt Hand Saeure
bombadieren ;)

Auspeitschen oder mit Steinen bewerfen is voellig zwecklos
Schwarzes Hexchen Cinderella hat ein dickes Fell :)

-----------------------------------------------------------------------------



Re^4: lehrlingsanforderungen: lvl 20? (Anacrion, 22. Sep 2001, 09:29:15):
~#! rn=Gnome rt=1001137744 rg=gilden.zauberer
~#! tid=1001091494
Hallo Gnome!
     
In meinem Groessenwahn moechte ich Dir die Irrsinnigkeit Deines 
letzten Artikels vor Augen fuehren.

Du schreibst, dass mein Zweitie Vorteile hatte, weil ich mich im MG
auskenne? Das mag sein. Er wusste halt immer sofort, wo Items zu
finden waren und bekam auch mal welche zugesteckt. Damit hast Du
recht.

Das dem so war, hat es ihm ermoeglicht, mit nur LVL15 (der 
bisherigen Anforderung) auf GLVL 7 vorzuruecken. Wenn er naemlich
fuer die Gildenquests und ZTs haette forschen muessen, dann waere er
bestimmt nicht unter LVL25 auf GLVL7 vorgerueckt. Das liegt einfach
daran, dass man FPs kriegt beim Angucken des Muds und evtl. sogar 
ein paar APs und EKs. Nun sagst Du, die Anforderung fuer GLVL7 soll
niedriger sein als LVL25 (das ist soweit ich weiss das, was Patryn 
gesetzt hat)?
Der einzige Weg, das zu erreichen ist, wenn man Deinem Artikel
glauben schenken darf, eine gute Mudkenntnis des Ersties und dessen
Kampfkraft bei der Beschaffung von Items. Nun .. in welcher Weise 
beeintraechtigt denn dann eine Levelanforderung einen
Erstiezauberer? Nicht?

Hinzu kommt endloses uebe(skripte)n unter vernachlaessigung aller
anderen Dinge, da man - wie schon zuvor geschildert - beim 
selbstaendigen Loesen der Gildenquests gar nicht umher kommt, 
ein paar Punkte mitzunehmen.

Ach ja. von wegen Gildenquests ... was haben die mit den
Levelanforderungen zu tun? Ist mein Zauberer besser, weil ich
ihm evtl. geholfen habe bei Quests? Oder haette er die Quest
nicht bei Gelegenheit eh machen muessen um aufzusteigen und
meine Hilfe war nur Bequemlichkeit? Also waere er nicht LVL15
sonder 35 und haette bessere Stats waeren die meisten Quests
bestimmt ein Spaziergang.

Ich darf im Lichte der vorigen Ueberlegungen Deinen Artikel
zusammenfassen:

Bitte setzt die Levelanforderungen runter, damit es auch weiterhin
fuer Erstspieler moeglich ist, nur durch Ueben und ohne die
geringste Mudkenntnis Magister zu werden.



anac*

P.S.: Ich habe nach dem alten system geleernt und mein kleiner nach dem neuten
.. da liessen sich uebrigens keine Synergieeffekte finden ... Das einzige was
Alkohol und der Ring der Zauberbremse ncoh bewirkten sind todesfolgen.

-----------------------------------------------------------------------------



Re^5: lehrlingsanforderungen: lvl 20? (Gnome, 22. Sep 2001, 09:56:37):
~#! rn=Anacrion rt=1001143755 rg=gilden.zauberer
~#! tid=1001091494
ich sage nicht, dass man ohne mudkenntnis magister werden soll oder
aehnliches, da hast du mich wohl falsch verstanden.
natuerlich sind anforderungen ein muss, aber muessen die - grade in den
unteren raengen - so drastisch verschaerft werden, dass vielen alten
<6-spielern die motivation genommen und vielen neueinsteiger vergrault
werden?
grade als voelliger erstling sollte doch einem der aufstieg etwas
leichter fallen, so dass man sieht, dass man "voran" kommt. wir koennen
gerne ueber >6-begrenzungen diskutieren, die unteren grenzen sind aber
z.Zt. definitiv zu hoch, meiner meinung nach.

die gildenquests waren ein beispiel dafuer, wie damals der teufelskreis-
lauf einer hohen begrenzung stattfand: bald hatte ich alle queste, die
mit einfachen (also ohne kampf) mitteln, zu errungen waren, doch fehlten
mir immer noch sehr viele punkte, um aufsteigen zu koennen. dafuer
haette ich jedoch kaempfen muessen, doch ich kannte noch keine
kampfsprueche :) silvana hat es dann sehr bald geaendert.

gnOme

-----------------------------------------------------------------------------



Re^6: lehrlingsanforderungen: lvl 20? (Nonne, 22. Sep 2001, 10:00:25):
~#! rn=Gnome rt=1001145397 rg=gilden.zauberer
~#! tid=1001091494
Also ich sehe das Problem da nicht bei den Levelanforderungen: Wieso kann man
bei GL 6 (was immerhin 2/3 des Erreichbaren ist) immer noch nichts? Das wird
hier zumindest behauptet. Die Kampfkraftsteigung hat einen derart grossen
Exponenten, dass man wohl nie ein ausgewogenes Wachstum der Kampfkraft mit
entsprechender Motivation hinbekommt, wenn man nicht will, dass jeder Depp mit
Level 20 Magister wird.

Nonne, sieht das Problem woanders.

-----------------------------------------------------------------------------



Re^7: lehrlingsanforderungen: lvl 20? (Anacrion, 22. Sep 2001, 10:24:55):
~#! rn=Nonne rt=1001145625 rg=gilden.zauberer
~#! tid=1001091494
Weil die Sprueche nicht lienear gelernt werden ist das. Und ich finde es
eigentlich ganz gut so wie es ist. Das einzige was mich massiv stoert sind die
ganzen skriptenden llp's.

anac* - hilfsbereit und erklaerdend :o)

-----------------------------------------------------------------------------



Re^8: lehrlingsanforderungen: lvl 20? (Vanion, 22. Sep 2001, 10:32:21):
~#! rn=Anacrion rt=1001147095 rg=gilden.zauberer
~#! tid=1001091494
Es freut mich, zu lesen, dass du gegenueber skriptenden HLPs mehr Toleranz
zeigst.

V*, sarkastisch.

-----------------------------------------------------------------------------



Re: Re: lehrlingsanforderungen: lvl 20? (Trug, 22. Sep 2001, 12:14:34):
~#! rn=Seno rt=1001129348 rg=gilden.zauberer
~#! tid=1001091494
Ganz einfach: 

Es gibt so einige Spieler, die sich halt auf Teufel komm raus erst als
Abenteurer / Katzenkrieger mal 'Seher machen' wollen, und dann erst da auf
'ihre' Gilde umsteigen wollen. Denen ist ja so eine Einschraenkung egal, nur
verdirbt das halt wirklich den 'echten' Zaubis jeden Spass da am eigentlichen
Spiel. Mit 'Spiel' meine ich den *Weg*  zum Seher, der oft nur als laestig
angesehn wird.

Stufe 30 fuer GL 6 ist wirklich phantastisch ueberzogen, bis dahin sollen sich
die Zauberer wohl mit so ganz wehrlos durch die Gegend schlagen, und Stufe 7
mit Level 40(!) ist wohl wirklich da mehr als ueberzogen, weil man erst mit
dieser Stufe so die richtigen Spells bekommt, wo man dann wenigstens ein
bisschen metzeln kann. 

Zeigt mir die Zauberer, die sich mit Giftpfeil bis Stufe 6 durchschlagen... 

Was ist eigentlich mit der 'neuen' Zauberergilde, bevor da jetzt an der
bestehenden bei den Stufenanforderungen herumgedoktort wird?

Trug.

-----------------------------------------------------------------------------



Re^6: lehrlingsanforderungen: lvl 20? (Hight, 22. Sep 2001, 12:38:05):
~#! rn=Pale rt=1001098521 rg=gilden.zauberer
~#! tid=1001091494
ich find das oki auch wenn ich whitewiz dazu noch n paar lvl zuschachern
muesst

hight

-----------------------------------------------------------------------------



Re^4: lehrlingsanforderungen: lvl 20? (Gor, 22. Sep 2001, 13:37:20):
~#! rn=Nonne rt=1001093393 rg=gilden.zauberer
~#! tid=1001091494
Das erklaer mir mal Nonne. 100 Punkte sind doch 100 Punkte oder?

-----------------------------------------------------------------------------



Re^5: lehrlingsanforderungen: lvl 20? (Croft, 22. Sep 2001, 13:39:34):
~#! rn=Gor rt=1001158640 rg=gilden.zauberer
~#! tid=1001091494
5 Level questen geht nun mal schneller als 5 Level metzeln ;-)
Gruss Croft

-----------------------------------------------------------------------------



Re^5: lehrlingsanforderungen: lvl 20? (Nonne, 22. Sep 2001, 13:39:56):
~#! rn=Gor rt=1001158640 rg=gilden.zauberer
~#! tid=1001091494
Das ist folgendermassen: Wenn man hoeher ist, hat man schon allerhand Quest,
viele FP und die einfachen Erstkills. Auch gibt es fuer XP weniger
Stufenpunkte. Frag mal Elendil, wieso er nicht in der gleichen Geschwindigkeit
weiterlevelt. Aber das war bestimmt ne Fangfrage, oder?

Nonne.

-----------------------------------------------------------------------------



Re^6: lehrlingsanforderungen: lvl 20? (Gor, 22. Sep 2001, 13:40:30):
~#! rn=Croft rt=1001158774 rg=gilden.zauberer
~#! tid=1001091494
Wer sagt, das du mit level 50 metzeln musst? Ich wuerde an deiner Stelle
nochma von vorne anfangen. 
Man tippe 'hilfe' ein.

Gor den Kopf schuettelnd.

-----------------------------------------------------------------------------



Re^7: lehrlingsanforderungen: lvl 20? (Pale, 22. Sep 2001, 14:00:14):
~#! rn=Gor rt=1001158830 rg=gilden.zauberer
~#! tid=1001091494
Hallo,
um ehrlich zu sein, stoeren mich die geaenderten Anforderungen nicht wirklich
sehr, da ich mit der Archie-Quest (so ich denn jemals jemanden finden sollte,
der da mitmacht) sowieso auf Lvl50 kommen muesste, reicht es fuer mich dann
aus, um auf Glvl9 hochzuklettern, aber ich verstehe durchaus die Meinung
vieler kleinerer Zauberer. Mir ging es da ganz aehnlich. Habe damals auch den
Fehler gemacht und bin mit Lvl5 der Gilde beigetreten (ich wurde damals von
vielen hohen aubis davor gewarnt. Warum wohl?) und habe mich dann wirklich
fast ein Jahr durch die diversen "einfachen" Quests quaelen muessen, um mein
Gildenlevel langsam erhoehen zu koennen. Es war nicht so einfach auf Glvl7 zu
kommen, und erst da fing der Spielspass langsam an.
Mal ehrlich, wer nutzt von den hoeheren Zaubis den Giftpfeil-Spell? Als
kleiner Zauberer hat man doch nur die Hoffnung ein paar NPCs mit Zwingtanz
solange zum Lachen zu bringen, bis sie freiwillig zu Lars marschieren ... Die
guten Sprueche bekommt man jedenfalls fruehestens mit Glvl7.
Das die Anforderungen jetzt soweit nach oben geschraubt wurden, kann durchaus
eine Abschreckung fuer unseren Nachwuchs sein und wer soll dann spaeter mal
bei Briesel & Co. vorbeischauen? Ich faend es besser, wenn die unteren Glvl so
bis lvl7 etwas geringere Anforderungen haben ... Mit Glvl8 kann man ann ja
schon richtig was wegraeumen, ergo faend ich lvl40 und Seher ok (ausserdem
dauert es sowieso ewig von Glvl7 auf Glvl8 :-)

Ich verstehe auch nicht so recht, warum jetzt auf einmal wieder o viel an der
Gilde geschraubt wird, wo doch angeblich eine neue Zaubigilde in Arbeit ist.

Pale (gruebelnd und trotzdem noch zufrieden)

-----------------------------------------------------------------------------



Re^8: lehrlingsanforderungen: lvl 20? (Orktoeter, 22. Sep 2001, 14:05:19):
~#! rn=Pale rt=1001160014 rg=gilden.zauberer
~#! tid=1001091494
Bei den Zauberern faengt der Spielspass erst ab GL7 an?

Ich hoffe mal, das sehen nicht alle Zauberer so.

(mein Kaempferzweiti hat von Anfang an spass gemacht, auch wenn es da nicht
"tolles metzeln" sondern mehr das "Gildenfeeling" ( Ausbilder, fumbles) war.

OrkT.

-----------------------------------------------------------------------------



Re^9: lehrlingsanforderungen: lvl 20? (Gnome, 22. Sep 2001, 14:06:21):
~#! rn=Orktoeter rt=1001160319 rg=gilden.zauberer
~#! tid=1001091494
trves!=zauberer

-----------------------------------------------------------------------------



Re^10: lehrlingsanforderungen: lvl 20? (Pale, 22. Sep 2001, 14:07:35):
~#! rn=Gnome rt=1001160381 rg=gilden.zauberer
~#! tid=1001091494
Tja, so eine aehnlihe Ausbildung haette ich mir bei den Zaubis auch
gewuenscht. Aber man lernt schnell, dass man sich allein kuemmern muss
(leider).

Pale

-----------------------------------------------------------------------------



Re^11: lehrlingsanforderungen: lvl 20? (Pale, 22. Sep 2001, 14:10:52):
~#! rn=Pale rt=1001160455 rg=gilden.zauberer
~#! tid=1001091494
zum Spielspass gehoert nun mal auch das metzeln und das konnte man bis glvl7
vergessen ... veruch mal paar andere NPCs als Kaninchen auf der Hochebene mit
Wasserwandlung und Zwingtanz zu beeindrucken ...

nochmal Pale

-----------------------------------------------------------------------------



Re^12: lehrlingsanforderungen: lvl 20? (Anatol, 22. Sep 2001, 14:52:17):
~#! rn=Pale rt=1001160652 rg=gilden.zauberer
~#! tid=1001091494
Vielleicht sollten die hier diskutierenden Trves und Kleriker die
Anforderung "Spielerlevel" als Sicherung sehen. Ein normaler Zauberer
- also ein Zauberer, der zufaellig KEIN Zweitie ist und auch nicht von
einem Freund ein Paket zum Hochscripten bekommen hat - muss irgendwie 
zu Praxis kommen. Hohe Levelanforderungen sorgen dafuer, dass der 
Zauberer eben nicht nur in der Kneipe steht und "wille-wille-wille"
vor sich hinmurmelt, sondern einem taeglichen Leben nachgehen muss.
Ich halte den Spielerlevel fuer eine deutlich bessere Anforderung als
z.B. bestimmte Quests vorzuschreiben.

Ein langer Leidensweg gehoert zur Zauberei. Natuerlich waeren Konzepte,
die das Lernen sinnvoller gestalten, nicht schlecht, das weiss auch
Patryn. Und - ehrlich! - ihr duerft ihm gern eure genialen Gedanken,
fuer die wir anderen zu bloede sind, mailen. Im Zweifelsfall doch
gleich mit Implementierung, kann ja so schwer gar nicht sein, stimmt
doch, oder?

Was mit den Scriptkiddies ist, die diese Gilde mit Zweities bevoelkern 
und von der Zauberei nicht wirklich Ahnung haben.... Da fallen sicher
irgendwem ein paar Gemeinheiten ein.

Anatol

-----------------------------------------------------------------------------



Re^7: lehrlingsanforderungen: lvl 20? (Matis, 22. Sep 2001, 14:58:23):
~#! rn=Gor rt=1001158830 rg=gilden.zauberer
~#! tid=1001091494
Gor, du weisst selber ganz genau, dass es mit zunehmender Zeit immer
schwieriger wird, neue Stupse zu erhaschen.

Matis

-----------------------------------------------------------------------------



Re^8: lehrlingsanforderungen: lvl 20? (Anacrion, 22. Sep 2001, 15:00:59):
~#! rn=Matis rt=1001163503 rg=gilden.zauberer
~#! tid=1001091494
Da es allein 3000 AP gibt, sollte es ein leichtes sein, LVL50 oder 60
erreichen zu koennen, wenn man will.

anac*

-----------------------------------------------------------------------------



Re^9: lehrlingsanforderungen: lvl 20? (Humni, 22. Sep 2001, 15:40:17):
~#! rn=Anacrion rt=1001163659 rg=gilden.zauberer
~#! tid=1001091494
Ich kenn die gilde nicht wirklich. Ich hab aber innerhalb von SEHR kurzer zeit
meinen Zweitie auf Level 8 hochgeskriptet (sehr kurz im Vergleich zu anderen
Gilden). Wenn ich sehe, dass er damit einen Level unter dem mximum ist, und
andererseits sehe, welche Arbeit in meinem Kaempfer und meinem Tanjian
stecken, die relativ gesehen noch nicht so hoch sind, stimmt tatsaechlich was
nicht.

Jedenfalls finde ich eine Anforderung wie ,Seher' oder auch tatsaechlich
,Level' erheblich besser als die Anforderung ,Archie-Quest', nicht jeder hat
mal eben 16 Stunden (Erahrungsbericht..) Zeit, und findet dann noch 2 Leute
die mitmachen. Und mal im Ernst: Die ,tm <freund_mit_archiskript> ich bracuh
da mal eben...' - Methode ist wirklich das einzige, was dabei rauskommt.

Was ich andererseits verstehen kann ist, dass andere Gilden mit entsprechendem
Level besser sind..vielleicht sollte man da mal was dran aendern. Nein, ich
kenn die Gilde zu wenig, um dazu was zu sagen.

Humni

-----------------------------------------------------------------------------



Re^13: lehrlingsanforderungen: lvl 20? (Seno, 22. Sep 2001, 19:16:54):
~#! rn=Anatol rt=1001163137 rg=gilden.zauberer
~#! tid=1001091494
"Ein langer Leidensweg gehoert zur Zauberei" ... soll das jetzt eine Gilde
fuer Masochisten werden ?

Ich stimme mit Dir ueberein, dass es, wie Du dargelegt hast, Gruende gibt, die
fuer hoehere Levelanforderungen sprechen. Nur muesste dann auch dafuer gesorgt
sein, dass die Zauberer auch in den unteren Gildenstufen (bis einschliesslich
6) spielbar sind, d.h. mit den Spruechen, die sie bis dahin koennen, und mit
den Ruestungen, die sie noch tragen duerfen, im Kampf genuegend ausrichten
koennen. Denn eine Gilde fuer Masochisten will ich wirklich nicht.

Nach wie vor bin ich aber der Meinung, dass die Stufenanforderungen bis
einschliesslich GL 7 so bleiben sollten, wie sie waren. Einem Zauberer ist der
Waffenkampf so gut wie verschlossen, was bedeutet, dass der gesamte Bereich
Waffen kennen lernen, ausprobieren und darin Skills lernen und steigern,
wegfaellt. Aehnlich, aber weniger schlimm ist es bei den Ruestungen bis man GL
7 erreicht und dann wieder fast alle Ruestungen verwenden kann, weil man sie
anpassen kann (wobei sie abgeschwaecht werden). Als Gegenstueck zum
Waffenkampf haben die Zauberer ihre Sprueche, die bringen bei dieser Gilde den
Spielspass. Deshalb waere die Gilde mit den neuen Stufenanforderungen, so sehe
ich das nach wie vor, fuer kleine und mittlere Spieler mehr als unattraktiv.

Bei den Tanjian hat das (so wie ich es mitgekriegt hab) dazu gefuehrt, dass es
nur relativ wenige "echte" Tanjians (Ersties) gibt, weil die Gilde mit ihren
Stufenanforderungen eher fuer Zweities interessant ist, die diese Stufen
ziemlich schnell hochspielen koennen.

Nebenbei ist ein Blick in die Historie interessant: Vor einigen Jahren konnte
man noch mit Stufe 20 Seher werden, jetzt soll das in manchen Gilden die
Vorraussetzung fuer Gildenstufen sein, die noch nicht mal die Haelfte des
Gildenpotenzials bieten ? Sollte es nicht zu einem Mehr an Spielspass fuehren,
dass das MG waechst, statt zu Anforderungen, die diesen vergaellen ?

Seno

PS: Anacrion, dass Dein L15/GL7-Zaubererzweitie staerker ist, als L15-Figuren
anderer Gilden, glaub ich Dir auch gern. Aber dazu hat Gn0me einen Artikel
geschrieben, den zu lesen sehr gut getan hat. Ich komm jedenfalls nicht mal
mit meinem L20/GL8-Zauberer aus eigener Kraft an Hand-Komponenten, weiss aber,
wie gut es sich damit kaempft, seitdem ich mal einen Posten geschenkt bekommen
hab.

-----------------------------------------------------------------------------



Re^14: lehrlingsanforderungen: lvl 20? (Anacrion, 22. Sep 2001, 19:20:54):
~#! rn=Seno rt=1001179014 rg=gilden.zauberer
~#! tid=1001091494
Also ich sehe das so, dass auch bei anderen Gilden die Seheranforderung fuer
ein LEvel, das nur die haelfte der Kampfkraft bietet, da ist. Die Frage ist
nicht,, WIE man es macht, sondern dass es in allen gilden gleich ist und nciht
ZU hart.

anac*

P.S. Seno, JEDER L17/GL7-Zauberer ist staerker als die Counterparts anderer
Gilden.Hand, xhand, feuerball, rausche, befriede, huelle, schutz, rueste,
wille, identifiziere, finde .. also fast alles, was man so braucht (ausser den
lvl8-spruechen, die grade noch 6 sind) kann man. Er ist von sich aus so stark,
nihc tdadurch dass andere ihm helfen.

-----------------------------------------------------------------------------



Re^15: lehrlingsanforderungen: lvl 20? (Arek, 22. Sep 2001, 22:07:22):
~#! rn=Anacrion rt=1001179254 rg=gilden.zauberer
~#! tid=1001091494
Ich hab das so gemeint, dass L 20 mal die Stufe war, mit der man Seher werden
konnte. Jetzt kann man in manchen Gilden mit dieser Stufe weit weniger als die
Haelfte des Gildenpotenzials ausschoepfen. Bei Gildenpotenzial denke ich dabei
sowohl an die Anzahl der Faehigkeiten, als auch ihre Qualitaet und wie gut man
sie bis dahin lernen kann.

Beim anderen Punkt bin ich mir nicht ganz sicher, denke aber, dass Du Unrecht
hast. Beim Zauberer steigert man zuerst die Intelligenz, damit man nicht noch
laenger ueben muss. Das geht auf Kosten der Attribute Staerke und Ausdauer und
mit sehr guten Waffen und Ruestungen ist man Hand (incl. XHand) und Schutz
ueberlegen, weil diese Sprueche mit L15/GL7 noch nicht allzu stark sind. Aber
wenn Du die optimal unterstuetzenden Ruestungsteile hast + Handkompos sieht
das ganz anders aus. An diese Dinge kommt man aber mit dieser (Gilden-)Stufe
nicht allein. Von den Spruechen, die Du genannt hast, lohnen sich im Kampf in
den allermeisten Faellen nur bei Hand, XHand und Schutz die Spruchkosten, also
erwecke mit so einer Aufzaehlung bei nicht-gildenbewanderten nicht den
Eindruck, dass das mords viel Staerke bedeuten wuerde.

Eigentlich finde ich es muessig, solche Diskussionen zu fuehren, denn das ist
mir einfach zu viel Hick-Hack.

Seno

-----------------------------------------------------------------------------



Re^16: lehrlingsanforderungen: lvl 20? (Grimmborn, 22. Sep 2001, 22:11:21):
~#! rn=Arek rt=1001189242 rg=gilden.zauberer
~#! tid=1001091494
Wenn ich vielleicht als jemand, der tatsaechlich die Grenze von level 20 fuer
die Seherwerdung noch miterlebt hat (auch wenn kurz vor meiner Seherwerdung
die AP-Grenze eingefuehrt wurde): Was man damals mit level 19 konnte entsprach
eher knapp der Haelfte dessen, was die Top-Seher hingelegt haben. Was also
genau ist Dein Argument?

GdA

-----------------------------------------------------------------------------



Re^16: lehrlingsanforderungen: lvl 20? (Anacrion, 22. Sep 2001, 22:43:51):
~#! rn=Arek rt=1001189242 rg=gilden.zauberer
~#! tid=1001091494
Wenn Du der Meinung bist, mit LVL20/8 schwach zu sein, Arek/Seno, dann wuerde
ich sagen, Du solltest Dir das MUD besser angucken und mal testen, was Deine
Sprueche so koennen. mein LVL15/7 schafft den grossen Schlagring nackt zu
holen und div. andere Dinge auch.

anac*

-----------------------------------------------------------------------------



Re^17: lehrlingsanforderungen: lvl 20? (Bielefeld, 22. Sep 2001, 22:46:12):
~#! rn=Anacrion rt=1001191431 rg=gilden.zauberer
~#! tid=1001091494
Mit der Orts- und Featurekenntnis eines nahezu Level-100-Spielers
kein Problem... nur sollte man selbst gefundenes (oder doch nur gezeigt
bekommenes) nicht gleich von allen anderen Mitspielern erwarten.

-Bielefeld (kann sich noch an einen ziemlich kleinen Zaubi namens
Anacrion erinnern...)

P.S.: Gibts hier was fuer Re^100 ?

-----------------------------------------------------------------------------



Re^18: lehrlingsanforderungen: lvl 20? (Anacrion, 22. Sep 2001, 22:48:54):
~#! rn=Bielefeld rt=1001191572 rg=gilden.zauberer
~#! tid=1001091494
Ich kann mich an andere (Erstie-)ZAuberer mit GL7 erinnern, die in der neuen
FE locker zerstaeubt haben und so .... 

Ausserdem: Genau das ist es doch, was ich will Biele: Dass man mit LVL7
Ortskenntnis hat und LVL8, und nicht mit LVL20 in LVL8 ist (wie Seno) und
keinen Plan hat (was ich von Seno nicht weiss). Um zu leveln erwirbt man doch
zumindest etwas Ortskenntnis.

anac*

-----------------------------------------------------------------------------



Re^18: lehrlingsanforderungen: lvl 20? (Anatol, 22. Sep 2001, 23:55:39):
~#! rn=Bielefeld rt=1001191572 rg=gilden.zauberer
~#! tid=1001091494
Und genau das ist der Punkt, Bielefeld. Ein Zauberer mit Gildenlevel
7 besitzt, rein von seinen gildentechnischen Moeglichkeiten, schon 
ein ziemliches Potential. Davon weiss der Otto-Normal-Zaubererzweitie
natuerlich nichts und daran wird man auch nichts aendern koennen 
(wobei sich Patryn sicherlich fuer gute gemailte Vorschlaege bedanken
wuerde). Aber ein Zauberer-Erstie, der durch die hoehere Stufe dazu
angehalten wird, gefaelligst mit offenen Augen durchs Leben zu gehen,
wenn er seinen Schatz an Gildenfaehigkeiten signifikant vergroessern
moechte, der hat gute Chancen, wirklich Gefuehl fuer "seine" Gilde
zu entwickeln.

Nicht dass Zweities das nicht auch koennten, um Himmels Willen, ich 
will da nicht ungerechtfertigt pauschalisieren. Aber es verlangt ein
gewisses Mass an Disziplin. Und das hat nicht jeder von der Staerke 
seines Ersties verwoehnte Neuzauberer. Und Skriptkiddies schon gleich
gar nicht.

Anatol


-----------------------------------------------------------------------------



Re^19: lehrlingsanforderungen: lvl 20? (Arek, 23. Sep 2001, 02:05:17):
~#! rn=Anatol rt=1001195739 rg=gilden.zauberer
~#! tid=1001091494
Hallo Anatol und Anacrion,

ich verstehe euch jetzt besser und stimme mit eurem Ziel ueberein.

Nur denke ich, dass die hoeheren Spielerstufenanforderungen eher das Gegenteil
bewirken werden. Das fuehrt doch dazu, dass Questen noch eher als bisher als
laestiges Hindernis auf dem Weg zu dem, was man erreichen moechte, naemlich
die naechste Gildenstufe, empfunden werden. Egal, ob man auf Kampfstaerke aus
ist oder weil man einfach Spass am Zaubern hat. Das bedeutet dann, dass
Questen noch mehr als bisher zu etwas werden, was man versucht, schnell hinter
sich zu bringen, statt sie wirklich zu spielen und zu erleben. Und
Ortskenntnis erlangt man dabei wenig, auch weil man sich dann nicht einfach
zwischen Questen mal Zeit nimmt, sich umzuschauen und neue Gebiete zu
erkunden.

Ich wollte auch in der Gilde nicht nur deshalb schnell weiter kommen, weil mir
das Zaubern Spass macht, sondern auch, weil ich die Gilde, die Sprueche und
ihre Moeglichkeiten kennenlernen und sozusagen im taeglichen Gebrauch ueben
wollte, statt stupide um des (langwierigen) Skillsteigerns willen. Ich freu
mich z.B. ueber jede neue unterstuetzende Ruestung, die ich entdecke. Dazu
muss ich die Sprueche aber benutzen koennen !

Und wenn ich mit L20 / GL8, wie man mir jetzt erklaert hat, noch lang nicht
das Potenzial ausschoepfe, das mir theoretisch moeglich waere und auch WEIT
davon entfernt bin, in der FE zu zerstaeuben (ich komm ueber zu Brei schlagen
nicht hinaus und das hab ich hoechst selten), liegt das daran, dass fuer mich
auch das Erforschen der Gildenmoeglichkeiten eine reizvolle Herausforderung
ist, waehrend andere dagegen offenbar nach guten Informationsquellen streben.
Aber wie gesagt, solche Informationsquellen werden umso noetiger, je
unzumutbarer es wird, sich das Wissen oder irgendwelche Anforderungen
selbststaendig zu erspielen.

Zu Grimmborn: Ich wollte damit sagen, dass das ueber Jahre stark gewachsene
Mud doch mehr Spielspass bringen sollte, statt weniger Spass durch staendig
steigende Anforderungen, wie das vor allem bei manchen Gilden der Fall ist.
Und da fand ichs eben interessant, dass man jetzt bei den Tanjian und
Zauberern fuer relativ kleine Gildenstufen Anforderungen stellt, die frueher
mal zur Seherwerdung genuegten.

Seno

-----------------------------------------------------------------------------



Re^20: lehrlingsanforderungen: lvl 20? (Anatol, 23. Sep 2001, 02:06:47):
~#! rn=Arek rt=1001203517 rg=gilden.zauberer
~#! tid=1001091494
Wo genau war jetzt nochmal Dein Problem?

Anatol


-----------------------------------------------------------------------------



Re^21: lehrlingsanforderungen: lvl 20? (Wurzel, 23. Sep 2001, 04:00:26):
~#! rn=Anatol rt=1001203607 rg=gilden.zauberer
~#! tid=1001091494
das problem nennt sich "allgemeine unzufriedenheit und jammerei". nichts was
wirklich neu waere hier...
ihr koennt froh sein, dass das nicht meine sache ist, sonst waere der
eintritt in die zauberergilde erst ab seherwerdung moeglich. genauso wie bei
den anderen "lieblingsgilden" hier.

wurzel

-----------------------------------------------------------------------------



Levelanforderungen (Srabi, 23. Sep 2001, 09:42:25):
Also, ich habe zwar keinen Zauberer, aber zumindest doch etwas Ahnung von der
Gilde.

Die Levelanforderungen, die hier disskutiert werden, sind ja wohl wahnwitzig
sondergleichen und logischerweise koennen diese auch noch von hohen Sehern
kommen, die eh nichts mehr zu befuerchten haben.

Was koennen denn die kleinen Zauberer, die auf den unteren Gildenleveln
sind...absolut nichts, denn ausser einen zusaetzlichen Hand haben die ja
nichts. Wie sollen diese denn die ganzen Metzelquests schaffen, ebenso die
Gildenquests???

Mir kommt das eher so vor, dass sich einige Zauberer vor der Zweitieflut in
der Gilde schuetzen wollen, denn ansonsten wuerden sie sich nicht ueber solche
Themen unterhalten. Genau diese Zauberer stopfen ihre Zweities in die
Klerikergilde und blockieren die oberen Raenge.

Gut, fuer Level 9 in der Gilde kann man ne Anforderung stellen, aber der Rest
ist absolut wahnsinnig.

Srabi, der sich dadurch mit Sicherheit keinen Zauberer einloggen wird!!!

-----------------------------------------------------------------------------



Re: Levelanforderungen (Liara, 23. Sep 2001, 12:32:37):
~#! rn=Srabi rt=1001230945 rg=gilden.zauberer
~#! tid=1001230945
Also, ich habe zwar keinen Zauberer, aber zumindest doch etwas Ahnung von der
Gilde.

Ahja, und woher?

ZZLB

P. S. : Wenn Du keinen Zauberer einloggen willst, dann ist das Dein
hoechsteigenes Problem. Ich war bis Level 38 (als ich Seher wurde)
Bierschuettler und habe Quests ohne Probleme geschafft. Und Du willst mir ja
wohl nicht erzaehlen, dass man mit einem Level 7-Zauberer schwaecher ist als
ein Schuettler. ;-)

-----------------------------------------------------------------------------



Re: Levelanforderungen (Anacrion, 23. Sep 2001, 15:23:39):
~#! rn=Srabi rt=1001230945 rg=gilden.zauberer
~#! tid=1001230945
Danke Srabi.

Dein Artiel hat gleich 3 Auswirkungen:

a) Du hast wieder mal Deine Enorme Kenntnis vom Mud bewiesen.
b) Du wirst (hoffentlich) keinen Zauberer ziehen,. wodurch wir von einer
weiteren Wurst verschont bleiben.
c) Du wirst Dich aufgrund des Ignoriere nicht mal drueber aergern.

MfG

anac*

-----------------------------------------------------------------------------



Re^22: lehrlingsanforderungen: lvl 20? (Seno, 23. Sep 2001, 16:39:26):
~#! rn=Wurzel rt=1001210426 rg=gilden.zauberer
~#! tid=1001091494
Die Zauberer jammern (von Ausnahmen abgesehen) nicht mehr. Das, womit sie sich
vor Jahren diesen Ruf eingehandelt haben, ist etwas ganz anderes. Damals
wollten die HLPs verhindern, dass ihre Kampfkraft beschnitten wird.
Diejenigen, die sich jetzt in der Gilde hochspielen wollen, greifen statt zu
jammern haeufig verstaerkt zu "effektiveren" Spielweisen, die mit Spielen und
Erleben im eigentlichen Sinn eines RPGs nichts zu tun haben. Durch weitere
Verschaerfungen, die das Vorankommen erschweren, wird diese Tendenz nur
verstaerkt und die Spirale dreht sich weiter (wie schon seit Jahren).
Alternativ koennten z.B. Skills und Sprueche erst bei L60 (um mal eine Zahl zu
nennen) gemaxt werden koennen. Damit koennte man das auch erreichen, worum es
hier eigtl. geht, naemlich dass dem ein Riegel vorgeschoben werden soll, dass
man "billig" und ohne grosse Mudkenntnis zu hoher Kampfkraft gelangen kann.

Aber mit Leuten wie dir zu diskutieren hat dir gegenueber wenig Sinn, da Du
einerseits, so wie sich mir das darstellt, derart von Hass gepraegt bist,
andererseits die Artikel in dieser Rubrik offensichtlich nur oberflaechlich
gelesen hast.

Seno

-----------------------------------------------------------------------------



Re^23: lehrlingsanforderungen: lvl 20? (Anacrion, 23. Sep 2001, 17:53:58):
~#! rn=Seno rt=1001255966 rg=gilden.zauberer
~#! tid=1001091494
Den letzten Absatz kannst Du getrost auf Dich selber anwenden.

anac*

-----------------------------------------------------------------------------



Re: Re: Levelanforderungen (Fantus, 23. Sep 2001, 23:04:22):
~#! rn=Anacrion rt=1001251419 rg=gilden.zauberer
~#! tid=1001230945
"b) Du wirst (hoffentlich) keinen Zauberer ziehen,. wodurch wir von einer
 weiteren Wurst verschont bleiben."

Hey, also an Deinem Arroganzlevel musst Du echt noch arbeiten, Anacrion. So
schaffste es nie zum Superseher! :>

-----------------------------------------------------------------------------



Re^3: Levelanforderungen (Patryn, 24. Sep 2001, 07:15:26):
~#! rn=Fantus rt=1001279062 rg=gilden.zauberer
~#! tid=1001230945
hi leute,

nachdem ich nun alle artikel zum thema gelesen habe, kann ich eigentlich
nicht behaupten, ich haette argumente gesehen die gegen die derzeitige
regelung sprechen wuerden...und das bestimmt nicht, weil ich auf teufel
komm raus eine meiner laenger geplanten aenderungen verteidigen wollte.
dass die inzwischen allgemein bekannten level 50 fuer GL 9 bzw. 75 fuer 10
 (wenn auch derzeit inaktiv) zusammen mit dem einstiegslevel von GL 2 zu
einer gewissen in der gilde verankerten GL-forderung fuer die entsprechenden
zwischenlevel fuehren, duerfte jedem klar sein.
ich glaub auch nicht wirklich, dass man ueber diese zahlen diskutieren
muss, schon gar nicht angesichts der mich ebenfalls aergernden
zu zahlreichen wurstzweities in magisterraengen.
ich persoenlich finde ja, eine ploertzliche forderung von 25 oder mehr
leveln in den hoeheren raengen ist weitaus demotivierender als ein
allmaehliches aber doch bestimmtes anziehen der forderung ueber alle GL
verteilt.
ich kann das metzelargument angesichts der phaenomenal vielen quests im
mud absolut nicht nachvollziehen, schon gar nicht fuer level 20.
und absolut naiv scheinen mir die vergleiche mit den frueheren
seheranforderungen, immerhin zu zeiten, wo man einen ganzs choen grossen
happen der damaligen quests haben musste, um level 20 ueberhaupt erreichen
zu koennen.
summa summarum...ihr koenntmich virtuell erdrosseln oder erscheissen,
die jetzige verteilung bleibt, sofern silvana da nicht zufaellig mal
vorbeischneit und mir was anderes suggeriert.
desweiteren bin ich nachwievor fuer den heiligen gral dankbar, der
scripten deutlich erschwert oder das jetzige lernsystem irgendwie so
abwandelt, dass eben nich so viel dumpfnasen zu leicht hohe raenge
erreichen und sich dann einbilden, sie muessten jetzt zum helden der
gilde gekuehrt werden, indem sie sich vorrangig mit nervenden spruechen
in zrufe verdient machen.

-- 
patryn

PS: vieleicht sollten manche weniger aggressiv nur darauf hin spielen,
    moeglichst schnell das gildenlevel zu pushen, denn das MG besteht aus
    weitaus mehr elementen.

-----------------------------------------------------------------------------



Re^4: Levelanforderungen (Cyldraig, 24. Sep 2001, 10:21:15):
~#! rn=Patryn rt=1001308526 rg=gilden.zauberer
~#! tid=1001230945
Koennte man nicht alle Levelanforderungen von Llystrathe ausgeben lassen?
Als ich endlich alle Zauber hoch genug fuer den Magister hatte und
dann nach drei Toden auch die Magisterpruefung bestand, fand ich die
Anforderung Archi-Quest doch ziemlich deprimierend.  Haette ich das
vorher gewusst, waer ich da wohl anders rangegangen.  Zumindest bei
mir fuehrte das dazu, dass ich auf Cyl keine Lust mehr hatte.
Jetzt darf ich dazu wieder wieder 13 Sprueche hochueben (und erzaehl mir
keiner er hat wasserwandlung im normalen mudden ohne explizites ueben
nebenbei gelernt).
Nicht so erfreut,
Cyldraig

-----------------------------------------------------------------------------



Re^5: Levelanforderungen (Patryn, 24. Sep 2001, 11:06:01):
~#! rn=Cyldraig rt=1001319675 rg=gilden.zauberer
~#! tid=1001230945
[ ] du kennst die zaubererfaq.
[ ] du musst noch viel ueber die gilde lernen.
[x] es ist offensichtlich gut, die anforderungen erhoeht zu haben.

-- 
patryn

-----------------------------------------------------------------------------



Re^3: fuer mirror (Pale, 24. Sep 2001, 11:18:50):
~#! rn=Anoris rt=1001275843 rg=allgemeines
~#! tid=1001275781
Ich bi auch nicht unbedingt sonderlich begeistert von den Aenderungen, aber
lasst es uns doch erstmal abwarten, ob es ueberhaupt so einschneidende
Aenderungen sind.

Ausserdemwar das doch von Patryn alles geplant nur um den durchschnittlichen
Jammerskill der Gilde knapp auf Max zu bringen (hat ja wohl funktioniert).

Pale (will auch virtuell mitjammern)

-----------------------------------------------------------------------------



Re^4: Levelanforderungen (Seno, 24. Sep 2001, 11:56:44):
~#! rn=Patryn rt=1001308526 rg=gilden.zauberer
~#! tid=1001230945
Naja, ich denke, dass Du und andere sich einfach (mittlerweile) schlecht in
einen Neueinsteiger hineinversetzen koennen. Ich wuerde jedenfalls unter den
neuen Bedingungen jedem davon abraten, unter L20 der Gilde beizutreten. Und an
diesen 20 Stufen habe ich etwa 3 Jahre gespielt, nachdem ich nicht soo
intensiv spiele und mir mein Vorankommen auch weitgehend selbst erspielen
wollte. (Nicht weil ich hier der Einsiedler waere, ich kenne etliche Leute.)
Wenn ich jedenfalls heute neu hier einsteigen wuerde, wuerde ich mir
wahrscheinlich nach kurzer Zeit ein anderes Mud suchen, in dem ich nen
Zauberer dann nicht nur theoretisch spielen koennte.

Andererseits hat mich natuerlich auch die Gilde viel Zeit gekostet, dazu
fuehlte ich mich aber auch gedraengt, weil ich z.B. fuer Gildenquesten zu
schwach war, die fuer meinen Gildenlevel eingestuft waren, oder weil ich mich
allgemein bzgl. Kampfkraft anderen gegenueber noch benachteiligt fuehlte.

Einem ploetzlichen, grossen Sprung in der Levelanforderung koennte man auch
begegnen, indem man z.B. GL 8 zwar schon ab Spielerstufe 20 zulaesst, dann
aber erst zwei Sprueche lernen kann. Die anderen 4 (GL 8 enthaelt zum Teil
sehr starke Sprueche) koennte man dann Stueck fuer Stueck freigeben.
Schattenkaempfer sollte aber mit L20 moeglich sein, schliesslich hat man bis
dahin schon eine Menge in die Gilde reingesteckt.

Mit dem Hinweis darauf, dass man in der Anfangszeit des Muds mit L20 Seher
werden konnte, wollte ich nur verdeutlichen, in welchen Regionen sich die
neuen Anforderungen bewegen. Man muss die 20 Stufen ja damals wie heute erst
mal hochspielen.

Seno

-----------------------------------------------------------------------------



Re^5: Levelanforderungen (Seno, 24. Sep 2001, 12:30:47):
~#! rn=Seno rt=1001325404 rg=gilden.zauberer
~#! tid=1001230945
Nachtrag: Statt "GL8 enthaelt _zum Teil_ sehr starke Sprueche" ist
_groesstenteils_ richtig. Ich korrigiere das hiermit, nicht dass deshalb jmd.
meint, mich in der Luft zerreissen zu muessen ;-)

Seno

-----------------------------------------------------------------------------



Re^6: Levelanforderungen (Grimmborn, 24. Sep 2001, 13:18:57):
~#! rn=Seno rt=1001327447 rg=gilden.zauberer
~#! tid=1001230945
Sicher musste man die 20 Stufen damals ebenso hochspielen wie heute. Mit ein
paar Unterschieden: Weniger Auswahl, was die AP angeht (damals gabs rund 1000
APvon denen man ~750 brauchte, bis level 19 galten nur die EP als
Aufstiegsbedingung. Level 20 war automatisch Seher), und unterschiedliche
EP-Rate. Damals waren, nachts, also ohne lag und bei quasi leerem mud und
maximaler Ausruestung, fuer Top-Seher rund 50k/Stunde drin. Und das war dann
schon gewaltig Stress. Korrigier mich wenn ich das falsch sehen sollte, aber
ist das nicht eine Rate ueber die man heute nur noch laecheln kann?

Grimm"frueher war alles bess^Wanders"born der Atheist

-----------------------------------------------------------------------------



Re^5: Levelanforderungen (Anacrion, 24. Sep 2001, 13:48:32):
~#! rn=Seno rt=1001325404 rg=gilden.zauberer
~#! tid=1001230945
20 LVL waren damals als ich mit dem MG anfing schon nur eine Sache von 3
Wochen ... oder 5 ... und offensichtlich ist Deine MUDkenntnis mit LVL20 nicht
hochgenug um aus deinem LVL(-Zauberer was rauszuholen.

Ich wuerde Dir dringen raten, zu Questen und zu Forschen.

anac*

-----------------------------------------------------------------------------



Re^6: Levelanforderungen (Grimmborn, 24. Sep 2001, 14:54:40):
~#! rn=Anacrion rt=1001332112 rg=gilden.zauberer
~#! tid=1001230945
Hmm, ja. Das erinnert mich an Zardoz' Wette, mit einem neu eingeloggten
Charakter in unter 10 min Titwu zu spielen. Er hats geschafft. Ohne frontend,
Skripte oder Hilfe anderer Spieler.

GdA

-----------------------------------------------------------------------------



Re^7: Levelanforderungen (Grimmborn, 24. Sep 2001, 14:55:06):
~#! rn=Grimmborn rt=1001336080 rg=gilden.zauberer
~#! tid=1001230945
Ach so, als Nachtrag: das war so Mitte 1994.

GdA

-----------------------------------------------------------------------------



Re^8: Levelanforderungen (Varlarion, 24. Sep 2001, 14:56:14):
~#! rn=Grimmborn rt=1001336106 rg=gilden.zauberer
~#! tid=1001230945
vielleicht solltest du dazu schreiben, dass die quest seitdem massiv
entschaerft wurde? dieses dschungel-labyrinth gibt es nicht mehr...

-----------------------------------------------------------------------------



Re^8: Levelanforderungen (Householder, 24. Sep 2001, 14:58:30):
~#! rn=Grimmborn rt=1001336106 rg=gilden.zauberer
~#! tid=1001230945
was genau ist bemerkenswert daran, eine quest, fuer die man nicht metzeln muss
und die man schon kennt, mit einem newbie in 10 minuten zu spielen ? 

-----------------------------------------------------------------------------



Re^9: Levelanforderungen (Grimmborn, 24. Sep 2001, 15:38:51):
~#! rn=Householder rt=1001336310 rg=gilden.zauberer
~#! tid=1001230945
Wie Varlarion schrieb: Seitdem ist das Dschungellabyrinth mit den Tigern
anscheinend entschaerft worden. Ausserdem ist mir nicht klar was metzeln mit
Geschwindigkeit zu tun haben soll - Titiwu ist (oder war zumindest) eine eher
umfangreiche quest. Du bist gerne eingeladen mit einem neu, nur ueber telnet
eingeloggten Spieler das nachzumachen. Sag Bescheid, ich nehme dann die Zeit.

GdA

-----------------------------------------------------------------------------



Re^10: Levelanforderungen (Humni, 24. Sep 2001, 16:43:15):
~#! rn=Grimmborn rt=1001338731 rg=gilden.zauberer
~#! tid=1001230945
Die Herausforderung nehme ich wohl an. Ich spiel Titiwu zwar immer mit tf,
brauch das aber nicht dafuer.

Humni

-----------------------------------------------------------------------------



Re^11: Levelanforderungen (Grimmborn, 24. Sep 2001, 16:47:26):
~#! rn=Humni rt=1001342595 rg=gilden.zauberer
~#! tid=1001230945
OK, ich hab abends oder am WE Zeit mir das anzugucken. Aber nicht Di ab 22
Uhr, da kommt Ally.

GdA

-----------------------------------------------------------------------------



Re^12: Levelanforderungen (Muadib, 24. Sep 2001, 16:56:17):
~#! rn=Grimmborn rt=1001342846 rg=gilden.zauberer
~#! tid=1001230945
welche version war das nun genau ?

-----------------------------------------------------------------------------



Re^13: Levelanforderungen (Humni, 24. Sep 2001, 16:57:01):
~#! rn=Muadib rt=1001343377 rg=gilden.zauberer
~#! tid=1001230945
Also wers nicht glauben mag:

finger titiwuman

Ist noch nicht markiert, sorry.

Ich machs auch gerne nochmal vor.

Humni

-----------------------------------------------------------------------------



Re^13: Levelanforderungen (Grimmborn, 24. Sep 2001, 16:57:21):
~#! rn=Muadib rt=1001343377 rg=gilden.zauberer
~#! tid=1001230945
Vierte Season, wenn ich das richtig zaehle. Immer Dienstags gegen 22 Uhr auf
Vox.

GdA

-----------------------------------------------------------------------------



Re^14: Levelanforderungen (Grimmborn, 24. Sep 2001, 16:58:17):
~#! rn=Humni rt=1001343421 rg=gilden.zauberer
~#! tid=1001230945
Ich stell Dir dann bei Gelegenheit nach Absprache einen Spieler in die AG. Wir
wollen doch nicht dass der schon eine Handvoll aliase aus Versehen
vorgearbeitet hat, nein? ;-)

GdA

-----------------------------------------------------------------------------



Re^14: Levelanforderungen (Boing, 24. Sep 2001, 16:58:23):
~#! rn=Grimmborn rt=1001343441 rg=gilden.zauberer
~#! tid=1001230945
Ich glaub es ging um die Version von Titiwu ... da gibts ja auch schon
drei verschiedene. Die vierte ist aber demnaechst nicht geplant.
Um Chancengleichheit beim 10-Minuten-Test zu garantieren kann ich 
gerne noch an verschiedenen Stellen auf Titiwu den alten Tiger clonen. :)
  Boing

-----------------------------------------------------------------------------



Re^15: Levelanforderungen (Anatol, 24. Sep 2001, 17:00:01):
~#! rn=Boing rt=1001343503 rg=gilden.zauberer
~#! tid=1001230945
Das mit den Aliasen, Grimmborn, ist witzlos. Der rumsuch-Dschungel, in 
dem man je Raum 8-9 Details anschauen musste, ist Vergangenheit.


-----------------------------------------------------------------------------



Re^16: Levelanforderungen (Boing, 24. Sep 2001, 17:00:35):
~#! rn=Anatol rt=1001343601 rg=gilden.zauberer
~#! tid=1001230945
Das war die zweite Version ... davor konnte man den Dschungel ja sogar
kartografieren.
  Boing

-----------------------------------------------------------------------------



Re^17: Levelanforderungen (Anacrion, 24. Sep 2001, 17:05:27):
~#! rn=Boing rt=1001343635 rg=gilden.zauberer
~#! tid=1001230945
Ja. Mit Karten geht der ganze Spass verloren ...

anac* fragt: wo bin ich?

-----------------------------------------------------------------------------



Re^19: Levelanforderungen (Varlarion, 24. Sep 2001, 17:06:11):
~#! rn=Anatol rt=1001343947 rg=gilden.zauberer
~#! tid=1001230945
Varlarion denkt: . o O (so moecht ich nicht enden...)

-----------------------------------------------------------------------------



Re^19: Levelanforderungen (Foobar, 24. Sep 2001, 17:18:20):
~#! rn=Anatol rt=1001343955 rg=schmarrn
~#! tid=1001230945
Hallo.

Keine Ahnung auf wen ich hier antworte, ist mir auch egal.

So. Die Anforderungen fuer Gildenlevel sind also erhoeht worden, weil einem
der hochgeschaetzten Gildenmagier zu viele Wuerste in den oberen Raengen
existieren.

So weit, so gut.

Ich haette es nur fuer fair gehalten, wenn die - laut den neuen Definitionen -
bereits existierenden Wurstmagister dann auch abgestuft werden und ihre
Gildenlevel verlieren. Zwar war es frueher weitaus schwerer, auf diese Level
zu kommen, da scheinen sich ja alle einig zu sein, es ist aber genauso ein
Pappenstiel die neuen Level durch etwas Forschen, Questen und Metzeln zu
erreichen, da scheinen sich auch alle einig zu sein.

Am sinnvollsten hielte ich persoenlich dynamische Anforderungen fuer
Gildenlevel, und zwar nicht nur bei den Zaubereren, sondern bei allen Gilden.
Ich koennte mir gut vorstellen, dass man z.B. Magister oder General nur werden
kann, wenn man jeweils 2/3 der FPs des Spielers mit den meisten FPs hat, 2/3
der XP des Spielers mit den hoechsten XP hat, 2/3 der Stufen des Spielers mit
den meisten Stufen hat und 2/3 der EK (laut Plakette) des Spielers mit den
meisten EK hat.

Leider habe ich keine Ahnung, wie schwer das zu implementieren ist.

Foobar

PS: Questpunkte habe ich oben bewusst weggelassen, weil man eh 80% fuer den
Seher braucht.

-----------------------------------------------------------------------------



Re^20: Levelanforderungen (Elendil, 24. Sep 2001, 17:30:36):
~#! rn=Foobar rt=1001344700 rg=gilden.zauberer
~#! tid=1001230945
Veto :) !

Also das an einem Spieler festzumachen finde ich ziemlich unangenehm. D.h.
wenn ich ein neues Monster finde, steigen bei anderen die Anforderungen fuer
den Gildenlevel??? Ne, bitte nicht! Wenn bitte mit Durchschnittswerten.

Dynamisches System find ich trotzdem gut. Ein Char sollte den Gildenlevel
haben, dessen Anforderungen er erfuellt, stimme ich zu, Foobar.

CU, Elendil

-----------------------------------------------------------------------------



Re^20: Levelanforderungen (Patryn, 24. Sep 2001, 18:04:55):
~#! rn=Foobar rt=1001344700 rg=gilden.zauberer
~#! tid=1001230945
na wie gut dass manche alte sprichwoerter nie an gueltigkeit verlieren
...wau wau...
zum konstruktiven teil des postings zumindest:
  gildenanforderungen sind gildensache.
ich halte da nichts von einem zu grossen gemeinsamen nenner.
nichtsdestotrotz kommt irgendwann ein dynamisches system, gemeinsam mit
der umkrempelung der gildenquests, nur hab auch ich abundzu ein paar
pflichtveranstaltungen im rl-mud.

-- 
patryn

-----------------------------------------------------------------------------



Re^16: Levelanforderungen (Gnome, 24. Sep 2001, 18:15:34):
~#! rn=Anatol rt=1001343601 rg=gilden.zauberer
~#! tid=1001230945
und selbst wenn, kostet dich es 3 sek., alle aliase zu erstellen.
rechne halt 3 sek. zu der zeit zu.
kannst du doch, oder?

gnOme

-----------------------------------------------------------------------------



Re^17: Levelanforderungen (Humni, 24. Sep 2001, 18:16:28):
~#! rn=Gnome rt=1001348134 rg=gilden.zauberer
~#! tid=1001230945
Klar. Man muss sowieso erst mit dem Floss nach Titiwu, man hat viel viel viel
Zeit.

Humni

-----------------------------------------------------------------------------



Re^18: Levelanforderungen (Boing, 24. Sep 2001, 18:19:59):
~#! rn=Humni rt=1001348188 rg=gilden.zauberer
~#! tid=1001230945
Mit dem Floss? Das dauert doch viel zu lang. Du hast offensichtlich
noch ne Menge Potential fuer bessere Zeiten ... :)
  Boing

-----------------------------------------------------------------------------



Re^19: Levelanforderungen (Fantus, 24. Sep 2001, 18:27:58):
~#! rn=Boing rt=1001348399 rg=gilden.zauberer
~#! tid=1001230945
Hehe, Friedhofsquest 30 Sekunden nach Erstlogin ? :)

*in Deckung geh*

-----------------------------------------------------------------------------



Re^20: Levelanforderungen (Grimmborn, 24. Sep 2001, 18:29:20):
~#! rn=Fantus rt=1001348878 rg=gilden.zauberer
~#! tid=1001230945
Ohne Hilfe kaum.

GdA

-----------------------------------------------------------------------------



Re^21: Levelanforderungen (Boing, 24. Sep 2001, 18:30:10):
~#! rn=Grimmborn rt=1001348960 rg=gilden.zauberer
~#! tid=1001230945
Und nicht mal mit Script ... :)
  Boing

-----------------------------------------------------------------------------



Re^22: Levelanforderungen (Grimmborn, 24. Sep 2001, 18:30:56):
~#! rn=Boing rt=1001349010 rg=gilden.zauberer
~#! tid=1001230945
Sowieso nicht, bei Scripten versagt bekanntlich immer dieser daemliche Baum
und gibt keine Aeste her. Zumindest war das vor sieben Jahren noch so...

GdA

-----------------------------------------------------------------------------



Re^15: Levelanforderungen (Ark, 24. Sep 2001, 18:33:26):
~#! rn=Boing rt=1001343503 rg=gilden.zauberer
~#! tid=1001230945
Bah, Dir fehlen gescheite Fallen. Treibsand, wie vorsintflutlich. Willste be
mir ein Praktikum absolvieren? ;^)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^16: Levelanforderungen (Varlarion, 24. Sep 2001, 18:38:10):
~#! rn=Ark rt=1001349206 rg=gilden.zauberer
~#! tid=1001230945
und bring doch bitte diesem pinguin endlich das sprechen bei, ich geb mupfel
nicht her und damit basta :)

-----------------------------------------------------------------------------



Re^17: Levelanforderungen (Boing, 24. Sep 2001, 18:39:32):
~#! rn=Varlarion rt=1001349490 rg=gilden.zauberer
~#! tid=1001230945
Und ich hab mir damals noch ueberlegt den Namen zu banishen ... ;)
  Boing

-----------------------------------------------------------------------------



Re^20: Levelanforderungen (Anatol, 24. Sep 2001, 18:46:48):
~#! rn=Foobar rt=1001344700 rg=gilden.zauberer
~#! tid=1001230945
Versucht doch mal zur Abwechslung, die Sache so zu sehen: Die Anforderungen
fuer die einzelnen Stufen wurde - wie schon lange ueberfaellig - endlich
nicht nur am Uebeaufwand, sondern auch an der allgemeinen Spielerfahrung
des Spielers festgemacht. Fuer die derzeit vorletzte Gildenstufe der
Zauberer - bekanntermassen DIE Gilde, die von den Trves als die staerkste
Gilde bezeichnet wird (wohlgemerkt: Von DIESEN Trves, die schon bei der
Gildenstufe 15 von 23 den _Seherstatus_ verlangen!) - muss man jetzt die
Spielerstufe haben, bei der die Seherwerdung nicht mehr weit weg ist.

Ein nachtraegliches Abstufen derjenigen, die diese Bedingungen nicht
ihrer Stufe entsprechend erfuellen, gab es noch nie - weder bei den
Chaoten, noch bei den Kaempfern (Ausbildungskills *prust*, waer ja
SOWAS von genial geworden...) noch bei den Klerikern. Ein Relativieren 
der Anforderungen gibt es, von den rationierten Posten einmal abgesehen,
eigentlich auch noch in keiner Gilde. Vielleicht sollten wir mit dem
Seherstatus anfangen, ja? Jeder Seher, der nicht 85% aller Quests hat
und nicht mehr als der Spielerdurchschnitt FPs, verliert seinen ach so
heiligen Status wieder.

Meine Guete. Ich frage mich, wer sich hier laecherlicher macht. Ich,
weil ich mich aufrege oder ihr, weil ihr mir auf diese Weise Grund
dazu gebt. Ok, ich glaube, ich kenne die Antwort. Man kann nicht immer
gewinnen.... ;)

Anatol

PS: Sind diesmal alle Zeilen da? *brummel*


-----------------------------------------------------------------------------



Re^20: Levelanforderungen (Anacrion, 24. Sep 2001, 18:56:28):
~#! rn=Foobar rt=1001344700 rg=gilden.zauberer
~#! tid=1001230945
Am besten in dieser Rubrik finde ich, wieviele nichtzauberer bzw.
Zweitiebesitzer sich hier beschweren, und dass man nur von einem einzigen
Erstiezauberer was hoert.

anac* - gruebelnd

-----------------------------------------------------------------------------



Re^21: Levelanforderungen (Zook, 24. Sep 2001, 19:20:54):
~#! rn=Anacrion rt=1001350588 rg=gilden.zauberer
~#! tid=1001230945
Wer ist denn der eine Erstiezauberer?

Zook.

-----------------------------------------------------------------------------



Re^22: Levelanforderungen (Karis, 24. Sep 2001, 19:33:58):
~#! rn=Zook rt=1001352054 rg=gilden.zauberer
~#! tid=1001230945
Das muss wohl Ana* sein.
Karis*

-----------------------------------------------------------------------------



Re^23: Levelanforderungen (Anacrion, 24. Sep 2001, 19:35:14):
~#! rn=Karis rt=1001352838 rg=gilden.zauberer
~#! tid=1001230945
Es geht um die, die sich beschweren, nicht die, die das fuer richtig halten,
die anforderungen hochzuschraquben. Beide Ana*s finden das richtig.

ana*

-----------------------------------------------------------------------------



Re^21: Levelanforderungen (Karis, 24. Sep 2001, 19:36:58):
~#! rn=Anatol rt=1001350008 rg=gilden.zauberer
~#! tid=1001230945
DARAUF warte ich schon lange. Wenigstens die Seheranforderungen koennten
dynamisch gestaltet sein. (Zum wievielten Mal diskutieren wir das jetzt ?)
Und ich kann Foobars Vorschlag nur zustimmen. Dynamische Gildenlevel
die mal mehr und mal weniger 'Kampfkraft' hergeben, waeren sicherlich
nicht das schlechteste fuer eine Gilde. Insbesondere fuer eine mit 
limitierten Posten.

Karis kann gar nicht zaubern.

-----------------------------------------------------------------------------



Re^24: Levelanforderungen (Karis, 24. Sep 2001, 19:37:36):
~#! rn=Anacrion rt=1001352914 rg=gilden.zauberer
~#! tid=1001230945
Um Ana* gleich vorzugreifen: ich kenne nur einen Ana*.
Karis*

-----------------------------------------------------------------------------



Re^25: Levelanforderungen (Anacrion, 24. Sep 2001, 19:38:22):
~#! rn=Karis rt=1001353056 rg=gilden.zauberer
~#! tid=1001230945
JA. Wir kennen uns. :o)

ana* - muss grinsen

-----------------------------------------------------------------------------



Re^22: Levelanforderungen (Ark, 24. Sep 2001, 22:15:46):
~#! rn=Karis rt=1001353018 rg=gilden.zauberer
~#! tid=1001230945
Hm, jetzt wo Boing nicht mehr Gott ist, kann ich vielleicht mit Zook eine neue
Seheranforderungsdiskussion vom Zaun brechen :-) Mit Boing hatte ich da eher
freundschaftliche Meinungsdifferenzen, hoehoe. Mal guggen, wie Zook auf
Schleim reagiert.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^23: Levelanforderungen (Varlarion, 24. Sep 2001, 22:19:40):
~#! rn=Ark rt=1001362546 rg=gilden.zauberer
~#! tid=1001230945
was denn fuer anforderungen? findet jetzt eine pruefung statt? jeder, der
seher werden will, muss mit telnet und ohne seine karten von PV zur HE, von da
aus zum hobbitdorf und wieder zurueck nach PV finden? :)

-----------------------------------------------------------------------------



Re^24: Levelanforderungen (Anacrion, 24. Sep 2001, 22:20:27):
~#! rn=Varlarion rt=1001362780 rg=gilden.zauberer
~#! tid=1001230945
In unter 3 min und ohne Wie bitte?

anac*

-----------------------------------------------------------------------------



Re^25: Levelanforderungen (Varlarion, 24. Sep 2001, 22:21:17):
~#! rn=Anacrion rt=1001362827 rg=gilden.zauberer
~#! tid=1001230945
wenn ich mir manche so angucke, reicht das schon, wenn sies _ueberhaupt_
schaffen...

-----------------------------------------------------------------------------



Re^26: Levelanforderungen (Anacrion, 24. Sep 2001, 22:21:45):
~#! rn=Varlarion rt=1001362877 rg=gilden.zauberer
~#! tid=1001230945
*seufz* *umguck* *seufz* *nick* 

*wein bittelich*

anac*

-----------------------------------------------------------------------------



Re^26: Levelanforderungen (Liara, 24. Sep 2001, 22:21:49):
~#! rn=Varlarion rt=1001362877 rg=gilden.zauberer
~#! tid=1001230945
Schieb' mal bitte jemand die Seherdiskussion woanders hin.

-----------------------------------------------------------------------------



Re^24: Levelanforderungen (Ark, 24. Sep 2001, 22:31:44):
~#! rn=Varlarion rt=1001362780 rg=gilden.zauberer
~#! tid=1001230945
Ne, um der Sache mal wieder neues Brennmaterial zu geben:
Ich war fuer festgeschriebene Anforderungen zum Seherwerden, was die Quests
(und nur die!) betrifft. Einerseits aus der Vermutung, dass hier die
potentiellen Spieler der Zukunft nicht jahrelang rumspielen wollen, um
irgendwann mal 3500 APs zu haben, um Seher werden zu koennen (man sieht, ich
sehe das schon langfristig), sondern nach spaetestens einem Jahr
durchschnittlicher Verweildauer auch mal diese "Privilegien" des Sehertums
geniessen zu koennen. Mit dauernd steigenden benoetigten Questpunkten haben
aber auch die zukuenftigen Mudder nicht unbedingt mehr Zeit. Trotzdem bekommen
sie hier taeglich vor Augen gefuehrt, dass man als Nichtseher sowieso eine
Wurst ist (ist stark vereinfacht, ich bitte um Verzeihung). Was machen sie
also in der Not? Man hoert sich nach der geheimnisvollen Abkuerzung "KL" um,
und wenn man sich erstmal eine auf dem Schwarzmarkt besorgt hat, ist das
wahrscheinlich wie eine Droge. Von da an nimmt das Schicksal unseres vorher
"unbefleckten" Questloesers/-loeserin seinen Lauf. Zweitis und
Nichtquestwillige klammer ich mal aus, denen ist sowieso nicht zu helfen.
Mit einer gleichbleibenden Questpunktanforderung wird aber zumindest dem immer
wieder gern benutzten Argument "Pro KL" der Boden entzogen. Die Tatsache, dass
es trotz steigender Questpunktanforderung immer noch soviele neue Seher gibt
wie "frueher" fuehre ich auf KL Benutzung in irgendeiner Art zurueck. Kann man
widerlegen. In fernerer Zukunft wird das aber schwerer. Und wer sich dann noch
hinstellen will und sagen mag, dass er/sie 3500 AP an geforderten Questpunkten
in weniger als 30 - 40 Onlinetagen, bzw. weniger als einem guten halben RL
Jahr bewaeltigt hat, der luegt oder ist so hoffnungslos toll, dass mir die
Worte fehlen :-)

Fazit aus dem Gesabbel: pro feste Questpunktanforderung zur Seherwerdung.

Vorhang frei.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^24: Levelanforderungen (Trug, 24. Sep 2001, 22:56:59):
~#! rn=Varlarion rt=1001362780 rg=gilden.zauberer
~#! tid=1001230945
Ist das so ein Problem? 

Trug, feixend.

-----------------------------------------------------------------------------



Re^25: Levelanforderungen (Montanus, 24. Sep 2001, 22:59:13):
~#! rn=Anacrion rt=1001362827 rg=gilden.zauberer
~#! tid=1001230945
Hobbitdorf? Das muss neu sein. Zu meiner Zeit gab es so was Neumodisches
nicht. HE-Elfendorf-PV, das war die Strecke

-----------------------------------------------------------------------------



Re^21: Levelanforderungen (Seno, 25. Sep 2001, 04:54:31):
~#! rn=Anacrion rt=1001350588 rg=gilden.zauberer
~#! tid=1001230945
Hallo Anacrion!

Du hast dich gewundert, dass hier nur ein einziger Zauberererstie gegen die
neuen GL-Stufenanforderungen Partei ergreift. Nun, relativ kleine Spieler tun
das normalerweise nicht, dass sie sich auf so etwas einlassen (warum wohl?).
Und den etwas groesseren kann es egal sein, koennte es mir eigentlich auch.
Ich hab meinen Zauberer so weit, wie ich ihn bekommen wollte, mir macht das
Spielen (Questen und Forschen) wieder Spass. Es stimmt auch nicht ganz so,
losgetreten hat die Diskussion WhiteTiger.

Was das Forschen angeht: Wenn Du mal einen Blick in die Zaubererrangliste
wirfst, kannst Du schliessen, dass ich mich in diesem Punkt deutlich von
vielen anderen abhebe. Was diese Voraussetzung angeht, koennte ich schon seit
langem Seher sein. Aber ich wuerde, wie gesagt, unter den neuen Bedingungen
wahrscheinlich nicht mehr hier anfangen. Unter diesen Bedingungen bekommt ihr
meiner Meinung nach nur noch mehr Wuerste. Man kann vielleicht als
Neueinsteiger 20 Level in 3 oder 5 Wochen hochspielen, aber forschen wird man
dabei kaum.

Seno

-----------------------------------------------------------------------------



Re^22: Levelanforderungen (Anacrion, 25. Sep 2001, 05:45:31):
~#! rn=Seno rt=1001386471 rg=gilden.zauberer
~#! tid=1001230945
Hae ??

Jeder Forscherpunkt gibt 6 Stupse -> 16 FP = 1 VL .... 


Wenn man Questet ohnre zu forschen, ist man Komplettloeser ... die braucht
aber eh keiner.

anac*

-----------------------------------------------------------------------------



Re^23: Levelanforderungen (Vanion, 25. Sep 2001, 08:34:47):
~#! rn=Anacrion rt=1001389531 rg=gilden.zauberer
~#! tid=1001230945
Oder man spielt die Quest mit dem troelften Zweitie und kanns mittlerweile
einfach ...

V* hat schon beim zweiten Durchspielen nich halb so viele FP gesammelt, wie
beim ersten.

-----------------------------------------------------------------------------



Re^17: Levelanforderungen (Catweazle, 25. Sep 2001, 08:54:17):
~#! rn=Boing rt=1001343635 rg=gilden.zauberer
~#! tid=1001230945
Der Titiwu-Dschungel war mal 'nicht'-kartografierbar? Interessant.

YTC

-----------------------------------------------------------------------------



Re^18: Levelanforderungen (Humni, 25. Sep 2001, 10:44:57):
~#! rn=Catweazle rt=1001400857 rg=gilden.zauberer
~#! tid=1001230945
Viel interessanter finde ich, dass man in den Dschungel ueberhaupt
reingekommen ist, ohne Wawa versteht sich..

Humni

-----------------------------------------------------------------------------



Re^19: Levelanforderungen (Boing, 25. Sep 2001, 10:47:52):
~#! rn=Humni rt=1001407497 rg=gilden.zauberer
~#! tid=1001230945
Ich haette die alten Versionen doch archivieren sollen ... :)
  Boing

-----------------------------------------------------------------------------



Re^20: Levelanforderungen (Varlarion, 25. Sep 2001, 10:49:45):
~#! rn=Boing rt=1001407672 rg=gilden.zauberer
~#! tid=1001230945
wie waers denn mit para-titiwu? du frisierst die tiger ein wenig und verteilst
sie munter auf der insel... *floetpfeifinsblauedenk*

-----------------------------------------------------------------------------



Re^21: Levelanforderungen (Croft, 25. Sep 2001, 10:52:35):
~#! rn=Varlarion rt=1001407785 rg=gilden.zauberer
~#! tid=1001230945
Para-Titiwu ist nicht vor Titiwu 2 geplant ;-)

-----------------------------------------------------------------------------



Re^22: Levelanforderungen (Varlarion, 25. Sep 2001, 10:53:21):
~#! rn=Croft rt=1001407955 rg=gilden.zauberer
~#! tid=1001230945
Varlarion grummelt.

-----------------------------------------------------------------------------



Noch einmal die Levelanforderungen (Srabi, 25. Sep 2001, 11:13:59):
Langsam reichts...

Patryn setze die Levelanforderung endlich durch und baue sie ein. Den
Zauberern wuensche ich dann in Zukunft eine Gilde, die enzweder leer ist, oder
eine Gilde mit hochgescripteten Zweities.

Wer geht denn freiwillig noch in eine Gilde, in der er das metzeln auf den
unteren Stufen vergessen kann...keiner. ERGO: um in der Zauberergilde metzeln
zu koennen, kann man soch ja nur hochscripten.

Srabi...immer wieder verwundert ueber die HLP's, denen eh nix mehr passieren
kann

-----------------------------------------------------------------------------



Re: Noch einmal die Levelanforderungen (Grimmborn, 25. Sep 2001, 11:23:33):
~#! rn=Srabi rt=1001409239 rg=gilden.zauberer
~#! tid=1001409239
Hmm, ist Dir moeglicherweise mal der Gedanke gekommen dass die Zauberergilde
fuer jemanden wie Dich, fuer den das alleinige Argument Kampfkraft ist,
eventuell die falsche Gilde sein koennte? Ich empfehle Dir die
Abenteurergilde: Halbwegs linearer Anstieg der Kampffaehigkeiten von Anfang,
kein Grund irgendwas zu scripten, keine stoerende "Gildenstory" drumherum.

GdA

-----------------------------------------------------------------------------



Re: Noch einmal die Levelanforderungen (Anacrion, 25. Sep 2001, 14:11:00):
~#! rn=Srabi rt=1001409239 rg=gilden.zauberer
~#! tid=1001409239
Insbesondere:

Wenn ich mir Srabi in GLVL16 bei den Trves angucke ...

Also nen LVL7 macht genausoviel Schaden, wenn er gut ist.

Aber schon in LVL25 (nach patryns einstellungen), nciht erst als Seher.

MfG

Anac*

-----------------------------------------------------------------------------



Re: Noch einmal die Levelanforderungen (Liara, 26. Sep 2001, 01:30:40):
~#! rn=Srabi rt=1001409239 rg=gilden.zauberer
~#! tid=1001409239
Was bildest Du Dir eigentlich ein, hier die Klappe mehr als alle anderen
aufzureissen, wenn Du Dir doch selber bestaetigt hast, von den Zaubis keine
Ahnung zu haben? 

Dein Artikel unterstreicht Deine eigene Behauptung nur noch. 

Und ich weiss gar nicht, wieso DU Dich so aufregst. Alle, die unmittelbar
betroffen sind, bleiben sachlich. Ist Dir das schonmal aufgefallen? 

ZZLB, sauer

-----------------------------------------------------------------------------



bewertung (Patryn, 26. Sep 2001, 10:20:44):
hi,

die berwertung von skills und spells aendert sich in kuerze,
bei 'teile llystrathe mit faehigkeiten' und aehnlichem sieht man,
wie man dann eingestuft wird.
es wird dann alles wieder so angepasst, dass man fuer aufstieg
alle spells auf "mit mueh und not ausreichend" habemn muss.
 (derzeit noch altes system an der stelle)

-- 
patryn

-----------------------------------------------------------------------------



Re: Re: Noch einmal die Levelanforderungen (Dimitri, 26. Sep 2001, 12:35:34):
~#! rn=Liara rt=1001460640 rg=gilden.zauberer
~#! tid=1001409239
>Und ich weiss gar nicht, wieso DU Dich so aufregst. Alle, die unmittelbar
>betroffen sind, bleiben sachlich. Ist Dir das schonmal aufgefallen?   
>
>ZZLB, sauer 

Nach deinem Artikel muss es heissen: Fast alle.....

Vector empfiehlt frische Luft und Spaziergaenge

-----------------------------------------------------------------------------



stufen (Patryn, 26. Sep 2001, 14:13:09):
also, wir versprochen ist die spellbewertung nun komplett anders als zuvor,
das kann unter umstaenden bedeuten, dass manche spells sehr viel haerter
bewertet werden als vorher, andere wiederum laeppischer.
das ganze steht noch auf wackligen beinen, also nich gleich grosses
palaver bei scheinbaren ungereimtheiten sondern einfach nachfragen.
auf jeden fall kann es durchaus sein, dass bei hohen zauberern
die zauber aus kleinen gildenstufen aehr viel strenger bewertet werden
als zuvor.

-- 
patryn

-----------------------------------------------------------------------------



aufstieg (Patryn, 26. Sep 2001, 15:39:18):
und weiter gehts...

ich habe vor, statt der jetzigen forderung einer bestimmten
zauberer-questpunktzahl fuer den aufstieg stattdessen zu fordern,
dass alle quests erfuellt sind, die tiefer oder gleich der derzeitigen
gildenstufe eingeordnet sind.
dabei fliegen gleichzeitig alle zaubererquests raus, die eigentlich
normale quests sind. das optional-flag wird evtl. wahrscheinlich auch
wqegfliegen, zaubererquestpunkte wird es wohl nicht mehr geben, weil dann
ueberfluessig.
zu diesem zweck sollen noch mal alle starke missverhaeltnisse zwischen
empfohlenen level fuer die zaubererquest und dem erforderlichen level
ueberdenken und mich gegebenenfalls darauf hinweisen.
desweiteren gilt das hier auch als vorwarnung...der aufstieg wird damit
eher schwerer als leichter. ob ich diese, naechste woche oder gar den
monat erst irgendwann dazu komme weiss ich nicht.

-- 
patryn

-----------------------------------------------------------------------------



Quests (Anacrion, 26. Sep 2001, 16:19:43):
Hier mal meine Einstufung dfer Schwirigkeit von Gildenquests .. als erstes die
jetzige Einstufung, danach meine LVL-Vorstellung ... Discvussion open ;o)

(In Ermangelung von b.z. in dieser Rubrik)

  Walderdbeeren fuer Llystrathe....... raus, eintritt
  Randar Tobis Wunsch................. LV  1  1-5 
  Lhanas Geschenk..................... LV  1  1-5
  Bergsteiger in Not.................. LV  2  1-5
  Kalles Kleinod...................... LV  3  1-5
  MaiTanLins Wunsch................... LV  4  1-5
  Hilf dem Hausmeister der Akademie... LV  4  5-6
  Basil Roghs Wunsch.................. LV  4  5-6
  Jallazara Salavarians Wunsch........ LV  4  7-8 
  Gelungene Verhandlungsfuehrung...... LV  4  5-6
  Jenny Weissasts Wunsch.............. LV  4  6-7
  Geleit fuer Ainulenda............... LV  5  5-7
  Asaniels Zaubertrank................ LV  5  1-4
  Befreie den Gefangenen der Orks..... LV  6  5-7
  Helfe der Stadtwache von Neskaya.... LV  6  6-8  
  Das Szepter des Koboldkoenigs....... LV  6  6-8 
  Werde Obergladiator................. LV  7  6-8
  Perlen vor die Saeue................ LV  7  7-8
  Besuche Fang Du Lan................. LV  7  6-7
  Die magischen Handschuhe............ LV  9  8-9
  Das Geheimnis der Priester.......... LV  8  8-9
  Erforsche das Grab von Xian......... LV  8  6-8
  Der ewige Rubin..................... LV  8  8
  Rettungsaktion in der Eismine....... LV  8  8-9 (geht nicht alleine)
  Zerstoere den Teargoetzen........... LV  8  8-9
  Sklave der Eistrolle................ LV  9  8-9
  Hilf der Bibliothekarin............. LV  9  9
  Befreie den armen Wummbel........... LV  9  6-8
  Der Reichsapfel..................... LV  9  8-9 (massiv antimagie da, sonst
pillepalle)
  Werde ein Drachentoeter............. LV  9  9 Man muss Seher sein, heftig
  Eines Moppels Freund................ LV  8  9 Fand ich heftig
  Der magische Guertel................ LV  9  machs nicht als Quest, sondern
als MOEGLICHKEIT
  Das Amulett aus Tigonenhaut......... LV  9  Haeute aufwerten :o) 6 Wochen
waeren oki ;o)
Soo

anac*

-----------------------------------------------------------------------------



Re^3: Noch einmal die Levelanforderungen (Whitetiger, 26. Sep 2001, 21:08:50):
~#! rn=Dimitri rt=1001500534 rg=gilden.zauberer
~#! tid=1001409239
damit auch noch mal ein kleiner erstie-zauberer was dazu sagt:

ich finde, dass stufe 20 fuer lehrling etwas zu hoch ist, da man bis stufe 4
nicht sehr gute sprueche kann, und man deshalb gerade versucht ist, kls oder
aehnliche listen zu verwenden, um die stufe hochzutreiben, um bessere sprueche
zu lernen...

WT.

ps: ich finde, dass es wirklich wenig artikel von kleineren spielern gibt...
pps: hat schon mal jemand eine statistik ueber spielerlevel/anzahl der artikel
gemacht? ;)

-----------------------------------------------------------------------------



Re^4: Noch einmal die Levelanforderungen (Anacrion, 26. Sep 2001, 21:10:49):
~#! rn=Whitetiger rt=1001531330 rg=gilden.zauberer
~#! tid=1001409239
Re: PS: q.e.d.
Re PPS: Diue sind direkt korrelliert

Re Text:

also hand und schutz und stimme und licht verwende ich dauernd ... so
schlecht, koennen die gar net sein.

anac*

-----------------------------------------------------------------------------



Re^5: Noch einmal die Levelanforderungen (Montanus, 26. Sep 2001, 21:30:11):
~#! rn=Anacrion rt=1001531449 rg=gilden.zauberer
~#! tid=1001409239
Man vergesse nie den Sandzauber (Durians Questbelohnung). Den hab ich
eigentlich auch immer gern gespielt.

@Whitetiger: nur fuer dich ein Artikel eines Spielers <Level10.

-----------------------------------------------------------------------------



stecke schwert weg (Patryn,  2. Okt 2001, 01:25:23):
zweigwechsel
vorsicht bei zweigwechseln oder verdraengt werden, bei neuwahl eines
zweiges werden nochmals explizit alle aktuellen level9-anforderungen
ueberprueft.

-- 
patryn

-----------------------------------------------------------------------------



Re: stecke schwert weg (Patryn,  2. Okt 2001, 01:26:04):
~#! rn=Patryn rt=1001978723 rg=gilden.zauberer
~#! tid=1001978723
hehe, nen altes keybinding :)
na ja, bleibt nun so *g*


-----------------------------------------------------------------------------



liste (Patryn,  2. Okt 2001, 01:56:52):
hi,

sollte die liste derzeit nicht richtig gehen, dann ist das problem
bereits bekannt. es gibt inzwischen zu viele zauberer fuer den
listmaster und das macht bumm.
bis ich auf asynchronen algorithmus umgestellt habe, kanns also
probleme damit geben.

-- 
patryn

-----------------------------------------------------------------------------



Re: liste (Patryn,  2. Okt 2001, 13:12:56):
~#! rn=Patryn rt=1001980612 rg=gilden.zauberer
~#! tid=1001980612
geht wieder

-- 
patryn

-----------------------------------------------------------------------------



Magisterposten (Ahab,  9. Okt 2001, 09:48:49):
Hallo Gilde :)

Bezueglich der Magisterposten habe ich einen Vorschlag, der laut Patryn
programmtechnisch schwierig umzusetzen ist und ausserdem wohl nur wenige
Leute betrifft:

Der Fairness halber faende ich es nicht schlecht, wenn jeder Spieler, der
mehrere Zauberer-Charaktere spielt (warum auch immer ]:->), sich dazu durch-
ringen koennte, mit diesen Charakteren maximal einen Magisterposten zu 
belegen.

Es gibt ohnehin schon wenig genug Plaetze in den Zweigen und auf diese Weise
koennte da eine gewisse Entspannung eintreten.

Denkt mal drueber nach. Danke.

Ahoi,

   Ahab.

-----------------------------------------------------------------------------



Re: Magisterposten (Vardion,  9. Okt 2001, 10:45:44):
~#! rn=Ahab rt=1002613729 rg=gilden.zauberer
~#! tid=1002613729
Hi.

Diese problem loest sich doch ueber den Spielerlevel eigentlich von selbst -
Ersties haben meisst nen hohen Level und werden damit 'automatisch' gegenueber
2ies bevorzugt. Damit werden natuerlich auch Vielspieler gegenueber
Wenigspielern bevorteilt - aber das sehe ich nicht als Problem, denn die
koennen den Posten ja auch am besten nutzen. Ansonsten wuerde ich nicht ZU
viele Restriktionen fuer 2ies einfuehren - das drueckt nur die
Markierungsmoral.

Vardion

-----------------------------------------------------------------------------



Re: Magisterposten (Mupfel,  9. Okt 2001, 16:49:57):
~#! rn=Ahab rt=1002613729 rg=gilden.zauberer
~#! tid=1002613729
Soweit ich mich erinnere war das schon gaaanz zu Anfang eine der Forderungen
seitens der Magier, die hinter der Gilde stehen. Kein Zwang, aber eine Bitte.

-mupfel-

-----------------------------------------------------------------------------



Magisterpruefung (Silvana, 22. Okt 2001, 00:08:05):
Berichten zufolge scheint die Magisterpruefung derbe zu buggen. Ich kann an
dieser Stelle nur davon abraten, sich daran zu versuchen - zu Lars gibt es
einfachere Wege. Ich schau mir das morgen in Ruhe an und gebe Entwarnung, wenn
ich meine den Bug gefunden zu haben.

  Silvana

-----------------------------------------------------------------------------



Re: Magisterpruefung (Silvana, 26. Okt 2001, 01:42:04):
~#! rn=Silvana rt=1003702085 rg=gilden.zauberer
~#! tid=1003702085
Also gut, ich finde keinen Fehler im Code und krieg den Fehler auch nicht
reproduziert. Da das aber offenbar den Fehler nicht daran hindert, sich
trotzdem gelegentlich zu zeigen, wuerde ich gerne den naechsten
Schlachtlaemmern^bProbanden ueber die Schultern schaun. Freiwillige vor!

  Silvana

-----------------------------------------------------------------------------



Re: Re: Magisterpruefung (Patryn, 26. Okt 2001, 02:22:26):
~#! rn=Silvana rt=1004053324 rg=gilden.zauberer
~#! tid=1003702085
hey, da gehts dir so wie mir :)
ich hab da auch nix gefunden, nur falls sich leute wundern, wo ihre mails
gelandet sind...ich hab mich schon an den bugmeldungen versucht.

-- 
patryn

-----------------------------------------------------------------------------



entgifte + zauberer (Patryn, 26. Okt 2001, 13:33:02):
entgifte sollte sich nun nich mehr waehrend einer tasse kaffee auf max
bringen lassen.

-- 
patryn

-----------------------------------------------------------------------------



Re: entgifte + zauberer (Mupfel, 26. Okt 2001, 15:39:36):
~#! rn=Patryn rt=1004095982 rg=gilden.zauberer
~#! tid=1004095982
Man braucht jetzt einen Becher...? ;)

-mupfel-
(oder eine Tasse Tee? ;)

-----------------------------------------------------------------------------



Etwas Disziplin bitte (Schleicher,  2. Nov 2001, 10:08:15):
Hm, ich glaube es gibt mehr als genug NPC's an denen ein aufstrebender
Zauberer seine Spells ueben kann, er muss also nicht wirklich kleine Spieler
froschen oder etwas von ihnen erzwingen so das dieser Spieler in seinem
eigenen Spiel behindert wird oder? Naja, da ich in der laufenden Woche zwei
Beschwerden zu diesem Thema bekommen habe dachte ich mir ich stelle das mal
hier zur Diskussion. Ich denke niemand moechte hier behindert werden oder?
Also etwas mehr Disziplin bitte.

Schleicher

-----------------------------------------------------------------------------



Re: Etwas Disziplin bitte (Foobar,  2. Nov 2001, 10:21:48):
~#! rn=Schleicher rt=1004692095 rg=gilden.zauberer
~#! tid=1004692095
Ein "ignoriere" fuer frosche, zwingtanz und erzwinge ist sowieso laengst
ueberfaellig.

Foobar

-----------------------------------------------------------------------------



Re: Etwas Disziplin bitte (Vardion,  2. Nov 2001, 10:22:47):
~#! rn=Schleicher rt=1004692095 rg=gilden.zauberer
~#! tid=1004692095
Moin.

Zuerst mal: 'frosche' ist ein Stabgimmick und  muss damit nicht geuebt werden.
Das haengt vo einem  Skill ab, der anders geuebt wird.  Und 'erzwinge' hindert
niemanden daran,  irgend eine  Aktion auszufuehren. Es  behindert das  spielen
also maximal durch  Scroll - und den  erzeugen auch genug andere  Quellen. Und
bevor Du hier pauschal alle Zauberer angreifst, solltest Du vielleicht mal mit
diesen 'aufstrebenden Zauberern' reden. Wenn sie  uneinsichtig sind, kannst Du
dich immer noch  ueber _sie_ beschweren. Warum bekommst  eigentlich ueberhaupt
DU Beschwerden  deswegen?  Biste  neuerdings  Zauberer-Gildenmagier  oder  gar
Hilfssheriff? Seltsam...

Vardion, braucht sowas zum Fruehstueck echt nicht

-----------------------------------------------------------------------------



Re: Re: Etwas Disziplin bitte (Mandragon,  2. Nov 2001, 10:25:21):
~#! rn=Foobar rt=1004692908 rg=gilden.zauberer
~#! tid=1004692095
Jo. Ausserdem noch ein 'ignoriere ombatis', ein ignoriere fuer todesstoss und
ein ignoriere fuer laeutere.

Noch Fragen , Kienzle ?

Ma*

-----------------------------------------------------------------------------



Re^3: Etwas Disziplin bitte (Foobar,  2. Nov 2001, 10:27:09):
~#! rn=Mandragon rt=1004693121 rg=gilden.zauberer
~#! tid=1004692095
Selbst Dir muesste aufgefallen sein, dass frosche, zwingtanz und erzwinge bei
Spielern keinen Kampf beginnen, Todesstoss aber sehr wohl.

Ombatis haut man in 3 Runden um und laeutere wird seltsamerweise aeusserst
selten mmissbraucht.

Keine Fragen mehr.

Foobar

-----------------------------------------------------------------------------



Re: Re: Etwas Disziplin bitte (Vardion,  2. Nov 2001, 10:29:43):
~#! rn=Foobar rt=1004692908 rg=gilden.zauberer
~#! tid=1004692095
Genau - geht ja nicht an, dass wir die armen armen Kaempfer huepfen lassen. Wo
die es doch sonst schon so schwer haben. Also wo fuehrt das denn hin? Nee, das
geht echt  nicht.  Und schafft  auch gleich  noch  Ombatis ab.  Und  Armitages
Bartschneider. Und Tillys Saege. Spass muss hier weg.

Vardion denkt . o O (ab Heute machen wir Ernst!)

-----------------------------------------------------------------------------



Re^3: Etwas Disziplin bitte (Bielefeld,  2. Nov 2001, 10:30:35):
~#! rn=Vardion rt=1004693383 rg=gilden.zauberer
~#! tid=1004692095
Genau, Humor ist dieser Gilde voellig unangemessen.

Bielefeld->schmarrn()

-----------------------------------------------------------------------------



Re^3: Etwas Disziplin bitte (Foobar,  2. Nov 2001, 10:30:39):
~#! rn=Vardion rt=1004693383 rg=gilden.zauberer
~#! tid=1004692095
Wenn Du den ganzen Muell als Spass definierst, denn kann ich Dir nur zustimmen
:o)

Foobar

-----------------------------------------------------------------------------



Re^4: Etwas Disziplin bitte (Mandragon,  2. Nov 2001, 10:32:24):
~#! rn=Foobar rt=1004693439 rg=gilden.zauberer
~#! tid=1004692095
Du hast die Wurzelbuerste vergessen.

Ma*

-----------------------------------------------------------------------------



Re^5: Etwas Disziplin bitte (Foobar,  2. Nov 2001, 10:34:06):
~#! rn=Mandragon rt=1004693544 rg=gilden.zauberer
~#! tid=1004692095
Kenn ich nicht.

Foobar

-----------------------------------------------------------------------------



Re^6: Etwas Disziplin bitte (Mandragon,  2. Nov 2001, 10:35:28):
~#! rn=Foobar rt=1004693646 rg=gilden.zauberer
~#! tid=1004692095
Ist ein ganz gemeines und fieses tool mit dem andere deinen titel auf 'hat
zerzauste Haare' setzen koennen und du kannst ihn nicht wieder zurueckaendern,
solange das aktiv ist. Sowas gemeines, so ein niedertraechtiger eingriff in
meine privatsphaere!

Ma*

-----------------------------------------------------------------------------



Re^3: Etwas Disziplin bitte (Orktoeter,  2. Nov 2001, 10:41:20):
~#! rn=Vardion rt=1004693383 rg=gilden.zauberer
~#! tid=1004692095
Bist du des lesens maechtig?

Foobar hat doch den entscheidenden Unterschied schon genannt:

Du kannst Spieler froschen und es zaehlt nicht als Angriff.

Man stelle sich folgende Extremsituation vor: Ein Team kaempft gerade beim DG
(oder etwas aehnlichem), ein Spieler hat schon gut etwas abbekommen, ist aber
noch knapp fir genug nicht zu fliehen und dann kommt ein netter Zauberer
vorbei und froscht ihn "mal eben so"

Auch dir sollte klar sein, das das etwas anderes ist, als "nur" etwas lag zu
machen.

OrkT.

-----------------------------------------------------------------------------



Re^4: Etwas Disziplin bitte (Mandragon,  2. Nov 2001, 10:42:52):
~#! rn=Orktoeter rt=1004694080 rg=gilden.zauberer
~#! tid=1004692095
Also sowas zaehlt eh als versuchter PK, wuerde ich meinen.

Es geht hier um altaegliche dinge, nicht die behinderung beim kaempfen.

Ma*

-----------------------------------------------------------------------------



Re^5: Etwas Disziplin bitte (Saul,  2. Nov 2001, 10:48:09):
~#! rn=Mandragon rt=1004694172 rg=gilden.zauberer
~#! tid=1004692095
In der Hilfe zu Frosche steht folgendes:
BEMERKUNGEN
        Es ist nicht noetig, dieses Gimmick zu ueben. Schliesslich sollen
        nicht nur noch verfroschte Spieler durch das MUD rennen! Deswegen
        ist ebenfalls Uebertreibung zu vermeiden. Wer sich nicht daran
        haelt, muss mit dem Entzug der Faehigkeit rechnen.

Ich denke das ist ausreichend.

Saul
l

-----------------------------------------------------------------------------



Re^6: Etwas Disziplin bitte (Orktoeter,  2. Nov 2001, 10:51:22):
~#! rn=Saul rt=1004694489 rg=gilden.zauberer
~#! tid=1004692095
Tja, wenn Zauberer, die durch die Torwache daran gehindert werden das Struv zu
metzeln sich dafuer mit einem frosche bedanken ist das meiner Meinung nach
mehr als nur eine unfreundlichkeit. Die Torwache muss angriffe abwehren.
Sicher, das geht auch ueber den Hilferuf, aber ich versth das sowieso nicht,
wieso ein so heftiger angriff (Ein Kaempfer ist gefroscht absolut nicht
kampffaehig) niocht als Angriff zaehlt?

OrkT.

-----------------------------------------------------------------------------



Re^7: Etwas Disziplin bitte (Mandragon,  2. Nov 2001, 10:52:46):
~#! rn=Orktoeter rt=1004694682 rg=gilden.zauberer
~#! tid=1004692095
Wenn jemand gerade dabei ist den struv zu hauen (JA, die stupsen) und ein
kaempfer der meinung ist, die aktion per torwache unterbinden zu muessen (was
nciht als angriff zaehlt), dann finde ich das mindestens so mies. ehre
wesentlich schlimmer.

Ma*

-----------------------------------------------------------------------------



Re^8: Etwas Disziplin bitte (Orktoeter,  2. Nov 2001, 10:54:29):
~#! rn=Mandragon rt=1004694766 rg=gilden.zauberer
~#! tid=1004692095
Huhu? Hallo? Jemand zuhause?

Rollenspiel?

OrkT, den Kopf schuettelend.

-----------------------------------------------------------------------------



Re^9: Etwas Disziplin bitte (Mandragon,  2. Nov 2001, 10:56:25):
~#! rn=Orktoeter rt=1004694869 rg=gilden.zauberer
~#! tid=1004692095
Aeh. ? Wie ? Jetzt ploetzlich DOCH rollenspiel ?

Jemand zu hauese?

ein trves, der das tor zumacht, waehrend andere drinen kaempfen begeht imho
nen pk.

Ma*

-----------------------------------------------------------------------------



Re^10: Etwas Disziplin bitte (Foobar,  2. Nov 2001, 10:57:09):
~#! rn=Mandragon rt=1004694985 rg=gilden.zauberer
~#! tid=1004692095
Frosch ihn halt.

Foobar

-----------------------------------------------------------------------------



Re^8: Etwas Disziplin bitte (Nonne,  2. Nov 2001, 10:57:38):
~#! rn=Mandragon rt=1004694766 rg=gilden.zauberer
~#! tid=1004692095
In weiser Vorraussicht haben die Gildenmagier der Zauberer die NPC, auf die
die Zauberer angewiesen sind, ja unangreifbar fuer andere Gilden gemacht. Ob
die Zuberer das vielleicht auch nerven wuerde, wenn nach einem 'teile
llysthrate mit hilfe' nur kaeme: Kein solcher Spieler!

Patryn! Schreit zur tat, ich will mal sehen, was die Zaubis dann sagen.

Nonne.

-----------------------------------------------------------------------------



Re^9: Etwas Disziplin bitte (Mandragon,  2. Nov 2001, 10:58:14):
~#! rn=Nonne rt=1004695058 rg=gilden.zauberer
~#! tid=1004692095
Die npcs der neuen gilde werden angreifbar sein.

Ma*

-----------------------------------------------------------------------------



Re^9: Etwas Disziplin bitte (Vardion,  2. Nov 2001, 11:01:49):
~#! rn=Nonne rt=1004695058 rg=gilden.zauberer
~#! tid=1004692095
Und das sagt ausgrerechnet der Kleriker-Gildenmagier, deren Gilden-NPC
ebenfalls nicht angreifbar ist. *waelz*

Vardion

-----------------------------------------------------------------------------



Re^10: Etwas Disziplin bitte (Foobar,  2. Nov 2001, 11:05:37):
~#! rn=Vardion rt=1004695309 rg=gilden.zauberer
~#! tid=1004692095
Die allerdings auch nicht stupsen, weshalb sollte man sie angreifen?

Foobar

-----------------------------------------------------------------------------



Re^10: Etwas Disziplin bitte (Nonne,  2. Nov 2001, 11:06:01):
~#! rn=Vardion rt=1004695309 rg=gilden.zauberer
~#! tid=1004692095
Wie Du vielleicht noch weisst, war Arkshat frueher angreifbar. Der war dann
leider immer tot. Das er nun nicht mehr angreifbar ist, war eine Notloesung,
weil sich die Spieler einfach nicht zurueckhalten konnten. Obwohl Arkshat nie
gestupst hat.

Nonne.

-----------------------------------------------------------------------------



Re^11: Etwas Disziplin bitte (Mandragon,  2. Nov 2001, 11:06:03):
~#! rn=Foobar rt=1004695537 rg=gilden.zauberer
~#! tid=1004692095
Warum greift jemand Funa oder siamil an ?

Ma*

-----------------------------------------------------------------------------



Re^12: Etwas Disziplin bitte (Foobar,  2. Nov 2001, 11:06:25):
~#! rn=Mandragon rt=1004695563 rg=gilden.zauberer
~#! tid=1004692095
Keine Ahnung.

Foobar

-----------------------------------------------------------------------------



Re^11: Etwas Disziplin bitte (Vardion,  2. Nov 2001, 11:06:27):
~#! rn=Foobar rt=1004695537 rg=gilden.zauberer
~#! tid=1004692095
Vielleicht weil ich Kleriker scheisse finde oder sonstwas gegen sie habe? Es
gibt andere Gruende als nen Stups :)

Vardion

-----------------------------------------------------------------------------



Re^12: Etwas Disziplin bitte (Nonne,  2. Nov 2001, 11:09:00):
~#! rn=Vardion rt=1004695587 rg=gilden.zauberer
~#! tid=1004692095
... und weil dadurch die Kleriker massiv behindert wurden, wurde es ausgebaut.
Wenn er ein paar mal am Tag tot gewesen waere, haette niemand was gesagt.
Seine durchschnittliche Lebenserwartung war auch auf unter 5 Minuten gesunken.
Es gibg doch hier um Behinderung anderer beim Spielen und das man das lassen
sollte, oder nicht?

Nonne.

-----------------------------------------------------------------------------



Re^12: Etwas Disziplin bitte (Elberet,  2. Nov 2001, 11:10:10):
~#! rn=Vardion rt=1004695587 rg=gilden.zauberer
~#! tid=1004692095
wenn kleine zaubis andere froschen, weil sie meinen, dass sies ueben muessten,
dann scheinen sie den hilfetext halt nicht gelesen zu haben. Und auf mehr
wollte Schleicher doch gar nicht hinweisen, oder? Ob das nun auch als Angriff
zum stoeren oder wer weiss was genutzt werden kann, ist doch ne ganz andere
frage. BTW sind die Zaubvigildennpcs auch fuer andere angreifbar.

Elbi

-----------------------------------------------------------------------------



Re^13: Etwas Disziplin bitte (Vardion,  2. Nov 2001, 11:11:06):
~#! rn=Nonne rt=1004695740 rg=gilden.zauberer
~#! tid=1004692095
Das waere doch mit Llystrathe nix anderes, wenn sie angreibar waere...
Aber ich hab natuerlich nix dagegen, wenn sie angreifbar ist, und jede Runde
einfach wahlos mit Zaps um sich wirft.

Vardion

-----------------------------------------------------------------------------



Re^14: Etwas Disziplin bitte (Elberet,  2. Nov 2001, 11:12:09):
~#! rn=Vardion rt=1004695866 rg=gilden.zauberer
~#! tid=1004692095
also die kaempfernpcs sind angreifbar und nicht staendig tot, man kann
gildennpcs wohl doch einigermassen schuetzten wies ausschaut ;)

-----------------------------------------------------------------------------



Re^15: Etwas Disziplin bitte (Vardion,  2. Nov 2001, 11:13:19):
~#! rn=Elberet rt=1004695929 rg=gilden.zauberer
~#! tid=1004692095
Wenn Briesel nicht seinen  Rattenschwanz an Handlangern haette, waere  er auch
dauertot. Und nur deswegen jetzt 10  funktionslose Zauberer-NPCs als Leibgarde
aufstellen? Nee...

Vardion

-----------------------------------------------------------------------------



Re^16: Etwas Disziplin bitte (Elberet,  2. Nov 2001, 11:15:27):
~#! rn=Vardion rt=1004695999 rg=gilden.zauberer
~#! tid=1004692095
wieso, die sind doch schon da, ausserdem kann llys doch bann, oder? dann ist
doch alles gut

-----------------------------------------------------------------------------



Re^16: Etwas Disziplin bitte (Foobar,  2. Nov 2001, 11:15:28):
~#! rn=Vardion rt=1004695999 rg=gilden.zauberer
~#! tid=1004692095
Ihr habt doch schon eine Horde funktionslose Zauberer-NPCs :o)

Foobar

-----------------------------------------------------------------------------



Re^17: Etwas Disziplin bitte (Elberet,  2. Nov 2001, 11:16:29):
~#! rn=Foobar rt=1004696128 rg=gilden.zauberer
~#! tid=1004692095
naja besser als die raeume nicht betretbar zu machen und man kann dann doch
rein

-----------------------------------------------------------------------------



Re^18: Etwas Disziplin bitte (Elberet,  2. Nov 2001, 11:17:00):
~#! rn=Elberet rt=1004696189 rg=gilden.zauberer
~#! tid=1004692095
und wenn nen zaubi gildennpcs killt gehoert er eh aus der gilde geworfen find
ich :o)

-----------------------------------------------------------------------------



Re^10: Etwas Disziplin bitte (Ark,  2. Nov 2001, 12:17:32):
~#! rn=Mandragon rt=1004695094 rg=gilden.zauberer
~#! tid=1004692095
Jo, aber nicht die gildenrelevanten NPCs. Genaueres werden wir uns noch
auskaspern. Dauerbehinderung durch stupsgeile Leute _sollte_ es nicht geben.
Ansonsten wird eben angepasst.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^15: Etwas Disziplin bitte (Orktoeter,  2. Nov 2001, 12:53:39):
~#! rn=Elberet rt=1004695929 rg=gilden.zauberer
~#! tid=1004692095
wie oft wurden die "mal eben schnell" von Zauberern gemetzelt? Speziell wenn
es gerade hiess das alle trevs gebeten werden sich zu versammeln und einer
Vereidigung beizuwohnen?
Ist heute vileicht nicht mehr so, aber es gabe eine Zeit, wo (einige) Zauberer
die Kaempfer recht massiv behindert haben und das auch sehr bewusst.

Aber das ist unabhaengig davon, das froschen meiner Meinung nach einen sehr
harten Angriff bedeutet und auch als solches gewertet werden sollte.

OrkT.

-----------------------------------------------------------------------------



Re^12: Etwas Disziplin bitte (Apollonia,  2. Nov 2001, 14:20:26):
~#! rn=Vardion rt=1004695587 rg=gilden.zauberer
~#! tid=1004692095
Dann sollte Llystrathe erst recht angreifbar sein, Stups hin oder her. Es gibt
garantiert genuegend Leute, die die Zauberer scheisse finden ;o)

Apo*

-----------------------------------------------------------------------------



Re^13: Etwas Disziplin bitte (Elberet,  2. Nov 2001, 14:20:58):
~#! rn=Apollonia rt=1004707226 rg=gilden.zauberer
~#! tid=1004692095
och Llys is ja angreifbar, das ist nicht das Problem :)

-----------------------------------------------------------------------------



Re^14: Etwas Disziplin bitte (Apollonia,  2. Nov 2001, 14:21:45):
~#! rn=Elberet rt=1004707258 rg=gilden.zauberer
~#! tid=1004692095
Dann meinetwegen killbar.

Apo*

-----------------------------------------------------------------------------



Re^15: Etwas Disziplin bitte (Elberet,  2. Nov 2001, 14:28:54):
~#! rn=Apollonia rt=1004707305 rg=gilden.zauberer
~#! tid=1004692095
soweit ich weiss krioegt man sogar mit, wenn sie eigentlich stirbt, obwohl sie
dann doch nciht stirbt ;) 

-----------------------------------------------------------------------------



Re^9: Etwas Disziplin bitte (Patryn,  2. Nov 2001, 14:51:30):
~#! rn=Nonne rt=1004695058 rg=gilden.zauberer
~#! tid=1004692095
das ist laengst geplant, wurde dann allerdings in richtung neue gilde
verschoben. die jetzigen gildenraeume und -npcs sind eh nicht so der
atmosphaerische reisser, da lohnt es nich riesen arbeit reinzustecken.

-- 
patryn

-----------------------------------------------------------------------------



Re^10: Etwas Disziplin bitte (Anatol,  2. Nov 2001, 19:56:30):
~#! rn=Patryn rt=1004709090 rg=gilden.zauberer
~#! tid=1004692095
Ich fass es nicht. 40 Artikel. Aber unterhaltsam.


Ausloeser ist ein Schleicher, der weder mit der direkten Exekutive (das
ist in erster Linie Muadib) noch mit den Gildenbetreuern (Patryn fuer das
hier&heute, zzgl. Silvana, Ark u.a. fuer die Zukunftsmusik) etwas zu tun
hat, aus irgendwelchen Gruenden als Ansprechpartner fuer Beschwerden sieht
anstatt sie an eben genannte weiterzuleiten.

Da ist ein Foobar, der einen Ombatis (der fuer Nichtmetzler, also nackte
Zauberer oder 'low/medium' Spieler ein untoetbares Problem ist) zu 
tolerieren bereit ist, es aber fuer noetig haelt, zwingtanz/erzwinge
ignorieren zu koennen. Lass' Dir mal von einem Betroffenen ohne gag.tf
erzaehlen, wie unglaublich nervig dieser hoffnungslos ueberzogene 
Nervdaemon ist, Foobar. Eusebius ist ein Waisenkind dagegen. Ohne Hilfe
kannst Du Dich dann nur zum Idlen begeben oder fuer ne Stunde ausloggen.
Hat ja nicht jeder eine Standleitung.

Da sind weitere, die fordern, dass "frosche" et al. (ausser das Laeutern
faellt wohl auch das Berauschen und sogar der SEGEN noch darunter) 
ignorierbar gemacht werden, weil man damit indirekte PKs begehen koenne.
Jungs, kommt runter. Einen PK kann man auch mit der Axt begehen. Und nur
weil die Mudlib den einen PK automatisch erkennt, den anderen nicht, ist
der andere nicht weniger ein PK. Selbst ein Echo der Art "Du hast noch
210 Lebenspunkte und 210 Konzentrationspunkte." kann ein PK darstellen
(Ich allerdings uebrigens nicht davor zurueck, nichtreagierende
Vollscripts gelegentlich etwas zu irritieren und einen PK zu riskieren.
Was bin ich boese.).

Da ist fo*-Ma*, der die Wuschelwurz mit einer Wurzelbuerste verwechselt.
Nicht tragisch, aber er sollte man eine Weile den Boden in der Gilde mit
einer Wuschelwurz schrubben... ]:^>.

Da ist ein Orktoeter, der es fuer "Rollenspiel" haelt, wenn ein Spieler
metzelnde Zauberer im Struv einsperrt (und damit sehr wohl umbringen
kann), es aber gleichzeitig fuer voellig ok haelt, wenn dieser Spieler
nach wie vor durch die nicht-PK-Regelung geschuetzt ist. Wuahaha. :) Und
der Umstand, dass nicht aller Gilden NPCs umkloppbar sind, kann ja wohl
auch kaum fuer so eine fadenscheinige Argumentation herangezogen werden.
Wacheschieben, um einen Angriff zu verhindern - ok. Aber ebenso ist es
ok, einen Kaempfer durch irgendwelche Massnahmen am Wacheschieben zu
hindern oder ihn dazu zu zwingen, den Posten zu verlassen (wenn "frosche"
dazu ausreicht - schoen :)).

Oh. Und uebrigens. Nur so als Frage. WER hat sich denn eigentlich beschwert?
Ueber wen konkret? Und warum AUSGERECHNET bei Schleicher? 

Anatol

-----------------------------------------------------------------------------



Re^11: Etwas Disziplin bitte (Orktoeter,  2. Nov 2001, 20:08:36):
~#! rn=Anatol rt=1004727390 rg=gilden.zauberer
~#! tid=1004692095
Ungewohnt viele Typos/Fehler von dir Anatol, aber abgesehen vom sprachlichen:

Wenn ich mich nicht sehr irre bedeutet "wache stehen" bei den trves nichts
anderes, als das die Wache jeden der Hineinwill aufhaelt und am betreten
hindern kann. Der Wachestehende kann niemanden am verlassen hindern. Ausserdem
ist es sehr wohl Rollenspiel, wenn ein Kaempfer seiner Gilde zuhilfe eilt. 

Wenn ich jemanden mit der Waffe angreife ist das der Begin eines Kampfes, wenn
mich ein Zauberer froscht ist das ein lustiges gimmick... ich waere mal
gespannt, wie lustig die Zauberer es faenden, wenn es ein Tool gaebe
(moeglichst noch fuer wenig Geld in jedem Laden zu kaufen), mit dem man
(vileicht sogar speziell Zauberer?) manipulieren kann, a la "foppe XXX" und
XXX kann dann nicht mehr zaubern (selbstredend kann er auch auch nicht lys um
hilfe bitten)

Meiner bescheidenen Meinung nach ist sollte so etwas wie froschen als Angriff
gewertet werden!

OrkT.

-----------------------------------------------------------------------------



Re^12: Etwas Disziplin bitte (Elberet,  2. Nov 2001, 20:09:20):
~#! rn=Orktoeter rt=1004728116 rg=gilden.zauberer
~#! tid=1004692095
also im grossen und ganzen, bis auf nen paar dinge stimme ich Anatol meinem
Schutzpatron zu :)

-----------------------------------------------------------------------------



Re: Re: Etwas Disziplin bitte (Liara,  2. Nov 2001, 20:09:40):
~#! rn=Foobar rt=1004692908 rg=gilden.zauberer
~#! tid=1004692095
Genauso wie ein ignoriere struvwache und so weiter? ;-)

-----------------------------------------------------------------------------



Re^12: Etwas Disziplin bitte (Anatol,  2. Nov 2001, 20:11:22):
~#! rn=Orktoeter rt=1004728116 rg=gilden.zauberer
~#! tid=1004692095
[ ] Du hast es kapiert.

Anatol

-----------------------------------------------------------------------------



Re^13: Etwas Disziplin bitte (Orktoeter,  2. Nov 2001, 20:12:55):
~#! rn=Anatol rt=1004728282 rg=gilden.zauberer
~#! tid=1004692095
[ ] Du hast gelesen, das ich meine Meinung geaeussert habe.

OrkT.

-----------------------------------------------------------------------------



Re^4: Etwas Disziplin bitte (Starfire,  3. Nov 2001, 07:46:19):
~#! rn=Bielefeld rt=1004693435 rg=gilden.zauberer
~#! tid=1004692095
Oehm, da habe ich jetzt eine Frage.
Ich habe heute boesartiger- und gemeinerweise Galbani, Verzeihung, Galbraith
und seine Schuelerin Callisto in der SSP aufgehalten, und Galbraith zum Tanzen
gezwungen, und Callisto zum Grinsen. Kann ich durch meine freiwillige Meldung
meine Strafe ein wenig abmildern? Ich meine, scheinbar ist es ja nun so, dass
man viele lustige Hilfsmittel, die einem das MG so zur Verfuegung stellt,
nicht mehr benutzen darf, und ich moechte ja nicht wieder gegen Regeln
verstossen.
Achja, bei der Gelegenheit moechte ich dann noch Yaladan melden. Der hat mir
heute naemlich einen (ziemlich guten) Ombatis geschickt.
Naemlich!
Gute Nacht, Star*...

-----------------------------------------------------------------------------



Re^5: Etwas Disziplin bitte (Foobar,  3. Nov 2001, 08:52:25):
~#! rn=Starfire rt=1004769979 rg=gilden.zauberer
~#! tid=1004692095
[ ] Kaestchen zum Ankreuzen sind total super.

Foobar

-----------------------------------------------------------------------------



Re^5: Etwas Disziplin bitte (Tektuko,  3. Nov 2001, 10:36:36):
~#! rn=Starfire rt=1004769979 rg=gilden.zauberer
~#! tid=1004692095
Wegsperren, Schluessel Wegwerfen :)

-----------------------------------------------------------------------------



Re^12: Etwas Disziplin bitte (Elendil,  3. Nov 2001, 11:23:58):
~#! rn=Orktoeter rt=1004728116 rg=gilden.zauberer
~#! tid=1004692095
Hi zusammen,

also Froschen wird geloggt, wer es uebertreibt bekommt Aerger.
Die Wache frosche finde ich voellig OK ;)

So, was ich eigentlich sagen wollte:
Wenn Frosche als Angriff gewertet wird, wird es direkt ausgebaut.
Weil ich kann keine NPCs froschen, bei Spieler zaehlt das als
Angriff. Oh, entschuldigung, es erfuellt noch einen Sinn, ich
kann mich selber froschen.

Gruss Ele

-----------------------------------------------------------------------------



Re^12: Etwas Disziplin bitte (Weatherwax,  4. Nov 2001, 18:32:07):
~#! rn=Orktoeter rt=1004728116 rg=gilden.zauberer
~#! tid=1004692095

Noe,

sollte es sicher nicht generell. Wie ja hier die ganze Zeit in allen Facetten
beschrieben wird, handelt es sich dabei genau dann um einen schwerwiegenden
Eingriff, wenn man es unter bestimmten Bedingungen tut. Ansonsten aber ist es
ja wohl relativ harmlos.

Derjenige, der tatsaechlich zu Schaden kommt, weil er von jemandem gefroscht
wurde, zumal wenn dies haeufiger vorgekommen sein sollte, hat ganz klar jedes
Recht, sich zu beschweren. Moegliche Konsequenzen wurden bereits aus  der
Spruchhilfe zitiert. Wo also soll das Problem sein? 
Mir gehts genau wie Anatol, insofern ich fuer am interessantesten die Frage
halte, um was fuer ein Windei es hier KONKRET gegangen sein soll. Nicht, dass
ich darauf bestehe, dass mich das was angeht, aber wenn es das nicht tun
sollte, dann verweise ich zurueck an denjenigen, der das hier zur res publica
gemacht hat.

Quak

Wx

-----------------------------------------------------------------------------



Re: Re: Etwas Disziplin bitte (Nicolai,  5. Nov 2001, 10:42:30):
~#! rn=Foobar rt=1004692908 rg=gilden.zauberer
~#! tid=1004692095
Muahaha ein ignoriere dafuer.
Wir sehen uns in der Arena, wenn ich ignoriere waffenschlag und ignoriere 
foobar.zauberer.ausweichen hab.

-Vector- erst bei Artikel 10

-----------------------------------------------------------------------------



Re^11: Etwas Disziplin bitte (Nicolai,  5. Nov 2001, 10:55:37):
~#! rn=Anatol rt=1004727390 rg=gilden.zauberer
~#! tid=1004692095
Muahah,
eben schon wollte ich den Tag rot im Kalender ankreuzen,
weil ich Anatols Artikel voll zustimmen wollte, und nix zum 
Widersprechen gefunden habe, Nur leider sagt der Artikel nichts aus.
Ein schoener Artikel, gewohnt lang, gewohnt sauber verfasst, und
mit netten kleinen Seitenhieben noch nebenbei alte Freund- und
Feindschaften gepflegt. Aber inhaltlich ist der Artikel leider
absolut nichtssagend. Vielleicht eine kleine Zusammenfassung fuer alle,
die diesen Thread bisher nur ueberflogen haben.
Trotzdem hab ich nichts an dem Artikel auszusetzen ..inhaltlich :)

Vector inzwischen bei nr52

-----------------------------------------------------------------------------



Re^12: Etwas Disziplin bitte (Karis,  5. Nov 2001, 10:57:30):
~#! rn=Nicolai rt=1004954137 rg=gilden.zauberer
~#! tid=1004692095
Fein. Dann schreib das das naechste Mal bitte kuerzer.
Karis, kapiert einen Text auch ohne 5 Wiederholungen.

-----------------------------------------------------------------------------



Re^13: Etwas Disziplin bitte (Elberet,  5. Nov 2001, 10:58:07):
~#! rn=Karis rt=1004954250 rg=gilden.zauberer
~#! tid=1004692095
aber 90% der anderen nicht, Karis ;)

-----------------------------------------------------------------------------



Re: Etwas Disziplin bitte (Patryn,  5. Nov 2001, 16:04:36):
~#! rn=Schleicher rt=1004692095 rg=gilden.zauberer
~#! tid=1004692095
da sieht man mal was dabei rauskommt, wenn leute sich bei inkompetenten
stellen beschweren. frosche und ueben...haha.
das kommt doch erst bei 'rfrosche' und 'flaechenfrosche'.
beides koennen kleinlevelige zaubis leider nur an trves ueben, in hoehren
leveln dann auch karateka oder aehnliches.
dauert aber noch etwas, also geduld.

-- 
patryn, mag trves: verfroscht und aufgepustet

-----------------------------------------------------------------------------



Re: Re: Etwas Disziplin bitte (Patryn,  5. Nov 2001, 16:09:18):
~#! rn=Patryn rt=1004972676 rg=gilden.zauberer
~#! tid=1004692095
ach ja, 'flaechenfrosche' kann alternativ auch 'froscherdbeben' heissen.
ich bin da noch soooo unentschlossen ;))))

-- 
patryn

-----------------------------------------------------------------------------



Re^3: Etwas Disziplin bitte (Anatol,  5. Nov 2001, 16:30:30):
~#! rn=Patryn rt=1004972958 rg=gilden.zauberer
~#! tid=1004692095
In der Doku steht aber "unkenregen". *brummel* :)

Anatol 

-----------------------------------------------------------------------------



Re^4: Etwas Disziplin bitte (Silvana,  5. Nov 2001, 17:31:09):
~#! rn=Anatol rt=1004974230 rg=gilden.zauberer
~#! tid=1004692095
Ich bin immer noch dafuer "rfrosche" ueber den userfilter vom kwer zu jagen...
"rfrosche gilde kaempfer"... };-)

  Silvana (Rubrik durchgelesen und sehr amuesiert)

-----------------------------------------------------------------------------



Re^5: Etwas Disziplin bitte (Gnome,  6. Nov 2001, 10:26:47):
~#! rn=Silvana rt=1004977869 rg=gilden.zauberer
~#! tid=1004692095
koennt ihr alles einbauen, wie ihr lustig seid.
solange sich ein magier in der zwischenzeit bereiterklaert, das mit der
magieinsel abhandengekommene anti-frosch-amu im mud neu zu positionieren.
dann koennen die zaubis von mir aus "rfrosche alle" lernen. :)

wer fuehlt sich angesprochen?

gnOme

-----------------------------------------------------------------------------



Re^6: Etwas Disziplin bitte (Silvana,  6. Nov 2001, 12:22:15):
~#! rn=Gnome rt=1005038807 rg=gilden.zauberer
~#! tid=1004692095
Nene, das geht nicht. Ein Schutz vor Froschen ist das alleinige Copyright des
verschiedenen Autors der Magieinsel. Wir werden doch nicht noch einmal den
Unmut dieses ehemaligen Mitgliedes unserer Gesellschaft herausbeschwoeren. Wo
er doch so nachdruecklich darauf beharrt hat, dass nichts von seinen Werken
wieder angeschlossen werden moege... Nein, einen Schutz vor Froschen wird es
daher wohl nie wieder geben duerfen...

  Silvana (nicht ganz ernst)

-----------------------------------------------------------------------------



Re^6: Etwas Disziplin bitte (Patryn,  6. Nov 2001, 13:16:42):
~#! rn=Gnome rt=1005038807 rg=gilden.zauberer
~#! tid=1004692095
das amu war in der form eh doof und lies froschende npcs ziemlich albern
ausschaun. instant-entfrosche ist wohl nicht so toll...

-- 
patryn

-----------------------------------------------------------------------------



Re^7: Etwas Disziplin bitte (Gnome,  8. Nov 2001, 11:40:26):
~#! rn=Patryn rt=1005049002 rg=gilden.zauberer
~#! tid=1004692095
dann mach es besser :)=

-----------------------------------------------------------------------------



vorwarnung, lernen I (von III) (Patryn, 22. Nov 2001, 12:46:11):
sooooo,

aehnlich der questumstellung kommt auch hier eine vorwarnzeit welche
diesmal das ueben betrifft. was wird passieren, was ist passiert?
geplant ist eine abwertung des erfolgslernens, welches, so werden mir viele
zustimmen, das hochueben eines zaubis ueber einer gewissen schranke einfach
zu easy macht.
schritt I waren einfach nur ein paar wichtige fixes, zb werden temporaere
lernbeschraenkungen nun auch beim erfolgslernen beruecksichtigt,
teleport und rausche schaun, ob lernen ueberhaupt sinn macht und es kommen
da wohl noch andere kleinigkeiten.
schritt II wird sein, dass ein master sich merkt, woran man wie oft uebt,
der lernerfolg wird rasch absinken, wenn man ne weile an seinem haustier
herumzaubert oder an muenzen u.s.w.
schritt III wird damit vorbereitet, damit unsere scripter dann das script
nicht einfach doppelt so lange ablaufen lassen muessen (jaja, man kann
trotzdem alles scripten). dann wird naemlich erfolgslernen stark abgewertet.

-- 
patryn

-----------------------------------------------------------------------------



Re: vorwarnung, lernen I (von III) (Vincent, 22. Nov 2001, 13:05:49):
~#! rn=Patryn rt=1006429571 rg=gilden.zauberer
~#! tid=1006429571
Fuehren diese in drei Schritten aufgeteilten Massnahmen dazu, dass Spieler,
die nicht scripten, nun ueber einen laengeren Zeitraum ueben muessen, um
den gleichen Erfolg zu erzielen, wie vor den Massnahmen, wenn sie auch
weiterhin nicht scripten?

Gruss
Vincent

-----------------------------------------------------------------------------



Re: Re: vorwarnung, lernen I (von III) (Patryn, 22. Nov 2001, 13:13:14):
~#! rn=Vincent rt=1006430749 rg=gilden.zauberer
~#! tid=1006429571
das wird ganz darauf ankommen ob die spieler die neuen regeln beobachten und
sich anpassen. sicher wird die lernzeit besonders bei erfolgslernen groesser
werden, das geht einfach zu schnell derzeit.
ich werde aber weitestgehend versuchen, wirklich stark nur schlechte und
maessig gute scripte zu behindern.

-- 
patryn

-----------------------------------------------------------------------------



Re^3: vorwarnung, lernen I (von III) (Bambi, 22. Nov 2001, 13:19:08):
~#! rn=Patryn rt=1006431194 rg=gilden.zauberer
~#! tid=1006429571
Ich geh mal davon aus, dass Du damit aussagen willst, dass Du "richtig gute
Scripte" nicht deshalb nicht behindern willst, weil sie richtig gut sind,
sondern weils zuviel Aufwand macht.

-----------------------------------------------------------------------------



Re^4: vorwarnung, lernen I (von III) (Humni, 22. Nov 2001, 13:22:22):
~#! rn=Bambi rt=1006431548 rg=gilden.zauberer
~#! tid=1006429571
:tippt auf ,weils unmoeglich ist'.

Humni

-----------------------------------------------------------------------------



Re^5: vorwarnung, lernen I (von III) (Elberet, 22. Nov 2001, 13:23:02):
~#! rn=Humni rt=1006431742 rg=gilden.zauberer
~#! tid=1006429571
weil sehrt gute scripte kaum von schlecht spielenden menschen zu unterscheiden
sind?

-----------------------------------------------------------------------------



Re^4: vorwarnung, lernen I (von III) (Patryn, 22. Nov 2001, 13:29:54):
~#! rn=Bambi rt=1006431548 rg=gilden.zauberer
~#! tid=1006429571
wenn du den heiligen gral gefunden hastm der aufwendige scripte abschiesst,
dann wird dich die gesamte existierende mud-landschaft zum neuen propheten
kueren.

-- 
patryn, anspornend

-----------------------------------------------------------------------------



Re^5: vorwarnung, lernen I (von III) (Grimmborn, 22. Nov 2001, 13:33:00):
~#! rn=Patryn rt=1006432194 rg=gilden.zauberer
~#! tid=1006429571
Nicht den Heiligen Gral, aber zum Abschiessen kann ich z.B. folgendes anbieten
(nicht in natura, natuerlich):
http://www.heckler-koch.de/html/german/behoerden/04_specialweapons/04_03_index
.html

Grimm"also, wenn das nicht reicht..."born der Atheist

-----------------------------------------------------------------------------



Re^6: vorwarnung, lernen I (von III) (Patryn, 22. Nov 2001, 13:34:10):
~#! rn=Grimmborn rt=1006432380 rg=gilden.zauberer
~#! tid=1006429571
wow...ist ja nen makabrer link, hat das auch nen webshop? :)

-- 
patryn

-----------------------------------------------------------------------------



Re^5: vorwarnung, lernen I (von III) (Bambi, 22. Nov 2001, 13:34:55):
~#! rn=Patryn rt=1006432194 rg=gilden.zauberer
~#! tid=1006429571
Ich glaub eher, dann werde ich gesteinigt.

-----------------------------------------------------------------------------



Re^6: vorwarnung, lernen I (von III) (Patryn, 22. Nov 2001, 13:35:32):
~#! rn=Bambi rt=1006432495 rg=gilden.zauberer
~#! tid=1006429571
nun ja, das war schon immer so...des einen propheten sind der anderen
kreuzzuege :)

-- 
patryn

-----------------------------------------------------------------------------



Re: vorwarnung, lernen I (von III) (Soul, 22. Nov 2001, 14:15:03):
~#! rn=Patryn rt=1006429571 rg=gilden.zauberer
~#! tid=1006429571
Erfolgslernen stark abgewertet? Ueber die ganze Bandbreite der Faehigkeiten?
Ich meine an dem Uebergang zwischen ueberwiegend aus Fehlern lernen und aus
Erfolg lernen ist es doch sehr schwer, wenn da aus Erfolg lernen abgewertet
wird und der Zauberer mit Zauberstab und allgemein Zaubern sehr gut ist, dann
kann das arg schwer werden sich noch zu verbessern, weil dann ja Fehler selten
sind.

In der Phase faengt doch das Skriptueben oder auch manuelle gesteuerte
Skriptaehnliche ueben (das ja auch mit gestraft werden wuerde ) ja erst
richtig an.
Gewisse Sprueche wie erschaffe sind ja eigentlich nur Skriptmaessig zu ueben.
Fuer normale Extrawuerstchen wie dem Sandtiger ne Sandtigerin zu verpassen und
so wird der doch viel zu selten angewendet und fuer nebenbei zu ueben hat der
doch ne zu lange Auszeit dadurch wird der z.B. wohl relativ haeufig
Skriptgeuebt oder?

Also aendert sich wohl nicht viel, nur die Skripte werden staerker gehandelt
und alle, die mit Skript und die ohne brauchen laenger zum ueben.
Ist also vor allem mal wieder die armen Telnet-Riege bedroffen und der Teil
der Armen Studenten die in der Uni kein TF oder ZMUD installieren duerfen und
sich daran halten.

Erlich gesagt dachte ich immer sowas wie Schritt I und II waeren schon laengst
realisiert.
Naja, aber heisst das nicht das jemand der z.B. Gewisse Gebiete mit lauter
"gleichnamigen" Gegnern metzelt dabei sehr wenig lernt? Und dabei der Skripter
der dann jeweils zwischedrin diverse Kaninchen, Ameisen oder aehnliches
niederkastet schneller lernt?
Ausserdem wuerde sich dabei ein anderes Problem erhoehen. Wenn
Gegenstandsbezogene Zauber geuebt werden "identifiziere" oder so, dann gibts
wohl noch mehr krempel in den Seherhaeusern. Auch dieser Zauber ist laestig zu
ueben, wenn man standardmaessig den Zauber mit nem Zweitie schon uebt.

Ich denke der Versuch bringt nur kurzfristigen Erfolg straft aber im Endeffekt
eher die normal und maessig legal Skriptenden.
Lediglich die dumm illegal Skripter haben ne bessere Chance erwicht zu werden!
He, he!

Ups, scheisse schon wieder ne Seite vollgeschrieben, ich muss echt dran
arbeiten das kuerzer zu halten.
Mfg, Soul


-----------------------------------------------------------------------------



Re: Re: vorwarnung, lernen I (von III) (Hight, 22. Nov 2001, 15:18:58):
~#! rn=Soul rt=1006434903 rg=gilden.zauberer
~#! tid=1006429571
pffff ... ich hab mal abgesehen von den zaubis noch nie aus nem erfolg gelernt

hight macht dann halt umstaendlichere scripte sollte es nochmal noetig sein
nen zaubi nach oben zu treiben

-----------------------------------------------------------------------------



Re: Re: vorwarnung, lernen I (von III) (Dunst, 22. Nov 2001, 15:25:50):
~#! rn=Soul rt=1006434903 rg=gilden.zauberer
~#! tid=1006429571
Hallo erstmal.

Wenn ich mich richtig entsinne war der eigentliche Sinn von Deinen Gilden-
umstrukturierungen, Patryn, dass die Wurstzauberer und Huellenlieferanten 
nicht mehr so schnell aufsteigen koennen.

Sind aber solche nicht grade diejenigen (ohne irgendjemandem zu nahe treten
zu wollen), die sich in Sachen scripte sehr gut auskennen?
Und somit die jetzigen neuen Umstellungen umgehen koennen?

Ich denke diese Umstellung trifft (mal wieder) die Zaubis, egal ob Ersties,
oder nicht, die diese Gilde gewaehlt haben, weil sie einen Zauberer spielen
wollten.

Der Weg von ganz unten, bis in Bereiche, in denen Zauberer 'metzeln gehen'
koennen ist ziemlich lang, und, durch die ersten Verschaerfungen, schwer 
geworden.

Ueben erschweren gut und schoen, aber man sollte auch bei selten gebrauchten
Spruechen ne Chance haben, die in ertraeglicher Zeit hochzuueben.

Ich zum Beispiel geh ne Zeitlang zu einem NPC und versuche (von Hand) 
einige Sprueche hochzuueben, und mache dann was anderes. 

Ich habe meinen Zauberer hochgespielt, _weil_ es ein Zauberer ist. Und _nicht_
weil der gut zuhaun kann.

Dunst

-----------------------------------------------------------------------------



Re^3: vorwarnung, lernen I (von III) (Orktoeter, 22. Nov 2001, 15:32:59):
~#! rn=Dunst rt=1006439150 rg=gilden.zauberer
~#! tid=1006429571
Ich bin kein zauberer und habe auch keinen zauberer, aber wenn es nicht
erwuenscht ist, das man Spells innerhalb einer bestimmten Zeit perfektionieren
kann, warum dann nicht hart in den Code einbauen, das z.B. fuer die letzen 10
%  jeweils nur noch fuer 1%/(3 monate) gelernt werden kann?

(die zahlenangabe bitte als Hausnumemr verstehen)

Wenn die Zeit dann noch so gewaehlt ist, das ein "normal" aktiver Spieler in
der Zeit dieses eine % ohne zu scripten holt, duerfte die Motivation fuer
scripte auch ziemlich weg sein.

OrkT.

-----------------------------------------------------------------------------



Re^3: vorwarnung, lernen I (von III) (Mandragon, 22. Nov 2001, 15:33:33):
~#! rn=Dunst rt=1006439150 rg=gilden.zauberer
~#! tid=1006429571
Die Umstellung war lange Ueberfaellig.
20% schnell von 80% auf 100% in 2h ist einfach zu schnell.

Ma*

P.S.: Heult woanders

-----------------------------------------------------------------------------



Re^4: vorwarnung, lernen I (von III) (Elberet, 22. Nov 2001, 15:34:17):
~#! rn=Mandragon rt=1006439613 rg=gilden.zauberer
~#! tid=1006429571
setzt lieber da lernen unten nen bischen hoch

-----------------------------------------------------------------------------



Re^4: vorwarnung, lernen I (von III) (Dunst, 22. Nov 2001, 15:34:29):
~#! rn=Mandragon rt=1006439613 rg=gilden.zauberer
~#! tid=1006429571
aha?! und wo geht das? 


-----------------------------------------------------------------------------



Re^5: vorwarnung, lernen I (von III) (Mandragon, 22. Nov 2001, 15:35:28):
~#! rn=Elberet rt=1006439657 rg=gilden.zauberer
~#! tid=1006429571
Oh. Da war ich auch fuer ... so im 50%-Bereich, wo gar nix geht ... aber
dafuer oben massiv runterschrauben.

Ma*

-----------------------------------------------------------------------------



Re^5: vorwarnung, lernen I (von III) (Mandragon, 22. Nov 2001, 15:36:08):
~#! rn=Dunst rt=1006439669 rg=gilden.zauberer
~#! tid=1006429571
Gute Frage.

Aber Du erwartest nicht, dass ich das jetzt hier poste, oder ?

Ma*

-----------------------------------------------------------------------------



Re^6: vorwarnung, lernen I (von III) (Dunst, 22. Nov 2001, 15:37:42):
~#! rn=Mandragon rt=1006439768 rg=gilden.zauberer
~#! tid=1006429571

Natuerlich nicht. Aber sowas ist halt nicht ohne Scripte zu schaffen.
Und durch solche Umstellungen werden groesstenteils diejenigen bestraft, die
_nicht_ scripten.

Dunst

-----------------------------------------------------------------------------



Re^7: vorwarnung, lernen I (von III) (Mandragon, 22. Nov 2001, 15:38:14):
~#! rn=Dunst rt=1006439862 rg=gilden.zauberer
~#! tid=1006429571
Es geht darum, ohne skript

-----------------------------------------------------------------------------



Re^8: vorwarnung, lernen I (von III) (Ark, 22. Nov 2001, 15:44:47):
~#! rn=Mandragon rt=1006439894 rg=gilden.zauberer
~#! tid=1006429571
Tja, ich lernte nur Karate per Hand, ich fand das schon recht gut (damals),
schnelles Vorwaertskommen bis etwa 30%, ein wenig muehseliger bis 50%, dann
wieder einigermassen bis 95% und dann nur noch sehr langsam. Wohlgemerkt, das
ist nur das Gefuehl gewesen, als man noch platte Zahlen einsehen konnte. Ist
aber innerhalb von 35 Online Tagen bis zum hoechsten Grad zu machen gewesen.
Angesichts der hoeheren Kampfkraft duerfte es vielleicht 10 Onlinetage mehr
sein, in denen man sich bei den Zauberern ohne Scripten nach oben spielen
koennen muesste, ohne zu weinen. Ist dem so?


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^9: vorwarnung, lernen I (von III) (Anatol, 22. Nov 2001, 16:38:55):
~#! rn=Ark rt=1006440287 rg=gilden.zauberer
~#! tid=1006429571
Ganz klar: Wer will und kann, der kann. Also mit entsprechend tollen
Scriptpaket kann man die Zaubis weiter scripten - wie auch die Trves,
die Tanjian und den Rest vom megawaffenverwoehnten Pack. Das ist nicht
das Problem und wenn es das Problem waere, waere es unloesbar: Das
optimale Script verhaelt sich wie ein "Spieler mit natuerlichem
Spielverhalten" und damit ist die Kiste zu. Einwaende? Keine? Gut. :)

Das Problem ist: Fuer die Zauberer ist kein intelligentes Script
notwendig. Wirklich nicht. Wat dim ehnen sin Drachenschildkroete...
Das Aufwendigste ist das Tanken und Enttanken, das eigentliche Ueben
faengt mit "/repeat " an und geht nicht allzulang weiter.

Mit einer Umstellung, so wie Patryn sie vorschwebt, werden zwei Dinge
erreicht: a) Die Scripte MUESSEN besser werden, sie muessen sich mehr
und mehr dem normalen Spielverhalten anpassen.

Geweine a la Sauls "Dann liegt halt noch mehr Kram in den Seherhaeusern"
ist schon etwas Fehl am Platze. Und Geschrei wie "Da werden nur wieder
die nicht-scripter bestraft!" auch. Warum? Weil b) auch diejenigen um-
denken muessen, die nicht scripteten aber auch nicht nachdachten, ihren
Spruch halt stumpf hochziehen wollen (so, f, nw, (warten), so, f, nw...).
Und mit Verlaub, DAS kann es ja wohl auch nicht sein. Nur weil es bei
den Trves und der Drachenschildkroete geht, muss es ja nicht auch bei
den Zauberern funktionieren.

Mit etwas Know-How ist ein Zauberer *ohne* optimierte Scripts in zwei 
Wochen auf Magister "gemaxt", das groesste Hindernis sind dann die
Quests. Und fuer das, was da hinten rauskommt - also ein Zauberer, der
zwar nicht so angriffsstark wie ein Trves, aber dafuer das Nonplusultra
an Improvisationsfaehigkeit ist - ist ein gehobener Anspruch an das
Hirn des Betroffenen schon angebracht. Die Welt hat der Haukes genug.

Und dabei geht es bei der ganzen Geschichte nichtmal um (fuer den 
Spieler) komplizierte Dinge. Die Dinge sind nur fuer den kompliziert,
der den Scheiss proggen muss.

Anatol

-----------------------------------------------------------------------------



Re^9: vorwarnung, lernen I (von III) (Patryn, 22. Nov 2001, 16:41:11):
~#! rn=Ark rt=1006440287 rg=gilden.zauberer
~#! tid=1006429571
das geht derzeit deutlich schneller, trotz des nicht kleinen zeitbedarfs
fuer die zaubiquests.
ihr werdet mir die tatsache nicht ausreden koennen, dass erfolgslernen um
einiges zu flink ist...andererseits ist mir durchaus bewusst, dass es
dazwischen irgendwo eine durststrecke gibt.
letztlich werd ich erst mal die idee II verwirklichen und dann auch nicht
zu detailliert, aber doch detailliert genug ankuendigen, um das dann noch
mal sinnvoll zu diskutieren.

-- 
patryn

-----------------------------------------------------------------------------



Re^9: vorwarnung, lernen I (von III) (Vardion, 22. Nov 2001, 16:42:01):
~#! rn=Ark rt=1006440287 rg=gilden.zauberer
~#! tid=1006429571
Naja - ich finde es etwas albern, aus den letzten 3% nen Krampf zu machen. Da
fand ich das Erfolgslernen an sich schon gut. Ueber die Staerke laesst sich
sicher reden.

Vardion

-----------------------------------------------------------------------------



Re^10: vorwarnung, lernen I (von III) (Gloinson, 22. Nov 2001, 16:57:41):
~#! rn=Patryn rt=1006443671 rg=gilden.zauberer
~#! tid=1006429571
Vom Scripten abgesehen - da ich es nicht aendern kann tendiere ich dazu es zu
ignorieren - es ist auch ein Spiel Zauberer zu sein. Nun mag man sich ueber
die Realitaet streiten koennen, aber das Zaubern erlernt man eben nur mit
wechselnden Bemuehungen, so wie jede Faehigkeit. Wenn das drunterliegende
System das hergibt und sich auch jemand findet es zu bauen - hat sich wohl -
dann ist IMHO kein Argument dagegen zu finden es auch einzurichten der, nennen
wir sie erdachte Realitaet etwas naeher zu kommen.

Gloin(son)

PS: Hatte ich schon erwaehnt dass es den Erbauern meist darum geht ein Feeling
zu vermitteln und nicht Punkte irgendwie zu verteilen?

-----------------------------------------------------------------------------



Re^10: vorwarnung, lernen I (von III) (Saul, 22. Nov 2001, 17:39:52):
~#! rn=Anatol rt=1006443535 rg=gilden.zauberer
~#! tid=1006429571
>Geweine a la Sauls "Dann liegt halt noch mehr Kram in den Seherhaeusern"

Ich musste den ganzen Kram nochmal lesen, bevor ich mir sicher war, dass
dies keine boshafte Beleidigung war, sondern nur ein "Freudscher Ver-
sprecher".
Trotzdem bin ich von Dir mehr Sorgfalt in Deinen Artikeln gewohnt.

Saul

-----------------------------------------------------------------------------



Re^10: vorwarnung, lernen I (von III) (Ark, 22. Nov 2001, 18:01:23):
~#! rn=Anatol rt=1006443535 rg=gilden.zauberer
~#! tid=1006429571
Dann bin ich spontan dafuer, jegliche Einschaetzung des Spielers seitens der
Gildenoberhaeupter oder anderer Listen zu verweigern und sie durch
zufallsgenerierte Sprueche abzuspeisen. Wer nicht weiss, wie gut/schlecht er
in Zahlen ist, der fragt sich vielleicht, wie lange er noch als Uebescript
herumlaufen soll. Vielleicht ... 
Jo, mir is klar, dass dann das evtl. vorhandene Lookup-Device (Lvl 20 Magier)
einspringen koennte, aber immerhin steht das nicht jedem zur Verfuegung und
faellt irgendwann mal auf.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^11: vorwarnung, lernen I (von III) (Anatol, 22. Nov 2001, 19:25:57):
~#! rn=Saul rt=1006447192 rg=gilden.zauberer
~#! tid=1006429571
mea culpa. Ich hatte ihn sogar noch angefingert um zu sehen, ob der
irgendwo dazugehoert...

Anatol

-----------------------------------------------------------------------------



Re^12: vorwarnung, lernen I (von III) (Wurzel, 25. Nov 2001, 21:25:10):
~#! rn=Anatol rt=1006453557 rg=gilden.zauberer
~#! tid=1006429571
so ganz klar ist mir nie geworden, warum man unbedingt jeden obskuren spruch
auf 100% haben muss. die sprueche, die man tatsaechlich benoetigt, hat man
auch im "normalen" spielbetrieb doch schnell genug oben.
das einzig laestige daran sind doch offensichtlich die stupse, die man durch
die gilden bekommt. wenn man die einfach abschaffen bzw. anders vergeben
wuerde, braeuchte niemand mehr unfug zu skripten, oder seh ich da was nicht?

wurzel

-----------------------------------------------------------------------------



Re^13: vorwarnung, lernen I (von III) (Mandragon, 25. Nov 2001, 21:26:48):
~#! rn=Wurzel rt=1006719910 rg=gilden.zauberer
~#! tid=1006429571
Letzteres.

In einigen gilden lernt man im normalen Spielbetrieb recht wenig, die
Auswirrkungen von max-skills sind jedooch wesentlich hoeher als die von
mittelmaessigen Skills.

Ma*

-----------------------------------------------------------------------------



Re^13: vorwarnung, lernen I (von III) (Karis, 26. Nov 2001, 22:50:12):
~#! rn=Wurzel rt=1006719910 rg=gilden.zauberer
~#! tid=1006429571
Da gehts nich um Punkte. Es ist _wichtig_, alle Skills auf 100% zu haben.
Meine Guete, was ich in meiner aktiven Zeit alles geschimpft wurde,
nur weil mir noch ein paar Skills fehlten.... 
Aber es ist unheimlich schwierig, Dir das jetzt genauer zu erklaeren.
Du bist schliesslich Magier :)

Ex-Generaelchen Karis.

-----------------------------------------------------------------------------



Re^14: vorwarnung, lernen I (von III) (Wurzel, 26. Nov 2001, 22:53:13):
~#! rn=Karis rt=1006811412 rg=gilden.zauberer
~#! tid=1006429571
wahrscheinlich hast du recht, als magier reicht die geistige kapazitaet
nicht immer aus, die spieler zu verstehen.

-----------------------------------------------------------------------------



Re^15: vorwarnung, lernen I (von III) (Zarniya, 28. Nov 2001, 10:18:51):
~#! rn=Wurzel rt=1006811593 rg=gilden.zauberer
~#! tid=1006429571
Ich muss hier an dieser Stelle mal wieder Wurzel Recht geben und einfach die
Farge Stellen, ob es ueberhaupt sinnvoll ist, dass man etwas auf 100% lernen
kann. Wir sind doch alle Lebewesen hier mit Fehlern und selbst ein perfekter
Zauberer kann man was einfaches versemmeln (zum Beispiel, wenn er nen
schlechten Tag hat). Waere es also nicht eher sinnvoll, die 100% eh
unerreichbar zu machen? Dann kann man sich auch nie auf einen Spruch
verlassen, was ein netter Spielspass ist. 

Ich verweise da wieder auf ein anderes Mud, wo man zB je nach Rasse oder Beruf
gewisse Skills oder Spells eh nur auf hoechstens 10% lernen kann, weil ein
Troll zum Beispiel einfach zu dumm zum Zaubern ist... was ich damit sagen
will: Wenn Silvana & Co es wirklich wollen, dann kann noch alles viel
Schlimmer kommen, als ihr denkt. Und ich weiss, dass Silvana sehr sehr gerne
rollenspielt und solche Ideen liebt :)

Marc

-----------------------------------------------------------------------------



Re^16: vorwarnung, lernen I (von III) (Orktoeter, 28. Nov 2001, 10:40:26):
~#! rn=Zarniya rt=1006939131 rg=gilden.zauberer
~#! tid=1006429571
Dafuer brauchst du nicht erst auf ein anderes MUD verweisen. Bei den Kaempfern
ist es ja bereits so. Wenn du von 100% sprichst sollte mal darueber diskutiert
werden, ob 100% eines Skills auch gleich 100% dessen sind, was man lernen
kann. Man kann das ja durchaus so managen, das man zwar 100% lernen kann, aber
den skill dadurch trotzdem "nur" auf 98-99% bekommt. Alternativ kann man auch
nen Randomfumble einbauen, der auch bei 100%-skill zuschlaegt. Wie das nun
genau geloest wird ist dann eher zweitrangig.
Eine Sache, die mir bei den Kaempfern auch sehr gefaellt ist, das es sich dort
erheblich bemerbar macht, wenn man angeschlagen ist. Ist ja auch sehr
einsichtig, das man, wenn man 3/4-tot ist nicht mehr so viel bringt als wenn
man absolut fit ist.

OrkT.

-----------------------------------------------------------------------------



Re^17: vorwarnung, lernen I (von III) (Anatol, 28. Nov 2001, 10:47:34):
~#! rn=Orktoeter rt=1006940426 rg=gilden.zauberer
~#! tid=1006429571
Bleibt doch bitte bei euren Leisten, ja? 

Anatol - findet es toll, wenn Leute, die absolut keine Ahnung von der
         Zauberergilde haben (sonst wuessten sie, dass auch sogenannte
         100%-Zauber ohne Probleme schmerzlichst patzen koennen), dem
         Gildenmagier erklaeren, was er tun sollte und was nicht. Sowas
         macht doch sonst nur er. ;)


-----------------------------------------------------------------------------



Re^18: vorwarnung, lernen I (von III) (Pitfall, 28. Nov 2001, 11:02:09):
~#! rn=Anatol rt=1006940854 rg=gilden.zauberer
~#! tid=1006429571
100 % zauber patzen i.d.r. nicht wirklich oft
wenn du 100 % skills sehen willst die patzen, schau dir die kaempfer an

-----------------------------------------------------------------------------



Re^19: vorwarnung, lernen I (von III) (Zook, 28. Nov 2001, 11:02:33):
~#! rn=Pitfall rt=1006941729 rg=gilden.zauberer
~#! tid=1006429571
Oh, bald ist der Thread reif fuer "Gejammer". :-)

Zook.

-----------------------------------------------------------------------------



Re^19: vorwarnung, lernen I (von III) (Patryn, 28. Nov 2001, 11:06:54):
~#! rn=Pitfall rt=1006941729 rg=gilden.zauberer
~#! tid=1006429571
dann will ich lieber nicht drueber nachdenken was kaempfer mit 100% und
ohne patzer darstellen.

-- 
patryn, seit jahren fuer abwertung@trves (keine sorge, habs aufgegeben)

-----------------------------------------------------------------------------



Re^20: vorwarnung, lernen I (von III) (Gnome, 28. Nov 2001, 11:10:31):
~#! rn=Patryn rt=1006942014 rg=gilden.zauberer
~#! tid=1006429571
das gleiche, als wenn sie keine patzer haetten. dann gaeb es allerdings
nicht so lustig situationen, in denen sich der ausbilder vor seinem
lehrling nackich macht, oder man sich mit einer stumpfen keule die
hand abschlaegt, was doch erheblich zum unterhaltungswert beitraegt. :)

gnOme

-----------------------------------------------------------------------------



Re^21: vorwarnung, lernen I (von III) (Gloinson, 28. Nov 2001, 11:13:07):
~#! rn=Gnome rt=1006942231 rg=gilden.zauberer
~#! tid=1006429571
Ich will hier mitscrollen. Vor allem wollte ich mal erwaehnen das die Zauberer
mit zuviel Wasser in den Beinen oder im Bauch auch keine Feuerzauber mehr
sprechen duerfen sollten. Oder oefter patzen.

Gloin"was gibt es fuer ein Re^100"(son)

-----------------------------------------------------------------------------



Re^22: vorwarnung, lernen I (von III) (Silvana, 28. Nov 2001, 11:45:45):
~#! rn=Gloinson rt=1006942387 rg=gilden.zauberer
~#! tid=1006429571
Fuer Re^100 gibt's nen Magierlevel. Abgezogen.

  Silvana (toternst)

-----------------------------------------------------------------------------



Re^16: vorwarnung, lernen I (von III) (Ark, 28. Nov 2001, 15:32:06):
~#! rn=Zarniya rt=1006939131 rg=gilden.zauberer
~#! tid=1006429571
Moep, wir sind perfekte Files mit keinen Fehlern. Oder bin ich hier doch im RL
gelandet?


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



stufen (Patryn, 28. Nov 2001, 16:47:44):
da ich mich eh schon dran gewoehnt habe, boese und gemein zu sein,
habe ich spontan noch mal die levelanforderungen der zaubis umgestrickt.
naeheres siehe faq.
einer der gruende ist dass identifiziere erst ab level20 nicht wirklich
nett war, aber es gab noch mehr.
alternative waere hoeherer gildeneinstiegslevel gewesen, wollt ich nich.

-- 
patryn

-----------------------------------------------------------------------------



Gildenhomepage (Apophis, 28. Nov 2001, 20:23:25):
Aloha Gildenkollegen und -kolleginnen

Die Gildenhomepage wurde nach langem NichtDrumKuemmern
von mir mal wieder ueberarbeitet.

Bitte seht sie Euch mal an und schreibt mir wenn Ihr
Fehler entdeckt, weitere Ideen habt oder sonst
irgendwas auf dem Herzen habt ;)

Nach meiner langen Mudabstinenz (so ca. 1 - 1 1/2 Jahre
duerften das gewesen sein) habe ich leider noch nicht
wieder den vollen Ueberblick ueber unsere Gilde und da
sich im Moment ja auch recht viel tut, gibt es mit
Sicherheit auch Teile an der Homepage die nicht mehr
aktuell sind.
Wenn Ihr sowas entdeckt schreibt mir bitte.

Achja, wenn gewollt kann auch das Design ueberarbeitet
werden, bzw. ein ganz neues her. Ich denke da an etwas
mehr dynamischere Seiten via PHP, dhtml, js, etc.
Jetzt ist meine Frage, ob das von der Mehrheit gewollt
ist, da ja auch manche Leute ueber Browser auf die
Seiten zugreifen, die z.B. js nicht unterstuetzen oder
nicht aktiviert haben.
Auch dazu mir einfach ne Mail schreiben, entweder
Mudmail an Apophis oder an zauberergilde@gmx.net

Die URL lautet natuerlich www.zauberergilde.de

Apophis

-----------------------------------------------------------------------------



Re: stufen (Seno, 28. Nov 2001, 21:05:42):
~#! rn=Patryn rt=1006962464 rg=gilden.zauberer
~#! tid=1006962464
freut mich, dass fuer die ersten 5 Gildenlevel jetzt wieder "vernuenftige"
Stufenanforderungen gelten. Die GL 9 und 10 kann man mit den Moeglichkeiten
(vor allem der Kampfkraft), die sie bieten, ruhig hochstufigen Spielern
vorbehalten, darin stimme ich Dir auch nach wie vor zu. Nur im mittleren
Bereich, also GL 6-8, sind die Anforderungen weiterhin weit ueberzogen.


Zum Vergleich:

Spruch		Abenteurerstufe	Zaubererstufe

Schaetz	10		30
Feuerball	15		30
Schnell	17		40


Dass man als _Zauberer_ diese Sprueche erst so viel spaeter lernen kann als
ein Abenteurer, finde ich geradezu laecherlich und dem ungleich hoeheren
Aufwand (Ueben, Gildenquesten) voellig unangemessen.

Schoen, dass Du auch mal im oberen Bereich ansetzt (Erfolgslernen) und gegen
das Skripten vorgehst.

Seno

-----------------------------------------------------------------------------



Re: Re: stufen (Gloinson, 28. Nov 2001, 21:08:58):
~#! rn=Seno rt=1006977942 rg=gilden.zauberer
~#! tid=1006962464
Nicht jede Gilde ist mit einer anderen vergleichbar. Insbesondere die
Abenteurer wurden levelmaessig nie wirklich angepasst.

Gloin(son)

-----------------------------------------------------------------------------



Re: Gildenhomepage (Silvana, 28. Nov 2001, 21:42:29):
~#! rn=Apophis rt=1006975405 rg=gilden.zauberer
~#! tid=1006975405
Nichts gegen ein modernes Design und auch nichts gegen aktive Elemente auf der
Webseite (immerhin verdien ich einen Teil meines Geldes mit der Herstellung
von Multimediainhalten, da sollte ich nicht dagegen sein...), aber beachtet
bitte die Regel: Auch ohne all die plugins und aktiven Teile, voellig
reduziert auf reines HTML 4, sollte die Seite noch gut aussehen und den vollen
Inhalt bieten! Wenn das gewaehrleistet ist, hab ich nichts gegen Spielereien,
wenn sie (im positiven Sinne) zum Flair der Seite beitragen.

  Silvana

-----------------------------------------------------------------------------



Re: Re: stufen (Vardion, 28. Nov 2001, 22:25:08):
~#! rn=Seno rt=1006977942 rg=gilden.zauberer
~#! tid=1006962464
Du willst doch nicht im Ernst den Feuerball der Abenteurer mit unserem auf
eine Stufe stellen???

Vardion, erschuettert

-----------------------------------------------------------------------------



Re^3: stufen (Mupfel, 28. Nov 2001, 22:32:14):
~#! rn=Vardion rt=1006982708 rg=gilden.zauberer
~#! tid=1006962464
Nunja, der Feuerball der Abenteurer hat nicht soviele verschiedene
Meldungen...

-mupfel-

-----------------------------------------------------------------------------



Re: Re: stufen (Patryn, 28. Nov 2001, 22:39:18):
~#! rn=Seno rt=1006977942 rg=gilden.zauberer
~#! tid=1006962464
tut mir leid, die spoells sind derart unvergleichbar, dass dies
als argument kaum zieht..
auch nmoechte ich vermeiden, dass man spaeter ploetzlich
>20 level braucht um zb von 8 auf 9 zu erhoehen und
finde einen moderaten aber harten anstieg besser.

-- 
patryn

PS: diskutieren koennt ihr das natuerlich gern,
 hab mich beim ersten teil ja auch ueberr4eden lassen nachdem
 wir mit silvana verschiexcene moeglichkeiten abwaegten

-----------------------------------------------------------------------------



Re^3: stufen (Seno, 28. Nov 2001, 23:46:14):
~#! rn=Patryn rt=1006983558 rg=gilden.zauberer
~#! tid=1006962464
ich finde, dass die Stufenanforderungen zwischen GL 5 und GL 9 nicht linear,
also immer 10 Stufen mehr, ansteigen sollten, weil auch die Moeglichkeiten und
die Kampfkraft des Zauberers nicht linear ansteigen. Ich faende L15->GL6,
L20->GL7 und L30->GL8 angemessen. Am besten faende ich, GL8 mit L25
zuzulassen, aber erst 2 der 6 Sprueche freizuschalten und dann alle 5 Stufen
jeweils einen der anderen 4 Spells.

auf konstruktive Beitraege und keine unnoetig lange Diskussion hoffend,
Seno

-----------------------------------------------------------------------------



Re^4: stufen (Wurzel, 28. Nov 2001, 23:48:12):
~#! rn=Seno rt=1006987574 rg=gilden.zauberer
~#! tid=1006962464
manche verstehen es einfach nicht. lange diskussionen sind nicht unnoetig,
sondern manchmal sehr unterhaltsam. besonders wenn sie sinnfrei werden, und
sind wir nicht alle zur unterhaltung hier?

-----------------------------------------------------------------------------



Re^5: stufen (Seno, 29. Nov 2001, 19:06:27):
~#! rn=Wurzel rt=1006987692 rg=gilden.zauberer
~#! tid=1006962464
*grins*

manchmal geht es aber auch um Themen, die dem einen oder anderen am Herzen
liegen und nicht jede/r liest die mpa in erster Linie zur Unterhaltung ;)
Und fuer dieses Beduerfnis gibt es ja auch Rubriken ;)

Seno

-----------------------------------------------------------------------------



Re^4: vorwarnung, lernen I (von III) (Tektuko,  1. Dez 2001, 07:13:32):
~#! rn=Mandragon rt=1006439613 rg=gilden.zauberer
~#! tid=1006429571
So lang? Am richtigen Npc machst du bei schnell am Ende 10% in 20min

-----------------------------------------------------------------------------



Re^7: vorwarnung, lernen I (von III) (Tektuko,  1. Dez 2001, 07:14:49):
~#! rn=Dunst rt=1006439862 rg=gilden.zauberer
~#! tid=1006429571
Doch, es ist ohne scripten zu schaffen, mann mus nur den richtigen Gegner
kennen ;) dann lernt man bei fast jedem schnell wo man macht ausm erfolg

-----------------------------------------------------------------------------



Re^5: vorwarnung, lernen I (von III) (Anatol,  1. Dez 2001, 11:22:34):
~#! rn=Tektuko rt=1007187212 rg=gilden.zauberer
~#! tid=1006429571
Manchmal frage ich mich, woher Spieler die Prozentwerte zu wissen glauben.

Anatol, sah da nur Dinge wie "fast befriedigend" o.ae.

-----------------------------------------------------------------------------



Re^6: vorwarnung, lernen I (von III) (Tektuko,  1. Dez 2001, 11:27:17):
~#! rn=Anatol rt=1007202154 rg=gilden.zauberer
~#! tid=1006429571
Mh die stehn doch auf der Homepage

-----------------------------------------------------------------------------



Re^7: vorwarnung, lernen I (von III) (Tektuko,  1. Dez 2001, 11:29:23):
~#! rn=Tektuko rt=1007202437 rg=gilden.zauberer
~#! tid=1006429571
http://zauberergilde.magenbrot.net/tabellen.html <- Mit Hilfe der Tabelle kann
mans gut ausrechnen ;)

-----------------------------------------------------------------------------



Re^8: vorwarnung, lernen I (von III) (Croft,  1. Dez 2001, 12:00:14):
~#! rn=Tektuko rt=1007202563 rg=gilden.zauberer
~#! tid=1006429571
Da hast du eine Liste der moeglichen Bewertungen, die uebrigens auch in
der ZFAQ stehen.  Aber um die FAQ zu zitieren:
"In dieser Reihenfolge, aber alles andere als linear."
Was so viel heisst wie: die Abschnitte sind alles andere als gleich gross.
Gruss Croft

-----------------------------------------------------------------------------



Re^9: vorwarnung, lernen I (von III) (Wurzel,  1. Dez 2001, 12:03:02):
~#! rn=Croft rt=1007204414 rg=gilden.zauberer
~#! tid=1006429571
jetzt lass den leuten doch ihre illusionen. hinterher gaebs ja hier keine
vehementen proteste mehr zu lesen, und das mud waere wieder ein stueck
aermer :)

-----------------------------------------------------------------------------



Re^10: vorwarnung, lernen I (von III) (Croft,  1. Dez 2001, 12:06:35):
~#! rn=Wurzel rt=1007204582 rg=gilden.zauberer
~#! tid=1006429571
Argl.  Da war ich wieder viel zu voreilig und korrigierend.  Haett ich
doch erst nachgedacht bevor ich meinen Artikel gepostet hab ;-)

-----------------------------------------------------------------------------



Re^11: vorwarnung, lernen I (von III) (Vincent,  1. Dez 2001, 12:56:05):
~#! rn=Croft rt=1007204795 rg=gilden.zauberer
~#! tid=1006429571
Ich ordne Deinen Artikel in den Bereich Aufklaerungsjournalismus ein. Dass
sich daraus keine grossartige Diskussion ergibt, liegt nicht an Deinem 
Vorgehen sondern an dem minder reisserischen Inhalt. Aber warten wir
doch einfach mal ab, welche Vermutungen von Spielerseite noch kommen, und wie
die Dementis der Magiere dazu aussehen. ;-)
Gruss
Vincent

-----------------------------------------------------------------------------



Re^12: vorwarnung, lernen I (von III) (Anatol,  1. Dez 2001, 14:42:13):
~#! rn=Vincent rt=1007207765 rg=gilden.zauberer
~#! tid=1006429571
Den Magiern machen Dementis auch nicht wirklich Spass. Ich persoenlich hab'
nichts dagegen, Gildenmagier etc. nicht ZU sehr zu nerven und Leuten, die
Elefanten sehen wo Affen sind, einen Gang in den Zoo (=Zfaq) anzuraten. [1]

Anatol

[1] Klar nerv' ich die Gildenmagier auch. Aber doch nicht den EIGENEN. :)


-----------------------------------------------------------------------------



Re^13: vorwarnung, lernen I (von III) (Silvana,  1. Dez 2001, 14:43:53):
~#! rn=Anatol rt=1007214133 rg=gilden.zauberer
~#! tid=1006429571
zu [1]: Nicht...? ;-)
Ich dachte, Du haettest in allen Gilden...?

  Silvana (nicht wirklich ernst)

-----------------------------------------------------------------------------



'werte' buggt... (Whitetiger,  3. Dez 2001, 20:49:17):
hi,
ich wollt nur mal anmerken dass der 'werte'-spruch buggt, ich habs mal hierhin
geschrieben, weil ich nicht wusste, wos sonst hinsoll...
beispiele:
... hat nett.
... ist einen guten Charakter.
ich denke, da ist was verdreht worden.

wt.

-----------------------------------------------------------------------------



Re: 'werte' buggt... (Vardion,  3. Dez 2001, 20:50:17):
~#! rn=Whitetiger rt=1007408957 rg=gilden.zauberer
~#! tid=1007408957
Das ist bereits gemeldet worden, und der richtige Weg zum melden ist 'zbug'.

Vardion

-----------------------------------------------------------------------------



Re: 'werte' buggt... (Patryn,  3. Dez 2001, 20:50:46):
~#! rn=Whitetiger rt=1007408957 rg=gilden.zauberer
~#! tid=1007408957
zbug,
mail patryn,
mail silvana,
mail gm_zauberer
tm patryn
tm silvana
zrufe
u.s.w.

nur als tip, wenn jemand noch mal nich weiss wo sowas hin soll

-- 
patryn

-----------------------------------------------------------------------------



Re: Re: 'werte' buggt... (Whitetiger,  3. Dez 2001, 20:50:56):
~#! rn=Vardion rt=1007409017 rg=gilden.zauberer
~#! tid=1007408957
wusst ich nicht, tut mir leid...
wt.

-----------------------------------------------------------------------------



Re^3: 'werte' buggt... (Gloinson,  3. Dez 2001, 20:51:24):
~#! rn=Whitetiger rt=1007409056 rg=gilden.zauberer
~#! tid=1007408957
Tue Busse. Werd Kleriker.

Gloin(son), zwinkert

-----------------------------------------------------------------------------



Re^4: 'werte' buggt... (Whitetiger,  3. Dez 2001, 20:51:52):
~#! rn=Gloinson rt=1007409084 rg=gilden.zauberer
~#! tid=1007408957
wieso kleriker?

-----------------------------------------------------------------------------



Re^5: 'werte' buggt... (Isi,  3. Dez 2001, 20:52:49):
~#! rn=Whitetiger rt=1007409112 rg=gilden.zauberer
~#! tid=1007408957
Busse? wieso wills Du dass er ein transporttmittel werden soll?
isi (haettwohlnach schmarrngehoertwerfend)
-

-----------------------------------------------------------------------------



Re^5: 'werte' buggt... (Gloinson,  3. Dez 2001, 20:53:35):
~#! rn=Whitetiger rt=1007409112 rg=gilden.zauberer
~#! tid=1007408957
Wegen der Busze. Und nenn mich jetzt nicht Acrimon.

Gloin(son)

-----------------------------------------------------------------------------



Re: Re: 'werte' buggt... (Zook,  3. Dez 2001, 22:47:52):
~#! rn=Patryn rt=1007409046 rg=gilden.zauberer
~#! tid=1007408957
Oh, prima. Sogar das neue "gm_zauberer" ist erwaehnt worden.

Zook grinst freudig in die Runde.

-----------------------------------------------------------------------------



Schritt II (Patryn, 10. Dez 2001, 21:59:08):
hoi, also der lerncache ist nun dran, das ist dieses ding was verhindern
soll, dass man die ganze zeit an seinem haustier uebt und sowas.
auch die ganze zeit im selben raum zu ueben ist eher schaedlich.
das ganze teil steht noch unter beobachtung und kann sich noch aendern,
ich muss hier aber dennoch drauf hinweisen, dass man beim ueben wieder
etwas genauer hinschaun sollte, ob und wenn ja, was genau passiert.
je nachdem wie es laeuft wird schritt III im herkoemmlichen sinn evtl.
sogar ueberfluessig, ich werd mal sehen.

-- 
patryn

-----------------------------------------------------------------------------



magisterpruefung (Silvana, 13. Dez 2001, 15:40:22):
Die Magisterpruefung ist um einen Bug aermer. Ich hoffe einfach mal, dass
damit die seltsamen Vorkommnisse der Vergangenheit beseitigt sind. Viele Dank
an Lacri fuer so viel Opferbereitschaft und Geduld. :)

  Silvana

-----------------------------------------------------------------------------



Update (Ark, 17. Dez 2001, 21:31:12):
Und wieder mal ist es Zeit fuer ein kleines Update, wieder in der Rubrik, in
der es wohl am besten passt. Wie steht es um den Fortschritt der Raeume,
Monster, Lehrmeister und Objekte der neuen Gilde?

The magical convent of Castalla Rosso:
Aktuelle Zahl geplanter Raeume    ->   223
Davon fertig                      ->     6
Aktuelle Zahl geplanter NPCs      ->    59
Davon fertig                      ->     2
Aktuelle Zahl geplanter Objekte   ->     6
Davon fertig                      ->     5
Aktuelle Zahl geplanter Kuratoren ->    18
Davon fertig                      ->     0
Aktuelle Zahl geplanter Aufgaben  ->    10
Davon fertig                      ->     1

Further bulletins as events warrant.

Im Moment sind die Langbeschreibungen der Raeume fertig, jetzt folgt die
"Besichtigung" des Rohbaus. Sicher wird sich noch einiges veraendern, aber
mittlerweile koennen wir schon einige edle Zuege hinter den groben
Gesichtskrusten der Gilde entdecken. Das Abschlagen der restlichen Teile ist
muehsam, dafuer strahlt uns am Ende aber sicher ein schoenes Antlitz entgegen.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Update (Grimmborn, 17. Dez 2001, 21:50:55):
~#! rn=Ark rt=1008621072 rg=gilden.zauberer
~#! tid=1008621072
6 von 223 Raeume sind fertig. Respekt. Denn mal weiter in die Haende spucken,
und die neue Gilde ist fertig bevor Neele ihren Vater als Mudgott beerben
kann...

GdA

-----------------------------------------------------------------------------



Re: Re: Update (Neele, 17. Dez 2001, 21:53:08):
~#! rn=Grimmborn rt=1008622255 rg=gilden.zauberer
~#! tid=1008621072
Stimmt, in 15 Jahren habe ich durchschnittliches Mudderalter erreicht, dann
uebernehme ich den Laden hier.

Neele

-----------------------------------------------------------------------------



Re: Update (Gor, 18. Dez 2001, 21:39:21):
~#! rn=Ark rt=1008621072 rg=gilden.zauberer
~#! tid=1008621072
War das ne Uebersicht ueber die Schwerttaenzer Gilde? *rotfl* ;)

Gor -> schmarrn

-----------------------------------------------------------------------------



Magisterpruefung (Silvana, 12. Jan 2002, 11:37:31):
Aufgrund fuer mich derzeit nicht nachvollziehbarer BUGS in der
Magisterpruefung ist selbige derzeit nicht anzuraten. Es sei denn, man steht
auf Selbstmord zugunsten der Gilde... ;-) Ich werde hier Entwarnung geben,
wenn der Bug (hoffentlich) gefixed ist. Ich koennte allerdings gelegentlich
einen opferbereiten "Pruefling" zum Testen brauchen... ;-)

  Silvana

-----------------------------------------------------------------------------



Re: Magisterpruefung (Silvana, 12. Jan 2002, 20:42:02):
~#! rn=Silvana rt=1010831851 rg=gilden.zauberer
~#! tid=1010831851
Da es nach ein paar kleineren Umbauarbeiten schon zwei Zauberern gelungen ist,
die Magisterpruefung zu bestehen, muss ich die wohl mal schwerer machen.
Aehm... nein... Was ich sagen wollte, war: Die Umbauarbeiten waren aller
Wahrscheinlichkeit nach erfolgreich. Die Pruefung scheint keine reine
Todesfalle mehr zu sein. :)

  Silvana

-----------------------------------------------------------------------------



zauberstab (Patryn, 23. Jan 2002, 23:36:33):
hi leute,

nachdem ich von jemanden auf ein bug im zauberstab aufmerksam gemacht wurde
der es ermoeglichte, weit ueber 150 stabmagiepunkte als maxwert zu haben,
habe ich das mal repariert.
auch bei den leuten die sich mal wieder nicht entbloeden konnten, das seit
monaten zu nutzen.
und nein, bitte kommt mir jetzt nicht wieder mit: ich hab das nicht gewusst
und dachte, das sei normal.
na ja, sie haben keine weiteren einschraenkungen erfahren, habs mir nur
notiert, man trifft sich ja immer mehrmals im leben, schaetz ich.

-- 
patryn

-----------------------------------------------------------------------------



Re: zauberstab (Patryn, 23. Jan 2002, 23:40:44):
~#! rn=Patryn rt=1011825393 rg=gilden.zauberer
~#! tid=1011825393
ehe es zu missverstaendnissen kommt: ueberladen des stabes ist OK und
gewollt als feature...der maxwert ist das, wohin der stab automatisch
hinstrebt beim idlen.

-- 
patryn . o O(doku?)

-----------------------------------------------------------------------------



robe (Patryn, 24. Jan 2002, 00:48:00):
gruene robe sollte wieder tun bei unterstuetzung, test it...

-- 
patryn

-----------------------------------------------------------------------------



unterstuetzungen (Patryn, 24. Jan 2002, 00:58:43):
hi leute,

mich verwundern ein paar mails und zbugs etwas, auch wenn ich inzwischen
so verunsichert war dass ich selbst erst nachschaun muste :)
jeder zweig wird durch einen bestimmten ruestungstyp unterstuetzt,
das ist technisch so noetig weil es schwierig waer sich mischende
unterstuetzungen bei selben spells auszubalancieren.
wer diese liste nun im kopf (haha) abruft wird feststellen,
dass "tatarata" huete jeglicher art gar nix unterstuetzen.

deshalb sind auch jegliche anfragen diesbezueglich sinnlos, bis...ja bis
vieleicht mal nen zweig dazukommt ("hahahaha")

-- 
patryn

-----------------------------------------------------------------------------



Re: unterstuetzungen (Patryn, 24. Jan 2002, 01:02:21):
~#! rn=Patryn rt=1011830323 rg=gilden.zauberer
~#! tid=1011830323
ah und noch was...sollten ruestungen irgendwo sich nicht an ihren zweig
halten, dann gibts ein problem: der code beherrscht das nicht.
es ist total unklar was dabei letztlich rauskommt und darf als bug gelten,
der mir bitte schoen gemeldet wird.
glaubt mir: die werte addieren sich nich sondern ueberschreiben sich
zufaellig je nach inventarreihenfolge. es bringt nix und verwirrt.
werd wohl mal ne check-funktion in den wilden armour-master einbaun.

-- 
patryn

-----------------------------------------------------------------------------



unterstuetzungen (Patryn, 24. Jan 2002, 14:32:06):
hi leute,

noch mal unterstuetzungen :)
zwar unterstuetzen niemals (ausser bugs, thX fuer hinweise) 2 ruestungstypen
einen zweig, aber ein ruestungstyp kann durchaus mehrere zweige
unterstuetzen.
nun finde ich es eigentlich eher unschoen, dass huete nix unterstuetzen und
dafuer ringe zb angriff und beherrschung.
beherrschung passt doch eher besser zu hueten ;)
also werden demnaechst irgendwann mal beherrschungs-spells aus ringen
rausgeworfen und in huete rein.
nun bitte ich euch um hinweise, welche huete ideal fuer zaubis waeren.
die huete sollen atmosphaerisch passen und es soll eingeschaetzt
werden, wie schwer sie zu bekommen sind und
was sie unterstuetzen koennten von
beherrschung.
also ran ans mailschreiben :) dank euch

-- 
patryn

-----------------------------------------------------------------------------



die robe ist keine robe ist keine... (Patryn, 28. Jan 2002, 11:14:12):
die robe der magie ist vorerst als unterstuetzende ruestung komplett
rausgeflogen. nur damit nachher keiner rumjammert, er haette sich die
muehe umsonst gemacht... ;)

-- 
patryn

-----------------------------------------------------------------------------



unterstuetzungen (Patryn, 28. Jan 2002, 13:01:40):
hi,

quer durchs beet sind noch viele fehlerhafte unterstuetzungen in diversen
ruestungen einem automatischem killbot zum opfer gefallen :)
sollte etwas verwunderliches dabei auffallen, sagt bescheid.

-- 
patryn

-----------------------------------------------------------------------------



learncache (Patryn, 29. Jan 2002, 00:56:47):
koennte sein dass ich heut nen recht schweren bug im learncache gefunden
habe, der das ueben von spells nahezu unmoeglich macht, welche hauptsaechlich
den raum als ziel haben, zb erdbeben.
test it and report :)

-- 
patryn

-----------------------------------------------------------------------------



Re: learncache (Obermotz, 30. Jan 2002, 15:21:21):
~#! rn=Patryn rt=1012262207 rg=gilden.zauberer
~#! tid=1012262207
Also eins verwundert mich:

Patryn hat nun mehrer Aenderung durchgefuehrt und kein Zauberer hat sich
beschwert? Das kann dich nicht sein!

Also muss ich wohl anfangen zu jammern. Ich will viel mehr bessere Unter-
stutzungen! Und ausserdem will ich Designer-Kompos! Und die Welt ist
sowieso zu boese. Und vorallem...

OM, heute nicht ganz ernst

-----------------------------------------------------------------------------



Re: Re: learncache (Cadrach, 30. Jan 2002, 17:58:24):
~#! rn=Obermotz rt=1012400481 rg=gilden.zauberer
~#! tid=1012262207
Woran erkennt man, das dieser Artikel von einem zaubi kam?
Er muss dazu schreiben, wenn er meint mal absichtlich komisch zu sein...

Cadrach, sich koestlich amuesierend.

-----------------------------------------------------------------------------



Re^3: learncache (Cuchullin, 30. Jan 2002, 17:59:44):
~#! rn=Cadrach rt=1012409904 rg=gilden.zauberer
~#! tid=1012262207
Du warst nie echter Zauberer, Cadrach. Du warst eigentlich _immer_ komisch.

:)

-----------------------------------------------------------------------------



amulette und huete ;) (Patryn, 11. Feb 2002, 23:56:00):
hi, heute ist aus den amuletten komplett die hellsichts-zweig unterstuetzung
rausgeflogen. das kommt nun in huete/helme rein.
damit sind nun manche amulette etwas duenn mit unterstuetzungen.
wem besonderes dazu auffaellt oder sich erweiterungen wuenscht, der sage
bescheid, aber bitte mit gesundem menschenverstand.
wir brauchen keine items, die vielfalt zerstoeren indem alles max ist.

-- 
patryn

-----------------------------------------------------------------------------



Re: bezaubere,feuerwalze,daemonenfratze u.s.w. (Nizzl, 27. Feb 2002, 20:38:15):
~#! rn=Patryn rt=1014832951 rg=gilden.zauberer
~#! tid=1014832951
d.h.?

-----------------------------------------------------------------------------



Re: Re: bezaubere,feuerwalze,daemonenfratze u.s.w. (Grimmborn, 27. Feb 2002, 23:00:03):
~#! rn=Nizzl rt=1014838695 rg=gilden.zauberer
~#! tid=1014832951
Das heisst dass wieder jemand das Magiergefasel aus Spielerrubriken nicht
raushalten kann.

GdA

-----------------------------------------------------------------------------



Re^3: bezaubere,feuerwalze,daemonenfratze u.s.w. (Patryn, 27. Feb 2002, 23:05:56):
~#! rn=Grimmborn rt=1014847203 rg=gilden.zauberer
~#! tid=1014832951
da sich schon wieder das dumme geplapper haeuft, nun also wieder am brett
nachschaun, wenn irgendwas nicht so funzt wie gewohnt.
und es gilt der uebliche punkt: wer es nicht kapiert was ich da schreibe,
fuer den ist es offensichtlich uninteressant und er brauch auch nicht
darueber zu lamentieren.

-- 
patryn

-----------------------------------------------------------------------------



Re^4: bezaubere,feuerwalze,daemonenfratze u.s.w. (Nicolai, 28. Feb 2002, 01:33:22):
~#! rn=Patryn rt=1014847556 rg=gilden.zauberer
~#! tid=1014832951
...und wer es nicht kapiert und es wagt nachzufragen
kommt auf die ignore-liste. Ein Hoch auf die Informationspolitik.

-----------------------------------------------------------------------------



Re^5: bezaubere,feuerwalze,daemonenfratze u.s.w. (Patryn, 28. Feb 2002, 01:34:41):
~#! rn=Nicolai rt=1014856402 rg=gilden.zauberer
~#! tid=1014832951
falsch, da gehoert schon noch eine portion rumheulen, schraeg anquatschen
und herumnerven dazu. also nix was ich mir in meiner freizeit geben muss.

-- 
patryn

-----------------------------------------------------------------------------



Re^6: bezaubere,feuerwalze,daemonenfratze u.s.w. (Pitfall, 28. Feb 2002, 01:39:37):
~#! rn=Patryn rt=1014856481 rg=gilden.zauberer
~#! tid=1014832951
cih sag jetzt lieber nicht: heul doch

-----------------------------------------------------------------------------



Re^7: bezaubere,feuerwalze,daemonenfratze u.s.w. (Patryn, 28. Feb 2002, 01:41:05):
~#! rn=Pitfall rt=1014856777 rg=gilden.zauberer
~#! tid=1014832951
ja, auch du bist drin...also sehe ich hier nur einen heulen :)

-- 
patryn

-----------------------------------------------------------------------------



Re^8: bezaubere,feuerwalze,daemonenfratze u.s.w. (Pitfall, 28. Feb 2002, 01:44:23):
~#! rn=Patryn rt=1014856865 rg=gilden.zauberer
~#! tid=1014832951
xxx teilt Dir mit: nimmer antworten, das schaukelt sich nur hoch, er is 
]xxx teilt Dir mit: grad tierisch angefickt und reagiert noch weniger
]xxx teilt Dir mit: normal wie sonst

ohne worte :o)

-----------------------------------------------------------------------------



Re^9: bezaubere,feuerwalze,daemonenfratze u.s.w. (Patryn, 28. Feb 2002, 01:46:07):
~#! rn=Pitfall rt=1014857063 rg=gilden.zauberer
~#! tid=1014832951
na ja, das xxx konnteste auch weglassen, ich kenn doch die kinder aus der
trves-fraktion.

-- 
patryn

-----------------------------------------------------------------------------



Re^10: bezaubere,feuerwalze,daemonenfratze u.s.w. (Tektuko, 28. Feb 2002, 17:01:42):
~#! rn=Patryn rt=1014857167 rg=gilden.zauberer
~#! tid=1014832951
Und wenn das naechste mal was geaendert wird, wird wieder gejammert warums
nich in der Zeitung stand.. :)

-----------------------------------------------------------------------------



Re^11: bezaubere,feuerwalze,daemonenfratze u.s.w. (Bambi, 28. Feb 2002, 17:37:31):
~#! rn=Tektuko rt=1014912102 rg=gilden.zauberer
~#! tid=1014832951
Stimmt.
Schreibt man was in der MPA, dann meckern Leute rum. ("Ich schreib demnaechst
auch, wenn ich aufs Klo geh.")
Schreibt man was nicht, dass motzen die Leute auch. ("Das ist also nur fuer
Insider, ja?")
Schreibt man was, das fuer Insider interessant ist ("Stichwort xxy: Das
funktioniert jetzt nimmer."), dann regen sich die Leute auf, die keine Insider
sind.
Schreibt man was fuer Insider so, dass es auch Leute verstehen, die z.B. ein
entsprechendes Objekt noch nie gesehen haben, dann ists ne KL.

Wenn mir noch was zum blubbern und wichtigtun einfaellt, dann lass ichs euch
wissen. ;)

-----------------------------------------------------------------------------



Re^12: bezaubere,feuerwalze,daemonenfratze u.s.w. (Pitfall, 28. Feb 2002, 17:50:35):
~#! rn=Bambi rt=1014914251 rg=gilden.zauberer
~#! tid=1014832951
blubber lieber allein auf klo

-----------------------------------------------------------------------------



Re^12: bezaubere,feuerwalze,daemonenfratze u.s.w. (Tektuko, 28. Feb 2002, 19:10:00):
~#! rn=Bambi rt=1014914251 rg=gilden.zauberer
~#! tid=1014832951
Zum Glueck sind wir hier in der richtigen Rubrik fuers jammern :)

-----------------------------------------------------------------------------



Re^12: bezaubere,feuerwalze,daemonenfratze u.s.w. (Mupfel, 28. Feb 2002, 20:17:09):
~#! rn=Bambi rt=1014914251 rg=gilden.zauberer
~#! tid=1014832951
Ist halt genau wie in rl. Such Dir die Variante aus mit der Du am besten leben
kannst, und den rest ignorierste.

-mupfel-
PS So machen das eh alle ;)

-----------------------------------------------------------------------------



Re^10: bezaubere,feuerwalze,daemonenfratze u.s.w. (Sky, 28. Feb 2002, 21:24:11):
~#! rn=Patryn rt=1014857167 rg=gilden.zauberer
~#! tid=1014832951


 Hi,

 voreneweg: Patryn, Du gehoerst meiner Meinung nach zu denen 
 die ihrem Job hier sehr gut erledigen und vor allem auch 
 sehr gewissenhaft nachgehen.
 Auch Deine MPA-Artikel sind (im Vergleich zu manch andren) 
 sachlich korrekt und auch in wohlgewaehlter Form und 
 Ausdrucksweise gehalten.

 Jedoch faellt auf, dass Deine Artikel oft so formuliert sind, 
 dass sie nicht jeder, den es interessiert und angeht, verstehen 
 kann.

 Wort wie: Spellbook, defend/hit-function, guard_check etc. sind
 da keine Seltenheit.

 Haette es im aktuellen Fall nicht gereicht zu schreiben:
 "Die Sprueche Feuerwalze, Bezaubere und Daemonenfratze (lol)
 wurde so und so geaendert, weil meine verehrten Kollegen leider
 unfaehig sind/waren ihre NPCs entsprechend anzupassen. Tut mit
 leid fuer euch."

 Klar, laesst sich mit einem "heul doch" oder "bloede Jammer-
 lappen" jede Art evtl.er Kritik von vorneherein wegreden.
 
 Ich kenne einige die bisher weder den Artikel noch die Aenderung
 richtig nachvollziehen konnten. Und ein "wers nicht versteht, den
 interssiert es auch nicht" halte ich fuer ziemlich unfair und 
 unpassend fuer jemand, der "Gilenmagier" sein will, bzw. ist.
 
 Entweder kannst, oder willst Du nicht zwischen "Insider" und 
 "Normalspieler" unterscheiden. Ich frage mich, was schlimmer ist.

 mfg *Sky*
 
 P.S.: Den Anfang des Artikels darfst Du Dir ausschneiden und
       uebers Bett haengen :)

-----------------------------------------------------------------------------



Re^11: bezaubere,feuerwalze,daemonenfratze u.s.w. (Patryn,  1. Mar 2002, 07:58:32):
~#! rn=Sky rt=1014927851 rg=gilden.zauberer
~#! tid=1014832951
jeder, der diese spells nutzt wird den unterschied automatisch merken und
mich nach spaetestens 10 minuten frust fragen was denn los ist.
es liegt in der natur der magisterspells, dass es insider-sachen sind.
es liegt in der natur von guard, dass es schwer allein mit spielerbegriffen
zu erklaeren ist, was das bedeutet.
und ja, "normalspieler"...du meinst also damit wohl die weniger kranken
fulltime-player, die haben fuer diese aenderung in der tat keine verwendung,
das kann man auch nicht wegreden mit der political correctness brille.

-- 
patryn

-----------------------------------------------------------------------------



Re^11: bezaubere,feuerwalze,daemonenfratze u.s.w. (Boing,  1. Mar 2002, 07:59:42):
~#! rn=Sky rt=1014927851 rg=gilden.zauberer
~#! tid=1014832951
> "Die Sprueche Feuerwalze, Bezaubere und Daemonenfratze (lol)
> wurde so und so geaendert, weil meine verehrten Kollegen leider
> unfaehig sind/waren ihre NPCs entsprechend anzupassen. Tut mit
> leid fuer euch."

Das waere aber nicht richtig gewesen. Die genannten Sprueche wurden
geaendert, weil sie urspruenglich nur unter der Bedingung genehmigt
wurden, dass man das Weglocken verhindern kann (das gilt fuer
Bezaubere, bei den anderen Spruechen kam das meines Wissens erst
spaeter dazu). Und wenn Monster, die man eigentlich nicht weglocken
koennen sollte, dann ploetzlich woanders stehen und das, was sie
bewachen, frei zugaenglich ist (Stichwort Water Luh), dann ist das
einfach nicht so prickelnd.

  Boing

-----------------------------------------------------------------------------



Re^12: bezaubere,feuerwalze,daemonenfratze u.s.w. (Patryn,  1. Mar 2002, 08:02:33):
~#! rn=Boing rt=1014965982 rg=gilden.zauberer
~#! tid=1014832951
wobei es sehr einfach gewesen waere, so wie in der vergangenheit geschehen,
auf diese einzelfaelle einzugehen. es gibt schon laenger eine blacklist,
manchmal wurden auch einfach die unique-npcs einfach so geproggt wie man sie
eigentlich halt proggt, als blueprint...schon wegen speichergruenden und
wartbarkeit (sorry fuer magierblabla, will nich splitten)
insgesamt gesehen waren es immer nur einzelfaelle und man haette gut drauf
reagieren koennen so wie bisher. nun ists auch egal...viel arbeit ist so
oder so auf der halde.

-- 
patryn

-----------------------------------------------------------------------------



Re^13: bezaubere,feuerwalze,daemonenfratze u.s.w. (Grimmborn,  1. Mar 2002, 09:04:22):
~#! rn=Patryn rt=1014966153 rg=gilden.zauberer
~#! tid=1014832951
Natuerlich weiss ich nicht worum es geht, aber dass Du mit der Haltung "es
waere doch alles so einfach wenn sich alle nach mir richten wuerden" nicht
weit kommst ist nun wirklich nicht neu.

GdA

-----------------------------------------------------------------------------



Re^12: bezaubere,feuerwalze,daemonenfratze u.s.w. (Vardion,  1. Mar 2002, 10:36:15):
~#! rn=Boing rt=1014965982 rg=gilden.zauberer
~#! tid=1014832951
Moin.

Das Problem an der Guard-Prop ist doch eher, dass sie vom Standard-NPC per
Default auf 100% (nicht bewegbar) gesetzt wird. Somit duerften 99.9% aller
NPCs im MorgenGrauen diese Prop auf 100 haben, weil

a) Magier sie evtl. ueberhaupt nicht kennen
b) sie bei einfachen 10-Zeilen-NPCs schlichtweg nicht setzen

Damit kann ein Spruch, der NPCs halbwegs sinnvoll bewegen will, diese Prop
eigentlich nur ignorieren und die Bewegbarkeit an anderen Kriterien
entscheiden.
Sicher kann man damit auch Unfug machen (siehe aktueller Fall), aber im
grossen und ganzen finde ich solche Moeglichkeiten, die ueber stupides
"hau-drauf" und tottanken von NPCs hinausgehen, eine Bereicherung fuer das
Mud.
Ist es denn wirklich unbedingt notwendig, dass ein Gardewaechter immer an
seinem Platz steht? Oder ein Glitzerdrache? Wenn sich die meissten NPCs hier
schon nicht von sich aus bewegen, koennte so wenigstens etwas Abwechslung
reinkommen.

Vardion

-----------------------------------------------------------------------------



Re^13: bezaubere,feuerwalze,daemonenfratze u.s.w. (Grimmborn,  1. Mar 2002, 10:39:02):
~#! rn=Vardion rt=1014975375 rg=gilden.zauberer
~#! tid=1014832951
Was effektiv gemacht wird ist, dass ein Magier im Konzept (wie bloed auch
immer es ist, aber als die NPC programmiert wurden waren sie nicht bewegbar)
von anderen Magiern rumpfuscht. Das findest Du generell in Ordnung?

GdA

-----------------------------------------------------------------------------



Re^13: bezaubere,feuerwalze,daemonenfratze u.s.w. (Ark,  1. Mar 2002, 10:44:57):
~#! rn=Vardion rt=1014975375 rg=gilden.zauberer
~#! tid=1014832951
Dann sehe ich das trotzdem eher als Gesellenstueck. Der potentielle Unfug
wiegt schwerer als der zusaetzliche Spass, das leuchtet sogar mir ein ;^


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^14: bezaubere,feuerwalze,daemonenfratze u.s.w. (Patryn,  1. Mar 2002, 11:05:55):
~#! rn=Ark rt=1014975897 rg=gilden.zauberer
~#! tid=1014832951
der potentielle unfug war ja nun nicht grad sehr verbreitet, abundzu mal
nen lacher und nen kleiner fix, und gut wars.
rein balancetechnisch war es sicher auch nicht vorgesehen, dass nach
anschluss der trves die magischen waffen in allen spielarten explosionsartig
ausuferten...und? passiert da was trotz jahrelangem argumentieren? noe.
da fand ich das aktuelle thema ehrlich gesagt weniger dringend.

-- 
patryn

-----------------------------------------------------------------------------



Re^15: bezaubere,feuerwalze,daemonenfratze u.s.w. (Cadrach,  1. Mar 2002, 11:30:35):
~#! rn=Patryn rt=1014977155 rg=gilden.zauberer
~#! tid=1014832951
Zumal man bei 99,9% aller NPCs die Property gar nicht setzen muss (weil die
nicht an diesem Ort stehen bleiben muessen). Bei den zwei Dutzend NPCs wo es
wirklich wichtig ist, koennten die RMs im Prinzip einfach Guard richtig setzen
oder einen anderen AddItem Parameter wie MOVE_HOME benutzen.
Allerdings haette man dies bei Einfuehrung des Spruches vor Jahren bereits
machen sollen.

-----------------------------------------------------------------------------



Re^13: bezaubere,feuerwalze,daemonenfratze u.s.w. (Boing,  1. Mar 2002, 11:36:55):
~#! rn=Vardion rt=1014975375 rg=gilden.zauberer
~#! tid=1014832951
Ich verstehe Deine Argumentation und kann sie sogar nachvollziehen.
Nur muss man ein bisschen weiterdenken. Es stoert mich nicht, wenn der
Glitzermock von seinem Platz wegbewegt wird. Aber es stoert mich, wenn
er ploetzlich auf der Hochebene steht. Denn er ist durchaus in der
Lage einen nichtsahnenden Anfaenger, der ihn als weiteres Aufwaerm-
monster im Stile von Ameisen und sonstigem Kleinzeug sieht, in einem
Schlag wegzuputzen. Das faende ich als Anfaenger nicht lustig.
Ich hab schon gestern mit Patryn ueber das Thema geredet, wenn man
das Weglocken raeumlich begrenzen koennte, dann waeren einem als 
Magier viel mehr Moeglichkeiten gegeben, das zuzulassen ohne groessere
Schaeden befuerchten zu muessen. Ich denke Patryn fand diese Idee auch 
nicht schlecht, es braucht halt wieder Zeit so etwas zu implementieren.

  Boing

-----------------------------------------------------------------------------



Re^14: bezaubere,feuerwalze,daemonenfratze u.s.w. (Gor,  1. Mar 2002, 12:21:38):
~#! rn=Grimmborn rt=1014975542 rg=gilden.zauberer
~#! tid=1014832951
Wenn die Magier das wissen, dann finde ich das in Ordnung Grimmborn. Ich finde
solche Sachen sollten irgendwo zu lesen sein. Andererseits finde ich dieses
'Gimmick' weniger sinnvoll. Was bringts es, wenn der NPC auf einmal einen Raum
weitersteht? Im besten Fall bringt es, dass man einen Guarded_Exit unbehelligt
passieren kann. Das man ab und an Spass hat, den Sandtiger herumzuschubsen,
koennte man ja noch verstehen. Aber das fuer die 5 Minuten Spass saemtliche
Magier ihre NPCs aendern muessten finde ich nicht vertretbar.

Gor

-----------------------------------------------------------------------------



Re^16: bezaubere,feuerwalze,daemonenfratze u.s.w. (Gor,  1. Mar 2002, 12:24:32):
~#! rn=Cadrach rt=1014978635 rg=gilden.zauberer
~#! tid=1014832951
Hab ich was verpasst? Haben wir wieder ne Diktatur, wo einem vorgeschrieben
wird was man zu machen hat? Es ist sehr fein von dir Cadrach, dass du
entscheiden kannst, welche NPCs das haben sollen und welche nicht. Wenn ich
der Meinung bin, dass der NPC hier stehen bleibt, aus welchen Gruenden auch
immer, dann bleibt er da stehen und wenn ich im STD_NPC das move
ueberschreibe.

-----------------------------------------------------------------------------



Re^15: bezaubere,feuerwalze,daemonenfratze u.s.w. (Patryn,  1. Mar 2002, 12:24:50):
~#! rn=Gor rt=1014981698 rg=gilden.zauberer
~#! tid=1014832951
uebertreibt doch nich immer so masslos, man konnte bei weitem nicht alle
npcs rumschleppen...da wurde schon ne menge gefiltert. es waren immer nur
einzelfaelle bei denen oftmals unverhaeltnismaessig herumkrakelt wurde,
aber hin und wieder hat man es auch im einvernehmen mit dem freundlichen
mitarbeiter geloest, ohne mpa und wichtigtuerei.

-- 
patryn

-----------------------------------------------------------------------------



Re^16: bezaubere,feuerwalze,daemonenfratze u.s.w. (Gnome,  1. Mar 2002, 18:08:51):
~#! rn=Patryn rt=1014981890 rg=gilden.zauberer
~#! tid=1014832951
@patryn: da hast du recht, in dem fall haetten die einzelloesungen so lange
         gereicht, bis man eine elegante und vor allen dingen unter-
         brechungsfreie loesung gefunden haette. momentan sind nicht nur
         zwei NPCs unkillbar, sondern auch eine zquest unspielbar dadurch.

@boing: was ist daran so schlimm, wenn mal der mock auf der HE steht?
        oder die eisviper am sandtiger? anfaenger sind lernfaehig >:)
        das mit water luh ist verstaendlich, aber da ist doch die
        einzelloesung vorzuziehen, oder? sonst sind manche sprueche
        einfach sinnlos.
        die einzelnen gilden haben ihre sprueche doch, um sie anzuwenden
        und nicht, um dauernd verboten zu werden, oder?

@grimmi: halt doch endlich mal die luft an.

gnOme

-----------------------------------------------------------------------------



Re^16: bezaubere,feuerwalze,daemonenfratze u.s.w. (Ark,  4. Mar 2002, 11:33:55):
~#! rn=Cadrach rt=1014978635 rg=gilden.zauberer
~#! tid=1014832951
Zwei Dutzend? Woher diese Schaetzung? Mir fallen spontan 6 NPC bei mir ein,
bei denen ich schonwas dagegen haette, wenn sie wegkoennten, die Balance wohl
auch, da ich sie als Argument fuer die Freigabe von Saechelchen angefuehrt
habe. Und ich habe sicher nicht sehr viel NPC geschrieben. Zwei Dutzend wuerde
ich also nicht unterschreiben.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^17: bezaubere,feuerwalze,daemonenfratze u.s.w. (Ark,  4. Mar 2002, 11:38:49):
~#! rn=Gnome rt=1015002531 rg=gilden.zauberer
~#! tid=1014832951
Also mit einer raeumlich begrenzten Loesung koennte ich mich auch anfreunden,
auch wenn es Nacharbeit bedeutet bei einigen NPC.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^18: bezaubere,feuerwalze,daemonenfratze u.s.w. (Birdy,  4. Mar 2002, 11:39:43):
~#! rn=Ark rt=1015238329 rg=gilden.zauberer
~#! tid=1014832951
laber nich, machs! *g*

-----------------------------------------------------------------------------



Re^19: bezaubere,feuerwalze,daemonenfratze u.s.w. (Grimmborn,  4. Mar 2002, 11:41:26):
~#! rn=Birdy rt=1015238383 rg=gilden.zauberer
~#! tid=1014832951
Meinst Du nicht das sollte derjenige machen, der die NPCs anderer Leute
manipulieren will?

GdA

-----------------------------------------------------------------------------



Re^20: bezaubere,feuerwalze,daemonenfratze u.s.w. (Birdy,  4. Mar 2002, 11:42:00):
~#! rn=Grimmborn rt=1015238486 rg=gilden.zauberer
~#! tid=1014832951
hab ich schreibrechte bei ark?

-----------------------------------------------------------------------------



Re^21: bezaubere,feuerwalze,daemonenfratze u.s.w. (Boing,  4. Mar 2002, 11:43:59):
~#! rn=Birdy rt=1015238520 rg=gilden.zauberer
~#! tid=1014832951
Nein, die wuerden Dir auch nichts bringen in diesem Fall.
  Boing

-----------------------------------------------------------------------------



Re^19: bezaubere,feuerwalze,daemonenfratze u.s.w. (Ark,  4. Mar 2002, 11:49:03):
~#! rn=Birdy rt=1015238383 rg=gilden.zauberer
~#! tid=1014832951
Die raeumlich begrenzte Loesung? Noe, muss jemand anderer festlegen, was das
bedeutet :-) Entweder uebergeordnete Verzeichnisse, oder explizite Pfadnamen
der Raeume, oder beides ... und Drooche, und Musigg, un Popcorn.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^17: bezaubere,feuerwalze,daemonenfratze u.s.w. (Patryn,  4. Mar 2002, 12:31:47):
~#! rn=Ark rt=1015238035 rg=gilden.zauberer
~#! tid=1014832951
kkwer
wobei wiederum vergessen wird, dass schon eine ganze menge NPCs automatisch
rausgefilter wurden die wahrscheinlich nich wegsollen, zb saemtliche
blueprints, oder sowas wie refresh-nones, oder refresh-destructs ohne
move-home u.s.w., und auch zu hohe level u.s.w.

also war das dutzend vieleicht doch keine soo falsche schaetzung

-- 
patryn

-----------------------------------------------------------------------------



Homepage (Elizabeth, 25. Mar 2002, 21:15:03):
Ich wollte nur mal verlauten lassen, das ich die Gildenhomepage jetzt
uebernommen habe von apophis... wenn jetzt kommt 'die is ja gar kein zaubi'
dann siehe -> skyfire .. :) also.. anfragen sonstiges ab jetzt an mich..wird
sicher auch ein paar kleine aenderungen und zusaetze geben :)
bye elli*

-----------------------------------------------------------------------------



Re: Homepage (Birdy, 25. Mar 2002, 22:26:29):
~#! rn=Elizabeth rt=1017087303 rg=gilden.zauberer
~#! tid=1017087303
Dann viel Spass dabei und mach deinen Zaubi zum Erstie, sonst gibts
Schwierigkeiten! ;)
Vielen Dank auch nochmal an Apophis, der sehr viel Arbeit in die Aenderungen
der Homepage gesteckt hatte, als es hier bei uns drunter und drueber ging. Er
hat bestimmt nicht weniger geleistet, als die Gildenmagier bei den diversen
Umstellungen. Vielen Dank! :)

Birdy

-----------------------------------------------------------------------------



Re: Re: Homepage (Tsunami, 25. Mar 2002, 22:48:17):
~#! rn=Birdy rt=1017091589 rg=gilden.zauberer
~#! tid=1017087303
ich finde es sehr passend dass ein Kaempfer die Zaubererhomepage nun
etwas verunstaltet :)))

Tsunami, freut sich auf Blut und Gewalt und Gemetzel :))

-----------------------------------------------------------------------------



Re^3: Homepage (Guard, 26. Mar 2002, 01:12:53):
~#! rn=Tsunami rt=1017092897 rg=gilden.zauberer
~#! tid=1017087303
tja, ueberhaupt scheinen Gildenfremdlinge den objektiveren Blick auf die
Interna zu haben und dadurch einfach besser dafuer qualifiziert sind, anderen
den Schhwachsinn einer Gilde begreiflich zu machen :-)

Guard

PS: will nich jemand die Kaempferseiten weiterbetreuen? :-) 

-----------------------------------------------------------------------------



Re^4: Homepage (Pitfall, 26. Mar 2002, 08:12:44):
~#! rn=Guard rt=1017101573 rg=gilden.zauberer
~#! tid=1017087303
noe aber du koenntest die mal wieder updaten :o)

-----------------------------------------------------------------------------



ZaubererSeiten (Skyfire,  4. Mai 2002, 22:51:10):
Also, bevor meine Mailbox noch winselt vor Gnade:
Das Problem ist folgendes Apophis hat die Zugangsdaten. D.h er hat das
Passwort fuer den Account der Seite. Das wiederum heisst, ich kann keine
verbindung herstellen zu dem server wo die seite gehostet wird. das einzige
was moege ist im moment ich direkt drauf zuzugreifen, bis ich apophis erreiche
und er den pfad herstellt. ansonsten kann ich da auch nicht viel machen als
eine alternative seite einzurichten mit dem inhalt dann aber im moment nicht
als die standart url. 
Skyfire (schreibt sich ein mailscript, dass jeden tag an apophis mailt)

-----------------------------------------------------------------------------



Re: ZaubererSeiten (Vardion,  5. Mai 2002, 23:03:11):
~#! rn=Skyfire rt=1020545470 rg=gilden.zauberer
~#! tid=1020545470
Der jetzige Server ist doch eh arschlahm. Vielleicht koennte man da gleich nen
neuen suchen...

Vardion

-----------------------------------------------------------------------------



Zauberkisten (Vanion, 10. Mai 2002, 12:42:35):

Hi, ich wurde gebeten, hier eine Bekanntmachung anzuschlagen. Dies wird
hiermit getan.

V*

---

Sehr geehrte Kundschaft,

Bei der Produktion einiger Moebelstuecke der Linie "Zaubererzubehoer" ist uns
ein unangenehmer Fehler unterlaufen. Um Ihnen moeglich guenstig die
beliebten Komponentenkisten anbieten zu koennen, hatten wir einen
Werkstudenten
der Akademie zu Taramis beauftragt, die Versiegelungszauber zu sprechen.

Leider hat der Werkstudent wohl aber ein, zwei Zutaten verwechselt, so
dass viele Ihrer wertvollen Komponenten nicht mehr in die Truhe passten.

Wir muessen fuer diesen peinlichen Umstand vielmals um Entschuldigung
bitten.

Die Zauber der derzeit noch in unseren Lagern befindlichen Kisten
wurden sorgfaeltigst auf diese Schwaeche geprueft, so dass wir Ihnen
wieder Moebelstuecke in gewohnter Qualitaet anbieten koennen.

Mit freundlichen Gruessen,
Das Seher-Einrichtungshaus Ihres Vertrauens

-----------------------------------------------------------------------------



Re: Zauberkisten (Ahab, 10. Mai 2002, 12:44:25):
~#! rn=Vanion rt=1021027355 rg=gilden.zauberer
~#! tid=1021027355
Wer wohl dieser unfaehige Werkstudent war? *g*

Ahoi,
Ahab.

-----------------------------------------------------------------------------



Re: Zauberkisten (Patryn, 10. Mai 2002, 15:49:51):
~#! rn=Vanion rt=1021027355 rg=gilden.zauberer
~#! tid=1021027355
muss ich jetzt beunruhigt sein,
wenn ich noch nie was davon gehoert habe
und keinen blassen schimmer habe, was du hier
erzaehlst? :)

-- 
patryn

-----------------------------------------------------------------------------



Magister (Liara, 25. Jul 2002, 16:43:18):
Da der Vorschlag, das Erreichen besonderer Gildenraenge etc. in der MPA
bekanntzugeben, noch nicht verwirklicht wurde, aber doch eigentlich ein
grosser Konsens dafuer existiert, schreibe ich unseren neusten Magister nun
mal per Hand hier rein:

[Zauberer:Llystrathe] Pallando zeigte das noetige Wissen und Koennen um von
[Zauberer:Llystrathe] nun an den Titel 'der Magister' tragen zu duerfen.
[Zauberer:Llystrathe] <14:21:51>

Gratuliere!

ZZL, wuerde sowas gerne mitbekommen, auch wenn sie offline ist ...

-----------------------------------------------------------------------------



Re: Magister (Cuchullin, 25. Jul 2002, 16:44:20):
~#! rn=Liara rt=1027608198 rg=gilden.zauberer
~#! tid=1027608198
Herrscht da ein Konsens? Meines Wissens hat Kruuuuuooolq schonmal in der
Zeitung gescrollt - und es hat irgendwie KEINEM gefallen...


-----------------------------------------------------------------------------



Re: Re: Magister (Isi, 25. Jul 2002, 16:50:52):
~#! rn=Cuchullin rt=1027608260 rg=gilden.zauberer
~#! tid=1027608198
Also so oft gibts ja nun auch keine Magister, dass das
gross scrollen wuerde...
isi (moussewerfend)

-----------------------------------------------------------------------------



Re^3: Magister (Varlarion, 25. Jul 2002, 16:52:26):
~#! rn=Isi rt=1027608652 rg=gilden.zauberer
~#! tid=1027608198
Richtig, Magister wird man einmal, der Erzmeister der Chaosgilde (die IMHO von
Kruuolq verkuendet wurden) hingegen wechselt im Abstand von 3-14 Tagen. 

Varl*, i.A. der Familienzauberine

-----------------------------------------------------------------------------



Re^3: Magister (Cuchullin, 25. Jul 2002, 17:05:00):
~#! rn=Isi rt=1027608652 rg=gilden.zauberer
~#! tid=1027608198
Da ich fuer mein dreistes Reply ziemlich dumm angemacht worden bin (rein
subjektiv natuerlich), sehe ich mich gezwungen, nachzutreten. Erstens 
stand da was von "grossem Konsens". Den es nicht gibt, sobald auch nur 
einer (ich?) dagegen ist. 

Eine Minderheit/Mehrheit der Zauberer mag die Magistererlangung in der MPA
stehen haben. Stellen wir uns vor, dies geschieht. Ok. Dann wollen die 
Kleriker ihre Priesterweihen drin stehen haben und die Chaoten die Erlangung
des 11. Gildengrades. Halt!, denkt sich dann M, sinnvoller ist es, wenn der
Erzmeister in der Zeitung steht (was er schon tat?), weil deeeen muesste 
man ja durch Raten herausbekommen - oder ist Kruououlq inzwischen bereit,
auf solche Fragen zu antworten? Ein anderer M befindet dann fuer schlau,
die Hohepriester in die MPA zu setzen, weil man naemlich verpassen koennte,
wenn Spieler X mal Hohepriester wurde - und den Posten sofort wieder verlor.
... und als Spieler haben wir doch ohnehin gelernt: Wir kommen auf die 
richtig kranken Gedanken, die an Qualitaet die Magierwelt nicht zu toppen
weiss. Aber EFFEKTIV geht es nur als Magier. Und das ist der Punkt an dem
ich glaube, dass man solche Dinge Gildenintern regeln koennte anstatt die
MPA umzuschreiben, damit jeder Idiot (Schleicher ist doch inzwischen Chef
der Karateka, oder? SCNR) Artikel von NPCs schreiben lassen darf.

Mir persoenlich wuerde ein "teile llystrathe mit neuigkeiten" reichen. 
Patryn ist sicher auch noch in der Lage, optionale Argumente zu Themen
und Zeitraum zu verarbeiten, sehe ich aber nur als zweitrangig an. 

Die Notwendigkeit fuer das Hinzuziehen der MPA sehe ich wirklich nur bei
Zwergen, die man erst mit Hammer und Meissel umprogrammieren muss, damit
sie 'nen neuen Befehl verstehen...

Cuch

-----------------------------------------------------------------------------



Re^4: Magister (Liara, 25. Jul 2002, 17:15:57):
~#! rn=Cuchullin rt=1027609500 rg=gilden.zauberer
~#! tid=1027608198
Ich gehe mal auf den sachlichen Teil deines Artikels ein.
Ich habe ueberhaupt nichts dagegen, auch ueber andere Gilden informiert zu
werden. Niemand hat gesagt, dass eine solche Sache unbedingt in der jeweiligen
Gildenrubrik stehen muss. Moeglicherweise kann man dafuer eine neue Rubrik
schaffen. Oder man loest es gildenintern ohne MPA.
Jedenfalls finde ich es voellig OK, darueber mal nachzudenken.

ZZL

-----------------------------------------------------------------------------



Re^5: Magister (Pitfall, 25. Jul 2002, 17:25:35):
~#! rn=Liara rt=1027610157 rg=gilden.zauberer
~#! tid=1027608198
schreibts doch einfach ans zaubibrett

so long
*pit*

-----------------------------------------------------------------------------



Re^5: Magister (Cuchullin, 25. Jul 2002, 17:32:20):
~#! rn=Liara rt=1027610157 rg=gilden.zauberer
~#! tid=1027608198
Zwischen darueber nachdenken und von einem nicht vorhandenen Konsens zu
sprechen ist fuer mich als nicht-Zwerg ein signifikanter Unterschied. 

Ich habe die Meinung, dass ein vermehrtes Hinzuziehen der MPA fuer diese
und aehnliche Zwecke (btw. wer uebernimmt die mpa-Balance? Fuehlst Du 
Dich berufen? Ich nicht.) zu viele Pferdefuesse hat. Dafuer, dass ich im
Moment nicht glaube, vom Gegenteil ueberzeugt werden zu koennen, lasse 
ich mich nicht wehrlos anmachen.

Und ich habe rein GAR nichts dagegen, wenn Llys die News auch Nicht-
Zauberern erzaehlt. Sie kann da ja dann filtern: Wenn ein Magister nach
den neuesten Geschehnissen fragt, kann sie per default auch Zweigwechsel
erwaehnen. Finde ich stimmungsvoller, selbst auf die Gefahr hin, dass 
es bei den Chaoten nicht "teile kruuolq mit neuigkeiten" ist, sondern 
"teile wuquor mit hail chaos, wie gehts?", bei den Klerikern der Weg zu
Arkshat noch gemacht werden muss (seufz) ... 

Cuch

-----------------------------------------------------------------------------



Re^6: Magister (Liara, 25. Jul 2002, 17:34:36):
~#! rn=Cuchullin rt=1027611140 rg=gilden.zauberer
~#! tid=1027608198
Lies im Archiv nach, bevor du hier rumbloekst.

-----------------------------------------------------------------------------



Re^7: Magister (Montanus, 25. Jul 2002, 17:36:11):
~#! rn=Liara rt=1027611276 rg=gilden.zauberer
~#! tid=1027608198
Die mpa-Balance ist in den Haenden des zukuenftigen RMs Schattenwelt. Und der
raeumtschon auf, wenn er meint, dass Artikel in flaschen RUbriken stehen.
Lass dir also deswegen nicht noch mehr graue Haare wachsen. :-)

-----------------------------------------------------------------------------



Re: Re: Magister (Tilly, 25. Jul 2002, 17:47:57):
~#! rn=Cuchullin rt=1027608260 rg=gilden.zauberer
~#! tid=1027608198
Jepp, hat der Kruuolq tatsaechlich. Ist aber schon wirklich
laaaaaaaaaaaaaaaaaaaaanger her.

Und gefallen hats tatsaechlich den wenigsten >:)

 - Tilly -


-----------------------------------------------------------------------------



Re^3: Magister (Montanus, 25. Jul 2002, 17:50:52):
~#! rn=Tilly rt=1027612077 rg=gilden.zauberer
~#! tid=1027608198
Es gibt zwei Moeglichkeiten. Die wird euch Grimmborn sicher schon einmal
veraten haben, oder vor ihm Loco:

(1) wenn einen das, was in der MPA in einer Rubrik steht, nicht gefaellt, dann
kann man sie abbestellen, oder man kann einen Thread ignorieren. (siehe:
"hilfe mpa").
(2) wenn man meint, man muesse alles, was in der mpa steht, auch lesen, dann
sollte man nicht meckern, wenn mal was in der mpa steht, was einen nicht
interessiert. Zu Abhilfe siehe Punkt 1.

-----------------------------------------------------------------------------



Re^7: Magister (Cuchullin, 25. Jul 2002, 17:56:25):
~#! rn=Liara rt=1027611276 rg=gilden.zauberer
~#! tid=1027608198
Das Archiv von gilden.zauberer umfasst etwa 1 Megabyte. Du willst mich
doch nur fuer ne Weile ruhig halten, gib es zu. Das einzige, was ich beim
raschen Suchen nach Schluesselworten fand (in 'kampagne' steckt 'mpa' drin,
schon gewusst? ;)), war ein Artikel von Dir, ein "Pro" von Foobar und ein
"Contra" von Lug. Wenn ich da was uebersehen haben sollte - was ich fuer
moeglich halte - sag mir doch bitte Autor/Datum oder sowas.

Ansonsten berufe Dich in Deiner "Konsens"-Argumentation lieber auf Zruf.

Cuch


-----------------------------------------------------------------------------



Re: Magister (Ark, 25. Jul 2002, 18:27:32):
~#! rn=Liara rt=1027608198 rg=gilden.zauberer
~#! tid=1027608198
Hm, reicht es nicht aus, wenn sowas das Gildenoberhaupt bei der Frage nach dem
Aufsteigen miterzaehlt, z.B. die letzten 2,3, oder 4 Aufstiege? Ist am
einfachsten, ist eine Holinformation und stoert keinen, und befriedigt
beliebig genau den Informationsdurst Abwesender.
... und muesste von den Gildenmagiern umgesetzt werden ;)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Magister (Miril, 25. Jul 2002, 23:19:25):
~#! rn=Liara rt=1027608198 rg=gilden.zauberer
~#! tid=1027608198
Hm, so ganz nachvollziehen kann ich das Geschrei hier nicht. Ich uebergehe
auch regelmaessig irgendwelche Mensamenues, bei denen ich nicht mal weiss, an
welcher Uni sie eigentlich serviert werden ;-).
Ich faende es persoenlich durchaus nett, wenn mal etwas mehr MG-spezifisches
in
der MPA stehen wuerde. 32000 Rehe moegen ja fuer Insider ganz witzig sein,
scrollen aber vermutlich deutlich mehr, als Kruuolq, Llystrathe und Konsorten
es jemals schaffen koennten.
Miril

-----------------------------------------------------------------------------



Re: Re: Magister (Gnome, 25. Jul 2002, 23:41:53):
~#! rn=Miril rt=1027631965 rg=gilden.zauberer
~#! tid=1027608198
ganz meiner meinung, miril.
grade der, der 'megaschmarrn' abonniert hat und mitschreibt, hat was
dagegen, obwohl er doch den befehl 'unscubscribe' kennen sollte, somit
es fuer ihn also kein problem darstellen duerfte, eine (noch)
fiktive rubrik namens 'gilden.bekanntmachungen' zu ignorieren.
ist das nicht ironie? ( (c) 'teaching mrs. tingle' )

zugegeben: die wechselnden hohen gildenposten interessieren eher
weniger, doch ist es mitunter interessant, wer nun schon wieder
magister geworden ist oder wer sich jetzt als general sehen darf.

und ich glaube eher, dass liara von einem grossem konsens sprechen
darf, als du von gar keinem, anatol. zumindest nach den letzten 15
artikeln zu urteilen.

gnOme

-----------------------------------------------------------------------------



Re^3: Magister (Cuchullin, 26. Jul 2002, 05:04:32):
~#! rn=Gnome rt=1027633313 rg=gilden.zauberer
~#! tid=1027608198
Ob ich Beitraege zu lesen gewillt bin, die von Menschen geschrieben wurden
oder in zwei Jahren Logs von Ombatis in Schmarrn zu lesen habe, ist ein
qualitativer Unterschied, der sogar hinsichtlich "Megaschmarrn" bestechend
ist.

Definition "Konsens": Uebereinstimmung, Einigung in strittigen Fragen

Was nu? Ein bisschen schwanger? Liara kann, wenn sie will, von einer
"vorherrschenden Meinung" sprechen, wuerde ich ihr sogar glauben. Aber
nie von einer Schwangersch... einem Konsens.

Es besteht keine zwingende Notwendigkeit, NPCs in die MPA schreiben zu 
lassen; es gibt noch andere Moeglichkeiten. Die aber augenscheinlich
fuer das Zwergenvolk zu kompliziert waeren, mh? ;)

Ich vermische ungern Diskussion um das Thema mit Diskussion um irgendwelche
missglueckten Wortwahlen. Tut mir - aufrichtig - leid, dass es mir mal 
wieder passiert ist.

Cuch

-----------------------------------------------------------------------------



Re^4: Magister (Nonne, 26. Jul 2002, 08:05:43):
~#! rn=Cuchullin rt=1027652672 rg=gilden.zauberer
~#! tid=1027608198
Vielleicht haettest Du die Definition von 'Konsens' und die Abgrenzung zu
'vorherrschende Meinung' eher in die MPA schreiben sollen, dann waere der
Thread nur 3 Artikel lang geworden *g*

Nonne, sich ueber solche Streitereien an den Kopf patschend.

-----------------------------------------------------------------------------



Re^5: Magister (Panic, 26. Jul 2002, 09:23:47):
~#! rn=Nonne rt=1027663543 rg=gilden.zauberer
~#! tid=1027608198
Najo... wie waere es denn mit einer Rubrik gilden.stufen, wo sowas
reingepustet werden kann. Die kann ich dann uebergehen und gut is :)

-----------------------------------------------------------------------------



Re^4: Magister (Woody, 26. Jul 2002, 13:38:42):
~#! rn=Cuchullin rt=1027652672 rg=gilden.zauberer
~#! tid=1027608198
Die MPA war doch noch nie ein reines OOC-Medium, viel zu sehr werden
hier immer wieder Spielaspekte diskutiert, insoferne sehe ich da eher
weniger Probleme, wenn auch mal NPCs - wohlgemerkt in adaequatem Aus-
masse und moeglicherweise auch stimmungsvoll - etwas kund zu tun haben
und dies hier tun sollten.

Das Zwergenvolk ist nunmal relativ pragmatisch.


Woody.-


-----------------------------------------------------------------------------



Re^5: Magister (Godot, 26. Jul 2002, 14:08:33):
~#! rn=Woody rt=1027683522 rg=gilden.zauberer
~#! tid=1027608198
Genau. Find ich auch. Und wenn wir schon dabei sind,
kann nicht noch jemand mal einen NPC bauen,
der in megaschmarrn ein paar Artikel reinschreibt?
Manchmal droht der Thread ja doch zu erlahmen,
ausserdem koennte man so sicherstellen, dass nicht
andauernd irgendwelche Rehe verschenkt werden.
Und schliesslich und endlich kriegt man so die 100k
schneller voll. Insebesondere, wenn man mehrere NPCs
baut, die sich gegenseitig auf dem Kiecker haben :)

Hach... da waer was drin in der mpa ;)

Godot

-----------------------------------------------------------------------------



Re^4: Magister (Gnome, 26. Jul 2002, 15:25:20):
~#! rn=Cuchullin rt=1027652672 rg=gilden.zauberer
~#! tid=1027608198
du hast es erkannt.
es ist mir (und ich glaube nicht nur mir), etwas zu stressig, jedes
gildenoberhaupt persoenlich nach den spielern zu fragen, die nun die
letzte gildenhuerde erklommen haben.
ein 'nn' ist da etwas fingerfreundlicher.

dass die gildenchefs _ausserdem_ noch neuigkeiten an die jeweiligen
mitglieder per tm oder brett verteilen, sollte dem eigentlich nicht
im wege stehen.

gnOme

-----------------------------------------------------------------------------



Re^5: Magister (Ark, 26. Jul 2002, 16:11:55):
~#! rn=Gnome rt=1027689920 rg=gilden.zauberer
~#! tid=1027608198
Achso, es geht um Faulheit und Bequemlichkeit. Nun, dann weiss ich, warum ich
sicher nie eine Gilde machen werde. Soviel auch zum Thema Stimmung und so
weiter ;)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^6: Magister (Nonne, 26. Jul 2002, 16:13:33):
~#! rn=Ark rt=1027692715 rg=gilden.zauberer
~#! tid=1027608198
Stimmung? Hier? Hey, im MG spielen ist eine Wissenschaft und hat nichts mit
Rollenspiel zu tun!

Nonne.

-----------------------------------------------------------------------------



Re^7: Magister (Ark, 26. Jul 2002, 16:15:08):
~#! rn=Nonne rt=1027692813 rg=gilden.zauberer
~#! tid=1027608198
Deshalb mach ich auch keine Gilde :-) Mir klang das nur noch in den Ohren,
dass die Zaubis nicht stimmungsfreudig sind. Aber sowas galt dann wohl nicht
fuer die Bequemlichkeitsfeatures, an sowas gewoehnen sich die Spieler. Hm, wie
menschlich.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^8: Magister (Gnome, 26. Jul 2002, 16:44:45):
~#! rn=Ark rt=1027692908 rg=gilden.zauberer
~#! tid=1027608198
warum sollte das der stimmung (?) einen abbruch tun, wenn briesel was
in die mpa schreibt? ist doch eher das gegenteil der fall.
ok, und es ist bequemer. na und? :)

-----------------------------------------------------------------------------



Re^9: Magister (Gloinson, 26. Jul 2002, 16:52:13):
~#! rn=Gnome rt=1027694685 rg=gilden.zauberer
~#! tid=1027608198
Briesel? Was in die Zeitung? In welcher Gilde bist Du nochmal? Und da schreibt
der Chef selbst was in die Zeitung? Schreibs doch selber, so als Adjutant.

Gloin(son)

-----------------------------------------------------------------------------



Re^10: Magister (Tzofe, 26. Jul 2002, 16:53:09):
~#! rn=Gloinson rt=1027695133 rg=gilden.zauberer
~#! tid=1027608198
Gibs doch zu: Brieseltrim kann gar nicht Schreiben :))

-----------------------------------------------------------------------------



Re^11: Magister (Grimmborn, 28. Jul 2002, 21:09:17):
~#! rn=Tzofe rt=1027695189 rg=gilden.zauberer
~#! tid=1027608198
Tja. So wie ich das sehe sind die Gildenmagier fuer ihre Gilden
verantwortlich, und (soweit es mich betrifft) auch fuer die entsprechenden
Rubriken in der mpa. Wenn also ein Gildenmagier beschliesst, dass sein
Gilden-NPC laufend Artikel der Art "Doofnuss hat gerade die Hochebene
betreten" und "Depperl hat vorhin mutig eine Biene umgebracht, Ruhm und Ehre
unserer Gilde!", dann ist das fine by me. Jeder darf in sein eigenes Unglueck
rennen.

GdA

-----------------------------------------------------------------------------



Re^12: Magister (Montanus, 29. Jul 2002, 21:54:27):
~#! rn=Grimmborn rt=1027883357 rg=gilden.zauberer
~#! tid=1027608198
Da du, lieber Cuch*, hier dauernd auf der Zwergen-/Elfenmentalitaet
herumreitest, lass dir gesagt sein:

*Echte* Elfen stehen ueber so etwas. (Insofern ist GdA eigentlich ein
perfekter Elf, auch wenn er sich gerne als Zwerg tarnt.)
Die Jammerei ist was fuer die Menschen, Katzenbekommer und Hobbits.

-----------------------------------------------------------------------------



Re^13: Magister (Grimmborn, 29. Jul 2002, 22:38:37):
~#! rn=Montanus rt=1027972467 rg=gilden.zauberer
~#! tid=1027608198
Also, wenn Du mich beleidigen willst kannst Du das gerne tun, aber jammer dann
nicht ueber die Konsequenzen. Mich mit so einem schwulen Baeumeficker zu
vergleichen, also wirklich...

GdA

-----------------------------------------------------------------------------



Re^14: Magister (Montanus, 30. Jul 2002, 17:30:09):
~#! rn=Grimmborn rt=1027975117 rg=gilden.zauberer
~#! tid=1027608198
Ich bin Elf. *Ich* jammer nicht. Da steh ich doch meilenweit drueber. :-)

-----------------------------------------------------------------------------



Re^15: Magister (Grimmborn, 30. Jul 2002, 17:38:17):
~#! rn=Montanus rt=1028043009 rg=gilden.zauberer
~#! tid=1027608198
Wenn Du nicht jammerst, was hast Du dann in dieser Rubrik zu suchen?

GdA

-----------------------------------------------------------------------------



entspannte metzler (Patryn,  6. Aug 2002, 22:10:43):
also manche haben probleme:

wird bei einem zeitverzoegerndem spell wie feuerball mittel oder gross bzw
wandlung waerend der verzoegerung ein commando wie unt eingegeben, ersetzt
das argument, das bei dem spell angegeben wurde. Bsp: wandlung feuer; 
unt eis; du wandelst dich auf eis...

dieser fehler wurde so oder aehnlich gleich mehrmals abgesetzt :)
wenn das keine abgebruehten metzler sind...

-- 
patryn

-----------------------------------------------------------------------------



fuer kollektivgedaechtnis (Patryn,  8. Aug 2002, 16:20:52):
wer sich aus der liste austraegt, darf keinen posten innehaben.
wer sich (sogar sofort) wieder in die liste eintraegt, kassiert eine
postenblockierungssperre von 14 tagen.
das ganze gab anderen magistern planungssicherheit, als der postenmarkt
heisser umkaempft war.
scheint wohl undokumentiert zu sein.

-- 
patryn

-----------------------------------------------------------------------------



Re: Befehle von oben ausgefuehrt (Vardion,  9. Aug 2002, 10:06:03):
~#! rn=Nonne rt=1028878142 rg=gilden.klerus
~#! tid=1028878142
Die erste "klitzekleine" Aenderung waere doch eigentlich auch was fuer
Schutzhuelle...

Vardion, duckt sich schonmal

-----------------------------------------------------------------------------



Re: Re: Befehle von oben ausgefuehrt (Patryn,  9. Aug 2002, 10:47:11):
~#! rn=Vardion rt=1028880363 rg=gilden.zauberer
~#! tid=1028878142
wenn du drauf stehst, klemm ich schutzhuelle auf andere spontan ab,
ich mach mich da nich heiss.
wer die schutzhuelle wirklich kennt, der weiss eh, dass es als schutz
auf nichtmagische gilden eh mehr nen kosmetisches gimmick denn ein
wirkliches feature darstellt.
aber es gibt nen unglaublich gutes gefuehl, hab ich von kaempfern gehoert.

-- 
patryn

-----------------------------------------------------------------------------



Re^3: Befehle von oben ausgefuehrt (Gnome,  9. Aug 2002, 10:48:30):
~#! rn=Patryn rt=1028882831 rg=gilden.zauberer
~#! tid=1028878142
da hast du richtig gehoert, also lass sie dran :)
vardion sabbelt immer so viel, wenn er mal wieder zu tief ins
cola-glas geschaut hat... :o)

-----------------------------------------------------------------------------



Re^4: Befehle von oben ausgefuehrt (Pitfall,  9. Aug 2002, 10:55:46):
~#! rn=Gnome rt=1028882910 rg=gilden.zauberer
~#! tid=1028878142
es ist halt ein gutes gefuehl wenn der spell des gegners in nem hart
resultiert und nicht in nem staub :)

-----------------------------------------------------------------------------



Re^5: Befehle von oben ausgefuehrt (Patryn,  9. Aug 2002, 11:04:46):
~#! rn=Pitfall rt=1028883346 rg=gilden.zauberer
~#! tid=1028878142
nonne hat mich auf ein problem aufmerksam gemacht.
jede gilde wird mir ihrer magiebegabtheit beruecksichtigt,
die kaempfer waren hierbei total falsch eingeordnet und sind nun auf
dem vorgesehenen level aehnlich den karateka.
viel spass

-- 
patryn

PS: ehe hier wieder wueste verschwoerungstheorien auftauchen, nonne kann
euch gern bestaetigen, dass sich nur eine zahl, und die zurecht,
geaendert hat

-----------------------------------------------------------------------------



Re^6: Befehle von oben ausgefuehrt (Pitfall,  9. Aug 2002, 11:06:15):
~#! rn=Patryn rt=1028883886 rg=gilden.zauberer
~#! tid=1028878142
das staub von vorhin wird also nicht zu hart sondern zu pulver?

-----------------------------------------------------------------------------



Re^6: Befehle von oben ausgefuehrt (Nonne,  9. Aug 2002, 11:07:57):
~#! rn=Patryn rt=1028883886 rg=gilden.zauberer
~#! tid=1028878142
Ich wollte doch nur nachschauen, ob die wirklich so schlecht ist, bin ueber
diesen einen Wert gestolpert und habe nur nachgefragt, wieso der so ist. Ich
wollte das nicht, wirklich, ehrlich, tut mich nicht weh! Nein, was wollt ihr
mit dem Strick? Und der Balken da drueben... hilfe lasst mich runter... AAARGH

-----------------------------------------------------------------------------



Lehrlingspruefung (Kantos, 11. Aug 2002, 12:23:41):
Also die Syntax "melde Dich zur Lehrlingspruefung" find ich etwas behaemmert
:)
Manche meinten es soll die "Entkoerperung" des Selbst darstellen... aber ich
melde nunmal nicht DICH, sondern MICH an :)...
Also entweder ganz raus mit dem personenbezogenen oder richtig *G*

-----------------------------------------------------------------------------



Re: Lehrlingspruefung (Boing, 11. Aug 2002, 12:28:54):
~#! rn=Kantos rt=1029061421 rg=gilden.zauberer
~#! tid=1029061421
Standardsyntax im gesamten MorgenGrauen (naja, Ausnahmen bestaetigen die
Regel) ist, dass Du Deinem Charakter einen Befehl gibst, insofern ist
die Syntax absolut korrekt und passend zum restlichen MG.
  Boing

-----------------------------------------------------------------------------



Hae? (Kantos, 11. Aug 2002, 12:30:10):
ICH kletter ne leiter nach oben, ich zuecke eine Waffe, ich trage ein schild
.... nicht zieh "name" schild an

-----------------------------------------------------------------------------



Re: Hae? (Boing, 11. Aug 2002, 12:41:11):
~#! rn=Kantos rt=1029061810 rg=gilden.zauberer
~#! tid=1029061810
zuecke waffe
ziehe hose an
lies schild
kletter auf dach
betritt hoehle
tritt ork
melde dich an
...
Alles Befehle an Deinen Char aus Sicht der RL-Person an der Tatstaur.

  Boing

-----------------------------------------------------------------------------



Re: Re: Hae? (Humni, 18. Aug 2002, 23:12:00):
~#! rn=Boing rt=1029062471 rg=gilden.zauberer
~#! tid=1029061810
He, cool, darueber und ueber die Identifikation mit dem Char und sowas hab ich
kuerzlich nen Vortrag gehalten... ich such die URL aber erst nahc meinem
gleich fortgesetzt werdenden Urlaub raus ;-)

Humni

-----------------------------------------------------------------------------



Re^3: Hae? (Shaeena, 25. Aug 2002, 03:10:49):
~#! rn=Humni rt=1029705120 rg=gilden.zauberer
~#! tid=1029061810

woher kommen dann die meldungen "Du grinst." - "Du knuddelst xyz." ect? wenn
es der char ist, dem man befehle gibt, muesste da wie bei den einfachen emotes
stehen "zyx grinst." - "zyx knuddelt xyz." 
..oder sehe ich das jetzt falsch?
Shaeena

-----------------------------------------------------------------------------



Re^4: Hae? (Croft, 25. Aug 2002, 11:04:13):
~#! rn=Shaeena rt=1030237849 rg=gilden.zauberer
~#! tid=1029061810
Wieso?  Ist doch nur eine Frage der Erzaehlperspektive.  Erzaehlt wird
mit Du, und man greift ueber die Befehle direkt in die Handlung ein.
Gruss Croft

-----------------------------------------------------------------------------



Re^5: Hae? (Humni, 25. Aug 2002, 12:15:17):
~#! rn=Croft rt=1030266253 rg=gilden.zauberer
~#! tid=1029061810
Das ist ja das interessante: Ich hab meinen Kollegen (Soziologen und
Germanisten und solche Leute) ein Mud gezeigt, und nach einem einfachen
vorfuehren des sage-Befehls ging die Diskussion los, mit wem da geredet
wuerde, mit dem Char,  mit dem Mudrechner, mit... was weiss ich.. Loesung
haben wir keine gefunden. Interessantest Problem.

Zum Thema emotes: Dass da nicht bei ":graebt ein Loch" ein "Du graebst ein
Loch" steht hat einfach damit zu tun, dass ich keinen Parser kenne, der sowas
umsetzen koennte - oder will das jemand tun? ;-)

Humni

-----------------------------------------------------------------------------



Re^6: Hae? (Grimmborn, 25. Aug 2002, 13:45:17):
~#! rn=Humni rt=1030270517 rg=gilden.zauberer
~#! tid=1029061810
Wieso Diskussion? Du redest mit Deinem Char, und zwar im Imperativ. Dass Die
Rueckmeldung dann nicht "Du sagst:" sondern "Humni sagt:" lauten muesste ist
halt nicht so logisch, laesst sich aber mit tf sicher schnell beheben...

GdA

-----------------------------------------------------------------------------



Re^7: Hae? (Vanion, 25. Aug 2002, 13:50:12):
~#! rn=Grimmborn rt=1030275917 rg=gilden.zauberer
~#! tid=1029061810
Vanions interaktiver User (von 127.0.0.1) sagt durch Vanion: Hol mir mal 'ne
Vanions interaktiver User (von 127.0.0.1) sagt durch Vanion: Flasch Bier.

V*, ist mit der aktuellen Loesung eigentlich ganz zufrieden.

-----------------------------------------------------------------------------



Re^8: Hae? (Muadib, 26. Aug 2002, 13:40:18):
~#! rn=Vanion rt=1030276212 rg=gilden.zauberer
~#! tid=1029061810
zauberer!

-----------------------------------------------------------------------------



Ein Gedicht :) (Gaulious, 10. Okt 2002, 23:48:25):
Zauberer

Ich war froehlich, dacht' nicht viel,
als ich in einen Strudel fiel,
ich sank in 1000 Farben nieder
und sagte nur: och, nicht schon wieder!

Der Steinbeisser, der grinste frech:
"Doch Gaulious, du hast recht,
die sorgenlose Zeit RL,
ist hiermit jetzt erst mal vorbei."

Da Widersprechen zwecklos war,
das wusste ich vom letzten mal,
zog ich erstmal den Spitzhut an,
und fragte Llysi: was steht an?

Llystrathe holte Luft und sprach:
"Mein lieber Gaulious,
jetzt mach dich fertig und sieh zu,
dass du der hohen Kuratoren
Wuensche schenkest deine Ohren,
und wenn du aufm Weg grad bist,
auch meine Erdbeeren nicht vergisst."

So zog ich aus, weit durch die Lande,
durch neue und mir wohlbekannte,
durch Hoehlen von schrecklichem Tier.
ein Drache da, ein Untier hier...
Den ganzen Tag durch die Gefahren,
bei Monstern buessen mit Haut und Haaren,
bis ich schliesslich voellig platt
jeden Wunsch erfuellet hab.

Muede komme ich sodann
wieder bei der Chefin an.
Diese doch kein Mitleid kennt,
mich noch einen Faulpelz nennt.

"Gaulious so geht das nicht,
warst du nur in der Kneipe drueben?
ich seh mit Schrecken dein' Bericht,
du wirst jetzt erst mal zaubern ueben!"

Tausend Zauber spaeter dann,
ich nun wirklich nicht mehr kann.
Hab gerade noch das Bett erreicht,
Zauberer sein ist gar nicht leicht...

Gaulious - hatte Langeweile ;)

-----------------------------------------------------------------------------



Re: Ein Gedicht :) (Birdy, 14. Okt 2002, 12:21:18):
~#! rn=Gaulious rt=1034286505 rg=gilden.zauberer
~#! tid=1034286505
schoen :)

uebrigens bin ich grad bei hellsicht zurueckgetreten, da ich kaum noch spiele.

-----------------------------------------------------------------------------



angriffsmagister (Patryn, 24. Okt 2002, 18:24:35):
Hi Angriffsmagister,

schaut bei der Feuerwlaze mal bitte genauer hin und meldet mir evtl. Fehler,
es gab da umfangreiche technische Umstellungen.
Optimal ist es, wenn ihr keinerlei Aenderung bemerkt :)

-- 
patryn

-----------------------------------------------------------------------------



Re: angriffsmagister (Patryn, 24. Okt 2002, 21:52:01):
~#! rn=Patryn rt=1035476675 rg=gilden.zauberer
~#! tid=1035476675
OK...damit auch andere mittesten koennen ist auch feuerball technisch
umgestellt, stichwort asynchron-mode, wer damit was anzufangen weiss,
schaue bitte auch auf moegliche Probleme, besonders die mittleren und
grossen Versionen. Wenn alles klappt sollen auch die anderen
Flaechenspells folgen.

-- 
patryn

-----------------------------------------------------------------------------



Re: Re: angriffsmagister (Grimmborn, 24. Okt 2002, 22:30:32):
~#! rn=Patryn rt=1035489121 rg=gilden.zauberer
~#! tid=1035476675
Ich hab einen Fehler gefunden: Das heisst "Feuerwalze", nicht "Feuerwlaze".
Was hab ich gewonnen?

GdA

-----------------------------------------------------------------------------



bug (Patryn, 28. Okt 2002, 17:22:41):
hi testies,

wie schauts jetzt bei prepared spells aus?
ueberschreiben zwischenbefehle immer noch die argumente?

-- 
patryn

-----------------------------------------------------------------------------



flaechenspells (Patryn, 29. Okt 2002, 12:06:18):
ok, alle flaechenspells sollten nun technisch umgestellt sein.
das betrifft sofern ich sehe feuerball, feuerwalze, erdbeben, daemonenfratze.
dort bitte ganz genau aufpassen und bugs bitte melden.
das ganze ist etwas tricky und bugs werden also geradezu erwartet ;)

-- 
patryn

-----------------------------------------------------------------------------



Spells... (Patryn, 31. Okt 2002, 17:13:28):
Hi,

bitte die naechsten Tage wieder auf Veraenderungen achten, wenn eine da ist,
mir mailen...das waer dann naemlich falsch ;)
Hauptsaechlich habe ich die Abfragen der Lern- und Nutzungsrestriktionen
ueberarbeitet/optimiert. (z.B. Charakterabfrage)

-- 
patryn

-----------------------------------------------------------------------------



zrufe (Patryn, 30. Nov 2002, 15:14:43):
hey, die seite zu zrufe wurde mal erneuert.
in der tat braucht man schon immer einen gewissen zstabskill um rufen
zu koennen...habs mal dokumentiert.
nur geuebt hat man halt damit nie...waer sonst etwas ...laut ;)

-- 
patryn

-----------------------------------------------------------------------------



abwertung ;) (Patryn, 16. Jan 2003, 20:47:19):
Zauberstabgimmicks testen vorsichtigerweise auf Gilde und auch als Geist
kann man sie nicht mehr benutzen. Frohes meckern.

-- 
patryn

-----------------------------------------------------------------------------



schutzzone (Patryn, 19. Jan 2003, 02:46:51):
Wegen grobem Unfug wurde die Schutzzone nun auch mit den
schon lange vorhandenen Schutzhuelle-Gildenfaktoren versehen.
Gleichzeitig wurden einige Gilden dort neu eingestuft.
Weitere leichte Aenderungen kommen sicherlich noch.

-- 
Patryn

-----------------------------------------------------------------------------



Re: schutzzone (Foobar, 19. Jan 2003, 03:12:30):
~#! rn=Patryn rt=1042940811 rg=gilden.zauberer
~#! tid=1042940811
Gelten die Aenderungen auch fuer NPC?

Falls ja, sind die schwarzen Skelette wohl leichter geworden. ;o)

Gruss,

   Foobar

-----------------------------------------------------------------------------



Re: Re: schutzzone (Patryn, 19. Jan 2003, 13:13:08):
~#! rn=Foobar rt=1042942350 rg=gilden.zauberer
~#! tid=1042940811
Die gelten auch fuer NPC, leider war die Freund-Feind-Kennung vorher
suboptimal, sodass auch die Schutzzone der NPCs Spieler schuetzte,
wen sie gelungen war.
Da dies nun alles ganz anders ist, beispielsweise alle im eigenen Team
u.s.w. als Freunde erkannt werden, Spieler Spieler als Freund erkennen,
NPCs NPCs als Freunde erkennen...blabla bla...
muessten sie staerker geworden sein.

-- 
Patryn, hat nicht wirklich nachgeschaut

-----------------------------------------------------------------------------



Re^3: schutzzone (Foobar, 19. Jan 2003, 13:33:10):
~#! rn=Patryn rt=1042978388 rg=gilden.zauberer
~#! tid=1042940811
*argl* :o)

Foobar

-----------------------------------------------------------------------------



Re^4: schutzzone (Mandragon, 19. Jan 2003, 13:33:56):
~#! rn=Foobar rt=1042979590 rg=gilden.zauberer
~#! tid=1042940811
Also das heisst, das die Skelette uns in Zukunft nicht mehr netterweise ne
Zone spendieren? ;o)

Ma*

-----------------------------------------------------------------------------



schutzzeugs (Patryn, 19. Jan 2003, 23:41:49):
Hi,

<schutz> wirkt nun auch auf andere Lebewesen, aber auch mit den
Multiplikatoren. Auf den Zauberer selbst leicht aufgewertet, nachbesserungen
moeglich!
schutz, schutzhuelle und schutzzone haben alle gildenmultiplikatoren,
welche die magiebegabtheit der gilden widerspiegeln
 (oder die balance *g*)
Auf Karateka oder Kaempfer bringts also viel weniger als auf Zaubis oder
Tanians, das meiste auf caster selbst.
Wichtige Aenderung! Wenn der Zauberer nicht anwesend ist, dann sind alle
drei Spells viel schlechter. Zusatzlernen war ja dann eh schon nicht.
spruchhilfe schutz und schutzzone hilft.

-- 
patryn

-----------------------------------------------------------------------------



Diskussion (Patryn, 21. Jan 2003, 14:35:07):
Was ich schon lange vorhabe, mancher wird es wissen, ist die Abschaffung
der Unterstuetzungen. Einige der damals Mitkonzeptionierenden sind heute der
Meinung, dass das ganze ein Fehler war.
Zu denen gehoere auch ich, aber mich interessiert eure Meinung dazu.  
Eigentlich wollte ich das jetzt noch nicht machen, aber aeussere Umstaende
veranlassen zur eiligen Entscheidungsfindung.
Was ist der Sinn des Ganzen?
Also erst mal wird ja, egal wie gering die Unterstuetzung ausfaellt, solch
eine Ruestung sofort komplett fuer den Zauberer freigeschaltet, ohne
jegliche Behinderung. Das macht auch Sinn, denn was soll sonst die
Unterstuetzung fuer Zauberer da drin? Das war aber auch von Anfang an der
Fehler unseres Konzeptes.
Zauberer rennen quasi wie Kaempfer durch die Gegend, abgesehen von den
Waffen. (wobei es grad andersrum eher gehen wuerde, Hand ist staerker als
 jeder Vollstrecker und ich kenne kaum Fantasyliteratur, in der Zauberer
 vollgepanzert rumlaufen koennen, aber jede Waffe sofort aus der Hand
 faellt)
Ich bin fuer Back to the Roots, Umhang, Hose, Hut, paar speziell markierte
Items (Hydraruestung z.B. ging bereits damals, oder Schlagring),
und gut ist.
Dafuer geben wir 'rueste' wieder einen Sinn fuer den Zauberer selbst,
errechnen, inwieweit Schutzspells allgemein wieder angepasst werden muessen.
Fuer das Lernen findet man auch eine Loesung.
Nun ist wirklich eure Meinung gefragt. Fuer wie interessant haltet ihr
Unterstuetzungen? Eigentlich hat man doch eh nach einer Weile sein
Standardset?!
Haltet ihr es fuer sinnvoll, dass wir so viel Ruestung anziehen koennen,
aber unsere Abwehrspells dafuer eher Lau sind?
Was bevorzugt ihr?

--
Patryn

-----------------------------------------------------------------------------



Re: Diskussion (Cuchullin, 21. Jan 2003, 14:36:32):
~#! rn=Patryn rt=1043156107 rg=gilden.zauberer
~#! tid=1043156107
Fehler in der zweiten Zeile: Streiche "Einige", setze "Alle".

Back to wizardry,
YTCu

-----------------------------------------------------------------------------



Re: Diskussion (Boing, 21. Jan 2003, 14:39:38):
~#! rn=Patryn rt=1043156107 rg=gilden.zauberer
~#! tid=1043156107
Ich halte Unterstuetzungen fuer eine gute Sache, da sie etwas Farbe
und Vielfalt ins Spiel bringen. Optimal waere es, wenn sich die
Unterstuetzungen auf zauberertypische (leichte) Ruestungen beschraenken
wuerden. Aus einer Diskussion ueber die Staerke der Schutzsprueche
halte ich mich aber mal mangels Wissen raus.

  Boing

-----------------------------------------------------------------------------



Re: Re: Diskussion (Vardion, 21. Jan 2003, 14:51:14):
~#! rn=Cuchullin rt=1043156192 rg=gilden.zauberer
~#! tid=1043156107
Hi.

Mit den momentanen Schutzspells finde ich es nicht nur gut, sondern sogar
notewendig, dass Zauberer Ruestungen tragen koennen. Solange jeder NPC mir
nach Gutduenken mal eben meine Schutzhuelle nehmen (und womoeglich gleich noch
durch eine schadensverstaerkende Anti-Huelle ersetzen) kann, sind Ruestungen
der einzige Weg, den Instant Death eines solchen "entbloesten" Zauberers zu
verhindern. Ich koennte mich da gleich mal aufregen, dass ich es unfair finde,
Zauberern die Huellen zu zappen, aber Kaempfern nicht ihre Ruestung
wegzunehmen. Naja, lassen wir das...
Prinzipiell bin ich auch dafuer, wenn halt die Umstaende angepasst werden.

Den Vergleich mit Kaempfern kann ich nicht ganz zustimmen, da deren Ruestungen
doch deutlich staerker als das sind, was wir tragen duerfen.

Zur Unterstuetzung an sich: die finde ich nicht sooo schlecht. Zum einen gibt
es derartiges auch in anderen Gilden (ok, das ist kein wirkliches Argument)
und zum anderen ermoeglicht es Zauberern ueberhaupt erst das Konzept der
Ausruestung. Ich finde es schon schoen, wenn man durch etwas Metzeln einen
staerkeren Feuerball erlangen kann, als man ihn allein durch die Beschaffung
der Komponenten hat. Aber sowas kann dann ruhig auf Ringe etc gepackt werden,
und nicht auf irgendwelche klobigen Teile.

Vielleicht koennte man da bei Schutzspells auch mal ueber "permanente"
Varianten nachdenken. Also so in etwa ich caste "huelle an" und die geht dann
nicht mehr aus, sondern zieht halt aller 30 sek oder was auch immer MP.
Momentan ist man halt auf irgendwelche Schutz-Erhalt-Trigger angewiesen um
einen aehnlich permanenten Effekt wie das Tragen einer Ruestung zu erreichen.
Ok, aber von dem Problem sind auch Kleriker, Tanjian usw betroffen...

Also alles im Allem Schutzspells rauf und Ruestungen weg.

Vardion

-----------------------------------------------------------------------------



Re^3: Diskussion (Foobar, 21. Jan 2003, 15:08:43):
~#! rn=Vardion rt=1043157074 rg=gilden.zauberer
~#! tid=1043156107
Moin.

Die von Dir, Patryn, beschriebene Abkehr vom status quo hoert sich zunaechst
mal ganz gut an. Es klingt logisch, wenn ein Zaubi statt mit irgendwelchem
Ruestungen oder Panzern mit Gewand, Sandalen, Stab und evtl. Ring und Amulett
rumlaeuft.

Nimmt man allerdings den Zaubereren - so wie sie jetzt sind - die Qual der
Wahl weg, welche unterstuetzenden Ruestungen sie tragen sollen, geht das
bisschen Komplexitaet was momentan vorhanden ist auch noch floeten.

Zwar muss der Zaubi dann gucken, welchen Schutzspell er zusaetzlich zu
"rueste" noch hochfaehrt, aber da hat der durchschnittliche Zauberer ja nur
zwei zur Auswahl.

Ich begruesse das Vorhaben, dass Zauberer wieder zaubern sollen,
ausdruecklich, halte es aber fuer sinnvoll, ihnen dann
mehr/andere/verschiedene Schutzspells zu verpassen. Ob sie das universeller,
staerker, oder schwaecher macht wird man sehen, ich hoffe nur dass es sie
anspruchsvoller macht ;o)

Gruss,

   Foobar

-----------------------------------------------------------------------------



Re^4: Diskussion (Patryn, 21. Jan 2003, 15:15:01):
~#! rn=Foobar rt=1043158123 rg=gilden.zauberer
~#! tid=1043156107
Also zur Vielfalt, genau deswegen sollte das nach den Hand-Aenderungen
kommen eigentlich.
Weiterhin mal eine urpsruengliche Idee waere Schutzhuelle mit Angabe
von bevorzugter Schadensabwehr und wie lange geplant, verschiedene
Staerkestufen fuer alle Spells statt nur Feuerball (teils in Arbeit)

-- 
Patryn

-----------------------------------------------------------------------------



Re^5: Diskussion (Foobar, 21. Jan 2003, 15:16:28):
~#! rn=Patryn rt=1043158501 rg=gilden.zauberer
~#! tid=1043156107
Und dann wuensche ich mir noch dass "verletze" in einen Spell pro Schadensart
aufgedroeselt wird ;o)

Foobar

-----------------------------------------------------------------------------



Re^6: Diskussion (Varlarion, 21. Jan 2003, 15:22:14):
~#! rn=Foobar rt=1043158588 rg=gilden.zauberer
~#! tid=1043156107
Huhu,

auch wenn das MG herzlich wenig mit Rollenspiel zu tun hat, faellt mir zu dem
Thema doch ein, dass es zauberkundigen Charakteren in vielen Systemen
untersagt ist, metallene Ruestungen zu tragen, bzw. dass sie darin nicht in
der Lage sind, zu zaubern.
Ich faende es daher - nebst einer AC-Einschraenkung natuerlich - recht
stimmungsvoll, den Zaubies nur Ruestungen aus bestimmten Materialien (Stoff,
Leder, Holz, etc.) zu erlauben. Dass dann die Schutzspells ein wenig angepasst
werden muessten, sollte klar sein, denke ich.
Ein weiterer Gedanke waere, dass die Aufrechterhaltung eines Schutzspells
Konzentration (und damit Magiepunkte) kostet.

Varl*

-----------------------------------------------------------------------------



Re^7: Diskussion (Vardion, 21. Jan 2003, 15:23:22):
~#! rn=Varlarion rt=1043158934 rg=gilden.zauberer
~#! tid=1043156107
Sind gewisse Lederruestungen, die aus 100% Metall bestehen, dann Leder oder
Metall? :-)

Vardion

-----------------------------------------------------------------------------



Re: Diskussion (Gnome, 21. Jan 2003, 16:54:28):
~#! rn=Patryn rt=1043156107 rg=gilden.zauberer
~#! tid=1043156107
auf der einen seite: begruessenswert.
schutz(huelle) wieder zu dem machen, was es sein sollte (ich erinnere
mich gerne in dem zusammenhang an LOR1, an der stelle, an der gandalf
dem balrog gegenuebersteht, seinen stab mit den worten 'you shall not
pass' auf den boden donnert und die flamme uduns an gandalfs optisch
kaum wahrnehmbarer schutzhuelle abprallt, wie ein tennisball an einem
gueterwaggon... DAS war doch mal ein schutz.:) ).
und endlich zauberer, die nach zauberer und nicht nach schlecht ausge-
ruesteten kaempfern aussehen. mit einem gewand, einem amu, einem ring.
nagut, einem hut noch. :)

andererseits: ueberlegenswert.
die qualitative vielfalt haengt dann NUR noch von dem skill selber ab.
also ein in-2-tagen-auf-max-zaubi kann dann genauso gut casten, wie
einer, der die gilde wirklich verstanden und das mg erkundet hat, wobei
bei letzterem man frueher (ich spreche schon in der vergangenheit...)
die 'netten' ruestungen gefunden hat.

vielleicht eine gesunde mischung, wie von einigen schon vorgeschlagen?
unterstuetzung ganz weg und mehr variation in den spell selber hoert
sich aber auch interessant an...

alles in allem aber: dafuer.

gnOme, i. A.

-----------------------------------------------------------------------------



 Re: Diskussion (Goethe, 21. Jan 2003, 17:54:26):
Finde das ein guter Vorschlag, Ruestungen auf ein bestimmtes Mass
zuzueckfahren, Unterstuetzungen ganz weg und dafuer mehr Variabilitaet in die
Schutzspells, also beispielsweise "schutzhuelle feuer". Dazu koennte man ja
eine "schutzhuelle" ohne schadensartangabe einbauen (also quasi wie bisher),
die zwar gegen jeden magischen Schaden gleichermasen schuetzt, dafuer aber
bedeutend mehr KP kostet und in der Spitze nicht ganz an die spezielle Angabe
heranreicht. Wie magst du denn "rueste" in dem Fall aendern? Die wenigen
Ruestungsgegenstaende die man dann bei sich tragen kann sehr viel staerker
ruesten als bisher?
Jedenfalls sollte ein Zauberer irgendwie auch einen Mindestschutz gegen mech
Schaden haben, auch wenn er ne Schutzhuelle gecastet hat, denn wieviele NPC
gibt es die beides machen...

Goethe stellvertretend

-----------------------------------------------------------------------------



Re: Re: Diskussion (Cuchullin, 21. Jan 2003, 18:23:28):
~#! rn=Gnome rt=1043164468 rg=gilden.zauberer
~#! tid=1043156107

Machen wir uns keine Illusionen, den echten Fatasy-Zauberer wird
es hier nicht geben. Die sind naemlich in ihrer Maechtigkeit so
alles und jedem ueberlegen. Trves? Karateka, Chaoten? Solange sie
nicht in Stueckzahlen um die 40, 50 auf den Zauberer einstuermen,
oder sich von hinten angeschlichen haben keiner Erwaehnung wert.

Das geht im Morgengrauen nicht. Vor einem (ordentlich umgesetzten)
Balrog stehen und ihm ungestraft Verbalinjurien entgegenwerfen,
bevor man ihn der Vernichtung zufuehrt... cool, aber... nein. Eher
nicht. Erinnert zu sehr an die Piratengilde.

YTCu

-----------------------------------------------------------------------------



Re^3: Diskussion (Mandragon, 21. Jan 2003, 18:25:12):
~#! rn=Cuchullin rt=1043169808 rg=gilden.zauberer
~#! tid=1043156107

Also ich bin dafuer, mehr Spell, weniger SpellDefend und weniger Ruestung zu
haben.

Allerdings denke ich, dass Unterstuetzungen bleiben koennen. Wenn dir Ruestung
nciht ohnehin eine Zauberruestung ist, muss man sie halt evtl. anpassen, bevor
sie unterstuetzt.

Ma*

-----------------------------------------------------------------------------



Re^3: Diskussion (Ark, 21. Jan 2003, 20:56:01):
~#! rn=Vardion rt=1043157074 rg=gilden.zauberer
~#! tid=1043156107
Monster zu schreiben, die Schutzhuellen aufloesen oder Ruestungen zerstoeren,
ist durchaus ok, _solange_ es nicht dermassen ausufert, dass ein von der
Beschreibung her schon kleineres Monster dazu imstande ist. Da dies dann
wieder sehr magierabhaengig ist, sehe ich natuerlich das Problem, worauf die
Zauberer natuerlich mit Angst, "nackt" dazustehen (...und die Kaempfer
natuerlich mal wieder nicht), reagieren.
"Zaubererkonforme" Ruestungen wie Hut, Ring oder Umhang sind ja ok, alles
andere aber eben nicht, und so wuerde ich es auch passender finden, dass man
sich als Zauberer eher auf die Macht der Magie verlaesst als auf Gegenstaende,
die faehige Zauberer einst fuer die auf Blech angewiesenen Kaempfer
schmiedeten.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^8: Diskussion (Ark, 21. Jan 2003, 20:57:37):
~#! rn=Vardion rt=1043159002 rg=gilden.zauberer
~#! tid=1043156107
Die sind notfalls auch vom RM zu ueberarbeiten. Gibt es da Hinweise aus der
spielenden Bevoelkerung bzgl. eines solchen Items?


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re:  Re: Diskussion (Ark, 21. Jan 2003, 21:00:34):
~#! rn=Goethe rt=1043168066 rg=gilden.zauberer
~#! tid=1043168066
Grob mal ueberlegt, evtl. finden es Zauberer auch besser, ihre Huelle mit
<schutzhuelle 25> oder so einstellen zu koennen, so dass sie in diesem Fall 25
KP dafuer opfern und sich evtl. beim naechsten Mal fuer eine staerkere Huelle
entscheiden muessen, wenn die nicht gereicht hat :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Re:  Re: Diskussion (Orktoeter, 21. Jan 2003, 21:17:02):
~#! rn=Ark rt=1043179234 rg=gilden.zauberer
~#! tid=1043168066
Ich finds ja interessant wie selbstverstaendlich es fuer alle ist, das Zaubis
mit ihren Schutzspruechen dauerhaft ("wenn es in einen neuen Schutzspruch
nicht eingabeut wird, das der dauerhaft anhaelt, dann schreibt man halt einen
Trigger/Script" sorry, aus dem Kopf, also nicht woertlich zitiert)
geschuetzt sein koennen. Ich habe ja gar nichts dagegen das Zauberer stark
sind, aber wie  heisst doch immer so schoen "Jede Gilde soll ihre vor UND
Nachteile haben". Wenn die Zaubis schon ueberarbeitet werden wuerde ich mir
eine Erschoepfung wuenschen, die bwirkt das man nicht gleich wieder
(denselben) Spruch casten kann. Eine weiter nette Idee ist doch, das eine
Schutzhuelle ja ein andauernder Zauber ist und somit Kontrolle verlangt, das
koennte man ja so loesen, das ab einer bestimmten Staerke des Schutzes keine
weiteren Spells mehr gecastet werden koennen (macht alleine wenig Sinn, im
Team aber evtl. schon, wenn dafuer andere laenger drin bleiben und mehr
Schaden mache).

OrkT.

-----------------------------------------------------------------------------



Re^3:  Re: Diskussion (Patryn, 21. Jan 2003, 21:18:22):
~#! rn=Orktoeter rt=1043180222 rg=gilden.zauberer
~#! tid=1043168066
Erzaehl Du uns nix von Vor- und Nachteilen, die kennen _wir_ durchaus.

-- 
Patryn

-----------------------------------------------------------------------------



Re^4:  Re: Diskussion (Cadrach, 21. Jan 2003, 21:56:52):
~#! rn=Patryn rt=1043180302 rg=gilden.zauberer
~#! tid=1043168066
Also von echten Ruestungen kann ich Patryn gerne mal eine ziemlich komplette
Liste zur Verfuegung stellen. Bei echten Ruestungen bezweifel ich auch das es
da noch grosse Altlasten wie metallene Lederruestungen gibt. Die wurden mit
Einfuehrung des Ruestungsskills relativ schnell alle umgestellt - wohl gemerkt
nur die Ruestungen :o)

Wie waers denn die Unterstuetzungen deutlich zu reduzieren (in der Wirkung zu
halbieren) und feste AC-Grenzen einzufuehren (ja dann faellt auch die
Hydraruestung raus - sowas besonderes ist sie naemlich heute auch nicht mehr).
Wenn man das macht, erhaelt man weiterhin die Vielfalt und die Tatsache das
Zaubis sich auch ausruesten muessen (Kompos kauft man ja meist), aber hat
dennoch genug Spielraum auf Spruchseite aufwerten zu koennen.

Ich finde eine Gilde die "nackt" bereits maximale Staerke besitzt, ist mehr
als genug.

Cad*

-----------------------------------------------------------------------------



Re^4: Diskussion (Vardion, 21. Jan 2003, 22:04:49):
~#! rn=Ark rt=1043178961 rg=gilden.zauberer
~#! tid=1043156107
Naja, ich finde es nicht ok. Auch fuer grosse Monster nicht. Denn bei Licht
betrachtet bedeutet das Aufloesen der Huelle fuer einen sonst ruestungslosen
Zauberer "Tod in der naechsten Runde". Damit erzwingst Du natuerlich direkt,
dass sich jeder einen Trigger dafuer schreibt, der einem in dem Fall sofort
rausbringt.
Ein Kaempfer, dem mal eben alle Ruestungen von Kopf bis Fuss aufgeloest
werden, wuerde sicher aehnlich reagieren.

Da das vermutlich nicht ganz Sinn der Sache sein kann, koennte man vielleicht
ueber eine allmaehliche Schwaechung der Huelle durch den NPC nachdenken (sagen
wir mal aller 2-3 Kampfrunden 10-20% weg oder so). Das koennte man dann mit
dem Beschaedigen (statt Aufloesen) von Ruestungen vergleichen. Die Luft wird
halt im Kampf langsam duenner, aber man kann noch per Hand reagieren und wird
nicht zum Triggern gezwungen.

Momentan gibt es halt diverse Monster (vornehmlich von Paracelsus und Wurzel)
die einfach indifferenziert jegliche Schutzzauber killen. Sei er nun auf einen
Kaempfer oder auf einen Zauberer gelegt. Fuer einen per Huelle geschuetzten
Kaempfer oder Karateka mag das ja noch relativ egal sein, ists halt eine
Schutzschicht weniger. Als schutzloser Zauberer kann man in dem Fall aber nur
mit einem recast-Trigger oder im Falle von Paracelsus, der das teilweise sogar
noch verhindert, mit einem Flucht-Trigger reagieren. Gegen Ruestungen
unternehmen diese NPCs wenig bis garnix, aber mal son kleiner
Schutzzauber-Neutralisator scheint ja schnell programmiert zu sein...

Vardion

-----------------------------------------------------------------------------



Re^5:  Re: Diskussion (Patryn, 21. Jan 2003, 22:08:08):
~#! rn=Cadrach rt=1043182612 rg=gilden.zauberer
~#! tid=1043168066
Viele schlagen hier Mischformen vor, hier mal meine Punkte dazu:
- Weniger Ruestungen zulassen fuer Unterstuetzung, Umhaenge, Hose und so:
 Man muss sich mal ueberlegen was dann fuer Unterstuetzungsmonster
auftauchen,
 wenn eine Ruestung die unterstuetzung fuer 2 oder 3 Zweige aufnehmen muss.
 Wenn man das naemlich nicht macht und nur selektiv Sprueche oder Zweige
 mit wenigen Ruestungen unterstuetzt, dann ist das eine knallharte
 Abwertung. Zusammen mit einfuehrung der Unterstuetzung wurde ja der
kkwer
kkwer
 Durchschnittssucces abgesenkt, um den alten mit guter Unterstuetzung
kkwer
 wieder erreichen zu koennen.
- Unterstuetzungen absenken:
 Siehe fast wie oben Begruendung, dann muesste man den Durchschnittssucces
 wieder anheben um das wettzumachen, man hat nachwievor und in noch
 staerkerem Masse sein Standardset, weiterhin noch mal zum mitmeisseln...
 egal wie gering die Unterstuetzung ausfaellt, wird die Ruestung fuer den
 Zauberer dann logischerweise freigeschaltet, weil es eben eine
 magische Ruestung ist. Waer ja etwas schizophraen, wenn die Ruestungen
 Spells unterstuetzt und beim Tragen durch Zauberer behindert, oder?
- nur schwaechere Ruestungen eintragen:
 Nun ja, schleichende Ruestungsinflation. Warum darf ich nich, die
 Hydraruestung hat ja auch u.s.w.
 Also ich seh auch gar nicht den Punkt, mir reicht ein Zauberer mit
 Umhang, Hose, Ringe, Hut und wenigen speziell genehmigten Teilen wie z.B.
 die Hydraruestung in abgeschwaechter Form voellig.

Was die Vielfalt angeht schrieb ich ja schon, da wird anderswo sicher
aufgeruestet.

-- 
Patryn

-----------------------------------------------------------------------------



Re^6:  Re: Diskussion (Patryn, 21. Jan 2003, 22:09:28):
~#! rn=Patryn rt=1043183288 rg=gilden.zauberer
~#! tid=1043168066
die kkwers entstehen wenn mich leute beim artikelschreiben zulabern ;)

-- 
patryn

-----------------------------------------------------------------------------



Re^5: Diskussion (Ark, 21. Jan 2003, 22:11:03):
~#! rn=Vardion rt=1043183089 rg=gilden.zauberer
~#! tid=1043156107
Ich verstehe Deine Bedenken nur insoweit, als dass Du die Magier
(wahrscheinlich nicht ganz zu unrecht) verdaechtigst, sowas in moeglichst
viele "prestigetraechtige" Monsterlis einzubauen, Sinn oder nicht Sinn. Aber
trotzdem bin ich der Meinung, dass man sowas bei einigen begruenden kann. Und
zu solchen geht man dann auch normal nicht alleine, vielleicht rettet ja der
Kaempfer durch Rueckendeckung dem Zauberer (sic) das Leben, wenn der boese
Schwarzmagier dem Zauberer gerade die Grenzen aufzeigte.
Und im Gegenzug kann das der Zauberer dem Kaempfer vergelten, wenn dessen
Ruestung durch den heissen Feueratem eines roten Drachen an dessen Koerper
fluessig wird (naja, ein Kleriker waer dann auch noch opportun).
Miss die Monster nicht immer nur an einer Gilde ("ich bin dann machtlos"),
sondern beschwer Dich, wenn es heisst "wir sind zu 15 machtlos, das Monster
ist nicht besonders ausgeglichen".


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^6:  Re: Diskussion (Cadrach, 21. Jan 2003, 22:11:53):
~#! rn=Patryn rt=1043183288 rg=gilden.zauberer
~#! tid=1043168066
Einer schleichenden Ruestungsspirale beugst Du mit einem festen Grenzwert vor.
Entweder man ist drunter, oder eben halt nicht. In meinen Augen vergisst Du in
Deiner Aufzaehlung noch leichte Schuhe und ein Leinenhemd oder wattierten
Waffenrock - soll doch hier keiner sagen wir waeren ein diskriminierendes mud
wo Frauen gezwungen werden, oben ohne rumzulaufen (obwohl haette ja was....
:o).

Cad*

-----------------------------------------------------------------------------



Re^7:  Re: Diskussion (Patryn, 21. Jan 2003, 22:14:28):
~#! rn=Cadrach rt=1043183513 rg=gilden.zauberer
~#! tid=1043168066
Fuer diese leichten Sachen gabs vorher schon das Konzept der
Ruestungsbehinderung, welches seit der Unterstuetzungen quasi
ueberfluessig ist.
Umso besser das Zeug, umso mehr behindert es beim Casten, jeder Spell hat
seine speziellen Werte was fuer Ruestungen OK sind.
Wenn das Zeug unterstuetzt, wird die Behinderung logischerweise
aufgehoben.

-- 
Patryn

-----------------------------------------------------------------------------



Re^6: Diskussion (Vardion, 21. Jan 2003, 22:15:24):
~#! rn=Ark rt=1043183463 rg=gilden.zauberer
~#! tid=1043156107
Ich rede von Zeugs wie Paracelsus' Drachen. Z.B. der liebe gute Nagadrache.
Den hauen weder Trves noch Zauberer noch Tanjian noch Chaoten im Team. Und der
ersetzt z.B. mal eben Huellen durch schadensverstaerkende Antihuellen. Einfach
so... Vermutlich ist der nicht die Art von NPC, fuer die Du das gutfindest.

Vardion

-----------------------------------------------------------------------------



Re^7: Diskussion (Ark, 21. Jan 2003, 22:22:00):
~#! rn=Vardion rt=1043183724 rg=gilden.zauberer
~#! tid=1043156107
Da ich den nicht kenne, sag ich mal diplomatisch "kommt drauf an". Und
Paracelsus hat den geschrieben, als die Zauberer noch mehr konnten, oder
taeusche ich mich? Ohne ihm "Bosheit" und das "Pa*" absprechen zu wollen :-)
Muessen andere begutachten.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^8: Diskussion (Madness, 21. Jan 2003, 22:37:13):
~#! rn=Ark rt=1043184120 rg=gilden.zauberer
~#! tid=1043156107
Da es 'meine' Gilde betrifft wollte ich auch mal ein paar Sachen zu den
Beitraegen sagen:

- Ruestungen
Ich finde das System wie es jetzt ist recht passend, also das man als Zaubi
nicht alle Ruestungen tragen kann.
Und nen magisch begabter Kaempfer will ich auch nicht werden.

- Unterstuetzungen:
Momentan ist es so das ich ohne Unterstuezung z.B. bei verletze nen
durchschnittsschaden von krachen mache und somit auf die Unterstuezung
angewiesen bin.
Desweiter gibt es schon Ruestungen die nicht nur Sprueche unterstuetzen,
sonder auch einige Behindern. Ich denke mal das man dieses Konzept ausweiten
koennte,
das die Ruestungen halt einige Spells unterstuetzen, aber andere Behindern.
Aber ich denke mal das das an den Magiern liegt, die die Ruestungen
anschliessen.
Ausserdem habe ich als Zaubi immer wieder das Problem das ich eh schon nichts
tragen kann und dann noch schwerere Ruestungen?

- Schutz/Schutzhuelle
Also ich denke mal das wir alle Orkt nicht zustimmen koennen. wenn ich nen
Blocker haben moechte, stell man nen Kaempfer mit Taktik 100, SChildkroete +
etc nach vorne.
Mit nehm einstellbaren SChutz koennte ich mich nicht so ganz anfreunden und
auch nicht mit nem 'dauer' Schutz der kps kostet.
Da ich wenn ich z.B. mit wenigen kps irgendwo stehe, halt nur fuer kurze Zeit
ne Huelle aufschmeissen kann und ich somit nicht fluechten koennte.
Ich sehe/habe kein Problem damit den Schutz/die Huelle immer wieder neu im
kampf zu sprechen.

Madness, will als 'aktiver' Zaubi auch mal was dazu sagen ;)

-----------------------------------------------------------------------------



Re^9: Diskussion (Ark, 21. Jan 2003, 22:43:19):
~#! rn=Madness rt=1043185033 rg=gilden.zauberer
~#! tid=1043156107
Dass man als Zauberer wenig tragen kann, ist doch sicher "passend", oder?
Schielt man da wieder zu den K.......? Ist ein (hoffentlich) beabsichtigter
Nachteil.
->balanciert nennt man das wohl :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^10: Diskussion (Cuchullin, 21. Jan 2003, 22:54:03):
~#! rn=Ark rt=1043185399 rg=gilden.zauberer
~#! tid=1043156107
Der Gedanke der Materialabhaengigkeit haette insofern was, da man dann
einen eventuell nicht-"anpassung"-baren Effekt hat. Damit fallen dann
selbstverstaendlich ziemlich viele Ruestungen mit Sondereffekten aus, 
andere wiederum (ein Feuerpanzer rein aus Feuer z.B.) blieben.

Ich bin etwas unentschlossen. Einerseits profitieren fast alle Gilden
von der wachsenden Vielfalt im Waffen/Ruestungsspektrum - und sich da
auszuklinken bedeutet unmittelbar eine "Ablehnung der zeitgemaessen
allgemeinen Aufwertung". Da stehen Zauberer zwar nicht alleine da (die
Handkantenklopper sind da auch mehr oder weniger gut dabei), sie 
betrifft es aber am meisten - schon allein, weil ihnen der Ruf, dass
sie ja die ach so staerkste Gilde seien, nach wie vor anklebt wie
eine Klette am Hund. Andererseits eben *ist* der klassische Zauberer
nunmal in Robe oder allenfalls in wattiertem Klimbim aus Filz.

Vom Unterstuetzerquark wegzukommen halte ich - so oder so - aber fuer
einen richtigen Schritt. Der Kram wurde damals ohnehin "freiwillig"
eingefuehrt, ohne dass die Balance dafuer etwas verschenkt haette...
damals zumindest.

YTCu

-----------------------------------------------------------------------------



Re: Diskussion (Darkwing, 21. Jan 2003, 22:54:51):
~#! rn=Patryn rt=1043156107 rg=gilden.zauberer
~#! tid=1043156107
"back to the roots" ... rueste und schutz aufwerten "ein paar speziell
markiere Items" (hallo Ruestungsspirale) ... ich muss sagen das gefaellt mir
nicht so wirklich. 

Unterstuetzungen weg, das hat durchaus etwas, aber warum muss man das mit
besseren Schutzspruechen kompensieren ? Zauberer gehoeren kaum in die erste
Kampfreihe - was mir viel besser gefallen wuerde waere eine Aufwertung der
Offensivsprueche, die auch aus der zweiten Reihe wirken, da kann es ja ruhig
richtig krachen. 

Ach ja und weg mit der Hand :)
Ach ja und weg mit der Hand :)

Darkwing

-----------------------------------------------------------------------------



Re^11: Diskussion (Ark, 21. Jan 2003, 23:03:35):
~#! rn=Cuchullin rt=1043186043 rg=gilden.zauberer
~#! tid=1043156107
Tja, dann fiele mir nochwas Komisches ein: ein Spruch, der aus den Ruestungen
eine Schutzhuelle macht, die die Eigenschaften der Ruestungen, soweit
moeglich, "aufsaugt" und in einem anderen Spruch wieder mit einer Huelle
abgibt.
Bsp.: Ich haue den Weghier, nehme seinen Ring, vernichte ihn mit dem ersten
Spruch und habe nun in meinem magischen Gedaechtnis die Macht, im naechsten
Kampf mit einem anderen Spruch eine gegen Feuer schuetzende Huelle mit Dauer
schlagmichtot zu wirken.
Also Komponenten mal etwas anders. Interessant: Zauberer und Kaempfer hauen
sich um Ruestungen ;^)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Re: Diskussion (Patryn, 21. Jan 2003, 23:26:29):
~#! rn=Darkwing rt=1043186091 rg=gilden.zauberer
~#! tid=1043156107
Ich widerhole mich auch hier, dass neben Schutz und Schutzhuelle auch Rueste,
und letzteres in die Bedeutungslosigkeit hinein, nach den anfaenglichen
Bugfixes nochmals ziemlich stark abgewertet wurden, lag hauptsaechlich
daran, dass die Zaubis auf einmal jeden Kram tragen konnten.
Vorher wars in der Tat kein Problem, den Umhang auf *2 hochzuruesten,
ausser das man heutzutage andere Gilden beruecksichtigen wuerde.
Danach war es natuerlich indiskutabel, und so ist rueste heut nur noch...
ich wag es angesichts von Gewohnheitsruestern kaum auszusprechen...
atmosphaerisches Gimmick.

-- 
Patryn

-----------------------------------------------------------------------------



Re^3: Diskussion (Patryn, 21. Jan 2003, 23:30:30):
~#! rn=Patryn rt=1043187989 rg=gilden.zauberer
~#! tid=1043156107
Ach ja, der Spruch <anpassung> hat wohl aehnliche Probleme, ueberfluessig
geworden mit Unterstuetzungen. Vorher durchaus wichtig :)

-- 
Patryn

-----------------------------------------------------------------------------



Re^4: Diskussion (Grimmborn, 21. Jan 2003, 23:38:05):
~#! rn=Patryn rt=1043188230 rg=gilden.zauberer
~#! tid=1043156107
Frueher so wichtig wie heute, und noch genauso wirksam, ist der Spruch
"unterschreibe vertrag". Hilft auch gegen diese ganzen Jammereien (erzeugt
allerdings oft neue).

GdA

-----------------------------------------------------------------------------



Re^5: Diskussion (Cadrach, 21. Jan 2003, 23:58:45):
~#! rn=Grimmborn rt=1043188685 rg=gilden.zauberer
~#! tid=1043156107
Wieso muessen denn unterstuetzende Ruestungen nicht behindern? Wer das will
kann sie anpassen... voila..
1.) Du kannst "rueste" wieder aufpassen
2.) Anpassung hat wieder einen Sinn

Cad*

-----------------------------------------------------------------------------



Re: Re: Diskussion (Cuchullin, 22. Jan 2003, 00:06:23):
~#! rn=Darkwing rt=1043186091 rg=gilden.zauberer
~#! tid=1043156107
> Zauberer gehoeren kaum in die erste Kampfreihe - was mir viel besser
> besser gefallen wuerde waere eine Aufwertung der Offensivsprueche, 
> die auch aus der zweiten Reihe wirken, da kann es ja ruhig richtig
> krachen.

Du wirst damit sicher offene Tueren einrennen. Nur muessen Zauberer im
Laufe ihrer Existenz auch durch Abenteuer, wo sie - alleine - Gegner
besiegen muessen, die nicht immer mit Finesse (huhu Ark ;)) zu bezwingen
sind. Allein aus diesem Umstand brauchen sie hier im Morgengrauen einen
Schutz.

Vielleicht ist sowas wie eine "letzte Reife" denkbar, in der der Zauberer
Einbussen im Schutz gegen mechanischen Kampfrundenschaden hinnimmt, aber
die Moeglichkeit hat, in den "Ultramodus" zu wechseln: Einkommender 
Schaden der mechanischen Kampfrunde mal fuenf (schmetter brei pulver),
ausgehende Kampfspells mal sechs (fuer austolerierbare Werte von "fuenf"
und "sechs"). Koennte, finde ich, eine nette Art sein, den schoenen Titel
"Erzmagister" wiederzubeleben. Auch wenn es letzten endes heisst, dass
beliebig viele davon rumlaufen koennen...

YTCu

-----------------------------------------------------------------------------



Re^6: Diskussion (Mandragon, 22. Jan 2003, 01:14:39):
~#! rn=Cadrach rt=1043189925 rg=gilden.zauberer
~#! tid=1043156107

Schoen das jemand anders meine Ideen an dieser Stelle aufgreift.

Ma*

-----------------------------------------------------------------------------



Re^6: Diskussion (Patryn, 22. Jan 2003, 01:17:50):
~#! rn=Cadrach rt=1043189925 rg=gilden.zauberer
~#! tid=1043156107
Zurueckblaettern, lesen.

-- 
Patryn

-----------------------------------------------------------------------------



Re: Re:  Re: Diskussion (Zwirion, 22. Jan 2003, 11:22:03):
~#! rn=Orktoeter rt=1043168572 rg=schmarrn
~#! tid=1043168066
Beim Thema Schutzzauber sollte man nicht vergessen, dass die Zauberer auch
noch 2 Zauber haben, die starke zusaetzliche Schutzwirkung haben, naemlich
Schattenkaempfer und Schmerzen. Gegen heftige Einzelmonster ist deren Wirkung
viel staerker als der beste Schutzzauber (natuerlich immer sofern der NPC
nicht gerade den Zauber abwehrt oder Schatten einfach ignoriert...)
                                                               zwirion

-----------------------------------------------------------------------------



Re^3:  Re: Diskussion (Vector, 22. Jan 2003, 16:14:29):
~#! rn=Zwirion rt=1043230923 rg=gilden.zauberer
~#! tid=1043168066
solange jeder im mud "schmerzen" casten kann --sogar besser
als zauberer, weil es nicht misslingt-- sollte man das nicht
als argument gegen staerker schutzzauber bringen.

bei staerkeren schutzzaubern denke ich jedoch zuerst
an kaempfer, die von den X-ties optimierte huellen
bekommen und geruestete adamanthemden tragen.

arks idee mit der einstellbaren schutzhhuelle a la
<schutzhuelle 25> waere doch die ein oder andere
ueberlegung wert.

-----------------------------------------------------------------------------



Re^4:  Re: Diskussion (Hisasul, 22. Jan 2003, 16:16:57):
~#! rn=Vector rt=1043248469 rg=gilden.zauberer
~#! tid=1043168066
Sagte Patryn nicht dass geruestete Sachen im Moment sogar fuer Zauberer selbst
sehr wenig (Nahe null?!?) bringen. Dann wird das fuer Kaempfer wohl garnichts
bringen und die Huelle ist auch nur noch fuers gute Gefuehl da seit da der Bug
entfernt wurde, also bitte erst nachdenken, dann rumheulen :)

His*

-----------------------------------------------------------------------------



Re^5:  Re: Diskussion (Vector, 22. Jan 2003, 16:18:45):
~#! rn=Hisasul rt=1043248617 rg=gilden.zauberer
~#! tid=1043168066
>also bitte erst nachdenken, dann rumheulen :)
ganz genau so isses.
soll ja leute geben die lesen die artikel ihrer vorredner
ehe sie sich in eine diskussion werfen. du scheinst nicht
dazu zugehoeren, also gehe ueber los und lies mal mal nach,
was bisher zu dem thema kam.

-----------------------------------------------------------------------------



Re^6:  Re: Diskussion (Hisasul, 22. Jan 2003, 16:24:14):
~#! rn=Vector rt=1043248725 rg=gilden.zauberer
~#! tid=1043168066
wenn du meinst dass das _nach_ einer Aenderung der Schutzzauberstaerke ein
Problem sein koennte, glaube ich dass du dir hier ausnahmsweise mal keine
Sorgen machen musst. Die magiebegabtheit der Trves ist ja weitlaeufig bekannt.
Da gibts schoene Multiplikatoren die das schon anpassen. Jetzt darf ich aber:
umsonst geheult!

His, sich verbessernd

-----------------------------------------------------------------------------



Re: Diskussion (Sou, 22. Jan 2003, 18:14:35):
~#! rn=Patryn rt=1043156107 rg=gilden.zauberer
~#! tid=1043156107
Ich finde die Intention, die Zaubigilde schoener zu machen zunaechst ein mal
gut.
Du hast mir ja vorgeworfen gegen jede Aenderung zu sein ...
Hier ein paar Vorschlaege:
1. Ruestungen fuer Zaubis (fast) wegnehmen.
2. Schutz der Zaubis verbessern (auch auf Teammitglierder, solange der Zaubi
mit im Raum ist)
3. Dem Zaubi die Hand abhacken, dafuer
4. wegen mir mehr Power in die Spells legen

Gut dann koennen wir auch die Kaempfer veraendern ...
1. Das ewige wegstecken der Waffen und Ruestungen abklemmen ... 
   a.) Entweder, ganz (halte ich fuer bedenklich, weil das Dynamik und somit
Spielspass nimmt)
   b.) Dass man Zweihandwaffen kurzfristig in einer Hand halten kann (fuer
eine Finte oder einen Schildstoss)
2. Man koennte dann auch ueberlegen Magie ausweichen - ein beliebter
Moserpunkt - abzuschwaechen, man hat ja den    Schutz des hilfsbereiten
Zauberers :O)

Fazit: Mein Wunsch waere es, die Gilden unterschiedlicher zu machen. Aber auch
von einander abhaenig ... einen gut geruesteten Ritter sollte ein Zaubi
vielleicht schlechter erlegen koennen, als ein Kaempfer - dafuer sollten die
Kaempfers bei magischen Wesen schlechter aussehen.
Zusammen sollten sie sich ergaenzen, zaubi spendet Schutz (der was bringt) und
Feuert wenige - dafuer maechtige Sprueche ab, Kaempfers kriegen bei magischen
angriffen (ohne Zaubischutz) noch mehr auf die Fresse, dafuer machen sie dann
kontnuierlich Schaden, und "beschuetzen" den Zaubi gegen mechanischen Schaden,
indem sie sich dazwischen stellen.

Sou zeifelt nur daran, dass solche Vorschlaege wirklich umsetzbar sind :)

-----------------------------------------------------------------------------



Re^3:  Re: Diskussion (Sou, 22. Jan 2003, 18:21:59):
~#! rn=Orktoeter rt=1043180222 rg=gilden.zauberer
~#! tid=1043168066
Dauerspell faend ich ne gute loesung ... bei jedem Angriff, den das ding
Abwehrt den Prozentsatz der schwaechung des Spells als KP abzug ... wegen mir
durch 2. :)

Fuer Sou war die Huelle eine Ruesung.

-----------------------------------------------------------------------------



Re^12: Diskussion (Sou, 22. Jan 2003, 18:38:11):
~#! rn=Ark rt=1043186615 rg=gilden.zauberer
~#! tid=1043156107
LOL - nette idee. Ich finde das sollte in eine SpecialItem gespeichert werden,
dass man immer wieder laden kann, aber sich auch austauschen - biete
Schattenchip, suche Saeurechip oder so

Sou lacht sich schlapp, ist aber begeistert.

-----------------------------------------------------------------------------



Re^5: Diskussion (Sou, 22. Jan 2003, 18:39:32):
~#! rn=Grimmborn rt=1043188685 rg=gilden.zauberer
~#! tid=1043156107
Hm ne, kann ich nicht zustimmen ...

Sou ist Shizo.

-----------------------------------------------------------------------------



Re^4:  Re: Diskussion (Madness, 23. Jan 2003, 10:27:10):
~#! rn=Sou rt=1043256119 rg=gilden.zauberer
~#! tid=1043168066
Also ich kann mich noch nicht so richtig damit anfreunden das der/die
Schutzsprueche dauerthaft oder pro abwehr kps kosten.
So wie ich das sehe wuerde das zuviele Kps immer kosten, vor allem wen pro
kampfrunde kps abgezogen wuerde.
Bei mehreren NPCs wuerde man sofort ohne Kps dahstehen und das wuerde ja bei
einem Zaubi ohne/kaum ruestung den Tot bedeuten.
Dann koennte man das gleiche bei den Kaempfer bei SChlange und Co einfuehren.
Das ist auch nen 'Schutzskill' der eigentlich auch Konzentration braeuchte den
beizubehalten.

Madness, ist fuer keine Aenderung am Schutzverhalten.

-----------------------------------------------------------------------------



Re^5:  Re: Diskussion (Karima, 23. Jan 2003, 10:35:35):
~#! rn=Madness rt=1043314030 rg=gilden.zauberer
~#! tid=1043168066
Naja..
Bei Karateka ist es afaik doch auch so, dass die Abwehren / Angriffe KP
kosten.. (jedenfalls bei meinem Kleinen) Und da klappt das ja auch noch..

-----------------------------------------------------------------------------



unterstuetzung (Patryn, 23. Jan 2003, 14:41:55):
Wie schauts nun aus, bisher scheint mir das recht unentschieden zu sein.
Ich bin also fuer Unterstuetzungen raus, das hiesse, der Success wird
allgemein wieder auf fruehere Werte angehoben, was in etwa einer guten
Unterstuetzung von heute entspricht.
Man erreicht wohl nicht ganz das Maximum was derzeit drin ist, aber die
meisten Spells sind eh gedeckelt.
Ruestungen muessen wieder explizit gekennzeichnet werden um nicht zu
behindern, ausser Umhaenge und so.
Anpassung wird also wieder wichtig, Rueste wird wieder gehoben um den
Verlust ausgleichen zu koennen, macht auch wieder Sinn, aber das weitergeben
geruesteter Sachen wird beschraenkt.
Evtl. muss dann noch schutz etwas angehoben werden, weil Rueste auch mehr
auf magische Abwehr gehen koennte, aber Schutzhuelle sollte bleiben koennen.
Mit nem normalen Rueste sollte auch das Nacktheit durch Huelle loesen nicht
wirklich ein Problem sein.
Bisher kann ich keine eindeutige Meinungstendenz ausmachen.
Auf jeden Fall werden zukuenftig Unterstuetzungen durch das Balanceteam
kkwer
abgesegnet und nicht mehr durch mich. Wenn weiter Unterstuetzungen,
dann wird man ab sofort dort drauf achten, dass das nicht ausufert.

-- 
Patryn

-----------------------------------------------------------------------------



Re^5:  Re: Diskussion (Seleven, 23. Jan 2003, 16:26:21):
~#! rn=Madness rt=1043314030 rg=gilden.zauberer
~#! tid=1043168066
Na ja, es ist fuer mich halt logisch, dass man einen Zauber aufrecht erhalten
muss, und wie schnell deine KPs  ausgehen solltest Du als Seher sehen. Das bei
den Kaempfern fuer die Techniken einzufuehren halte ich fuer keine so
schlechte Idee. Wuerde ich aber geringer ansetzen, als eine Huelle.

S11s Meinung. (Danach wurde gefragt, oder?)

-----------------------------------------------------------------------------



Re^6:  Re: Diskussion (Vector, 23. Jan 2003, 17:36:01):
~#! rn=Seleven rt=1043335581 rg=gilden.zauberer
~#! tid=1043168066
OK dann mal meinen Senf.
Prinzipiell ist es natuerlich wuenschenswert, und kommt der
Idee der Zauberergilde naeher, wenn diese Ruestungslos rum-
laufen.
Jedoch muss ich mich als aktiv-spielender Erstie dagegen
aussprechen. Derzeit ist es leider so, dass jeder dahergelaufene
X-tie 95% oder mehr der Zaubererstaerke ausreizen kann. Ich 
sage nicht, dass ich eine Kaempferloesung haben moechte, und
dass die Level dermassen unverschaemt viel eingehen soll.
Jedoch unterstuetzen viel zu wenig Monster so schoene
Sprueche wie stille, rausch, erschaffe, und erzwinge; 
das uebliche hand, schnell, schattenkaempfer reicht aus.

Die einzige Moeglichkeit sich von dem --mit Verlaub unwissenden--
Zweities metzeltechnisch abzuheben, ist eben, dass man sich
Ruestungen zulegt, die fuer den Durchschnittszweitie zu viel
Aufwand sind. Und als Erstie goenne ich es mir dann doch selber
eine bessere Huelle dank Asaniels Gewand zu haben, als ein Zweitie,
der eben nur mit Feuerpanzer oder Eisschamenenpanzer ausgeruestet ist.

Nun denn, stellen wir uns einen Zauberer mit einem Minimum an Ruestung
vor. Da wurde die Problematik bereits von Vardion und Goethe angesprochen,
auf der einen Seite meint jeder Wurst-NPC, Huellen aufloesen zu muessen,
und den Zaubi mit einer Anti-Huelle belegen zu koennen, auf der anderen
Seite sind heute eben Monster aktuell, die gewaltigen Mischschaden austeilen.

Ob es der Weissheit letzter Schluss sein kann, dass dann Zauberer eben mit
angepassten Feuerhosen und Kettenhemden rumrennen ist sicher Geschmacksache,
mich wuergt ein bisschen bei dem Gedanken.
Es liegt sicher auch an meinem Verfolgungswahn, dass mir beim Stichwort
"rueste" zuerst Kaempfer mit geruesteten Adamanthemden einfallen, nunja...
Vielleicht waere zu ueberlegen, dass Zauberer nur noch Schutz auf andere
sprechen koennen, die Schutzhuelle bleibt dem Zaubi vorbehalten.
Dann liese sich ein Ausgleich fuer das weniger an Ruestung durch ein
mehr an Schutzhuelle leichter realisieren.

Ok, Zusammenfassung des ganzen: Unterstuetzungen so lassen, wie bisher, 
eventuell sogar Gewichtigkeit aendern. Ohne Unterstuetzung nur noch 40%
des Maxschadens moeglich, mit der Ruestung --je nach Unterstuetzungsklasse--
bis 100%. Die Deckelung bleibt wie sie ist. Zauberer an sich muessen nicht
staerker werden, nur der Unterschied deutlicher zwischen unausgeruestetem 
Huellenzweitie und aktiv spielendem Erstie, der auch mal Tigonenamulett
und Asaniels Gewand holt.


--Vector--

-----------------------------------------------------------------------------



Re^7:  Re: Diskussion (Orktoeter, 23. Jan 2003, 17:43:13):
~#! rn=Vector rt=1043339761 rg=gilden.zauberer
~#! tid=1043168066
Also bislang wurde in dem ganzen Thread nur ein NPC erwaehnt der Huellen
aufloest und sogar Anti-Huellen verteilt, naemlich der Nagadrache. In jeder
mir bekannten Phantasyliteratur sind Drachen sehr maechtige und hochmagische
Wesen. Wer wenn nicht ein Drache sollte also so etwas machen koennen? Ganz
abgesehen davon das es eigentlich schon eine Frechheit ist, wenn man offenbar
so stark ist, dass man einen Drachen als "jeder Wurst-NPC" bezeichnen kann.

OrkT mag Drachen.

-----------------------------------------------------------------------------



Re^7:  Re: Diskussion (Seleven, 23. Jan 2003, 17:43:23):
~#! rn=Vector rt=1043339761 rg=gilden.zauberer
~#! tid=1043168066
Lieber Vector, meiner Meinung nach sollte das Level bei den Kaempfern noch
viel staerker einfliessen, (GL 24 - sollte es je kommen - ab Spielerstufe 70+)
...
'das uebliche hand, schnell, schattenkaempfer reicht aus.' ->
Sag ich doch: Hand ab! Spells hoch.

'die Schutzhuelle bleibt dem Zaubi vorbehalten' ->
Wieso nicht wie Rueckendeckung ab einem bestimmten Skillwert?

Zu Huellenaufloesenden NPCs ->
Es gibt auch genug, die einem zum ausziehen aller Sachen zwingen. Da helfen
IMHO leider nur Trigger.

S11 spendet Senf.

-----------------------------------------------------------------------------



Re^8:  Re: Diskussion (Vardion, 23. Jan 2003, 17:47:14):
~#! rn=Seleven rt=1043340203 rg=gilden.zauberer
~#! tid=1043168066
Ausziehen aller Sachen und Huelle aufloesen sind nicht aequivalent. Die Sachen
kann ich per Trigger sofort alle wieder Anziehen - bei der Huelle muss ich das
wegen Spelldelay mit anderen Spells abgestimmt werden. Bekommt man Paracelsus'
bekloppte Antihuelle noch drauf, darf man dann erstmal rausgehen und warten,
bis die abklingt.

Vardion

-----------------------------------------------------------------------------



Re^8:  Re: Diskussion (Orktoeter, 23. Jan 2003, 17:47:48):
~#! rn=Seleven rt=1043340203 rg=gilden.zauberer
~#! tid=1043168066
"Es gibt auch genug, die einem zum ausziehen aller Sachen zwingen. Da helfen
IMHO leider nur Trigger." Schade dass du das so siehst. Ein NPC der eine
solche Faehigkeit besitzt hat gerade gegenueber Kaempfern natuerlich einen
sehr maechtigen Spell, nur machst du den mit dem Trigger/Anziehscript
zunichte. Damit nimmst du quasi den Magiern eine elegante Moeglichkeit einen
NPC zu proggen, der in erster Linie den Kaempfern das Leben schwer macht.
(vielleicht sollten die Magier die solche NPC geproggt haben gleich noch etwas
nachbessern und das wiederanziehen erst nach einer gewissen Zeit erlauben).

OrkT mag auch Magier (manchmal)

-----------------------------------------------------------------------------



Re^8:  Re: Diskussion (Mandragon, 23. Jan 2003, 17:48:24):
~#! rn=Orktoeter rt=1043340193 rg=gilden.zauberer
~#! tid=1043168066
Wenn Du nur einen kennst, ist das Dein Problem. Das es auch andere gibt, ist
das der Zauberer. Magst Du Dich vielleicht irgendwoanders austoben???

Ma* (allmaehlich genervt)

-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Seleven, 23. Jan 2003, 17:48:44):
~#! rn=Vardion rt=1043340434 rg=gilden.zauberer
~#! tid=1043168066
Wenn Sou seine Sachen alle auszieht, ist er in der naechsten Runde draussen.
:)

-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Seleven, 23. Jan 2003, 17:50:36):
~#! rn=Orktoeter rt=1043340468 rg=gilden.zauberer
~#! tid=1043168066
Deswegen sag ich leider. Und die Idee mit delay finde ich Ok. - S11

-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Pitfall, 23. Jan 2003, 17:52:22):
~#! rn=Vardion rt=1043340434 rg=gilden.zauberer
~#! tid=1043168066
fast vardion, fast
es gibt auch bei den kaempfern durchaus techniken die man nicht mehr einsetzen
kann wenn einem der npc *point schreckensdrache, , , , * z.b. die waffe aus
der hand haut.

-----------------------------------------------------------------------------



Re^10:  Re: Diskussion (Cuchullin, 23. Jan 2003, 17:53:30):
~#! rn=Seleven rt=1043340636 rg=gilden.zauberer
~#! tid=1043168066
Es waere mir sehr recht, wenn die allwissenden Gildenfremden ihre
geschaetzte Meinung wenigstens in einem einzelnen Artikel die letzten
anderen Postings zusammen behandelnd abgeben wuerden. Der inhaltliche
Muell mancher Mitredenden (subjektive Einschaetzung) nervt schon genug,
Aber wenn ich dann zu zwei, drei, vier Zweizeilern erst wieder den
Bezugsartikel lesen muss, um entscheiden zu koennen, ob der Inhalt
jetzt Muell oder einfach nur undurchdacht ( =;o) ) ist, ist das
SEHR nervzehrend.

Etikette ende,
YTCu

-----------------------------------------------------------------------------



Re^8:  Re: Diskussion (Madness, 23. Jan 2003, 17:54:28):
~#! rn=Seleven rt=1043340203 rg=gilden.zauberer
~#! tid=1043168066
Ausnahmsweise muss ich Vector mal zustimmen, so ihn etwa wuerde ich mir das
auch wuenschen.
Und ich muss Seleven nur zustimmen: Hand ab! Lieber mehr Sprueche pro Runden
sprechen lassen.
Wobei das ganze nur einen Nachteil hat: Die schoene Extrahand wird dadurch
vollkommen ueberfluessig.
Wobei man aber auch gut die Anzahl der Haende in die Staerke oder die Anzahl
eines Spruchs einbeziehen koennte.

Zu OrkT.:
Nur ein NPC loest huellen auf? Dann biste aber kaum rumgekommen.
Ich kann kann dir da mehrere, vor allem fuer Zaubis wichtig, NPCs aufzaehlen.

Zu Seleven:
Na und? Dann triggerste das halt mit dem Ruestungen nehmen. Aber wir Zaubis
muessen warte bis sich die Anti-Huelle aufgeloest hat.

Madness, will seine Extrahand behalten!

-----------------------------------------------------------------------------



Re^7:  Re: Diskussion (Olli, 23. Jan 2003, 17:55:18):
~#! rn=Vector rt=1043339761 rg=gilden.zauberer
~#! tid=1043168066
Was ich als aktiv spielender Erstie dann, der sich nicht "mal eben"
das Tigonenamu oder Asaniels Gewand holt?

Olli, ist anscheinend eh ne Wurst.

-----------------------------------------------------------------------------



Re^8:  Re: Diskussion (Miril, 23. Jan 2003, 17:58:02):
~#! rn=Olli rt=1043340918 rg=gilden.zauberer
~#! tid=1043168066
Weiter oben las ich was von unwissenden Zeities, die dann genauso
stark sind. Vielleicht waer es ja mal ne generelle Ueberlegung wert,
die Skills auch FP abhaengig zu machen. Nur, damit die Weisen unter
euch auch mehr koennen, als irgendein hochgeskripteter Zweitie.

Nur ne Idee, kam mir so spontan und stoesst vermutlich auf
wenig Gegenliebe.

Miril

-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Seleven, 23. Jan 2003, 18:01:59):
~#! rn=Miril rt=1043341082 rg=gilden.zauberer
~#! tid=1043168066
Na ja, FPs dafuer, dass man staerker metzeln kann?
Mein Vorschlag ist Stufe allgemein. Dann kann jeder Spieler selber
entscheiden, ob er metzeln oder forschen will. 

S11 mal Cuch* weiter aufregend. ;>P

-----------------------------------------------------------------------------



Re^10:  Re: Diskussion (Goethe, 23. Jan 2003, 18:02:21):
~#! rn=Croft rt=1043341246 rg=gilden.zauberer
~#! tid=1043168066
bitte bei den Kaempfern nicht einbaun, forschen und Gilde soll schoen getrennt
bleiben.

G

-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Vardion, 23. Jan 2003, 18:02:25):
~#! rn=Miril rt=1043341082 rg=gilden.zauberer
~#! tid=1043168066
Was haben FPs mit Wissen ueber die Gilde zu tun?

Vardion

-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Orktoeter, 23. Jan 2003, 18:02:49):
~#! rn=Madness rt=1043340868 rg=gilden.zauberer
~#! tid=1043168066
 Ich habe nicht behauptet das es nur einen solchen NPC gibt, ich habe nur
gesagt das bislang in diesem Thread nur ein NPC erwaehnt wurde und dass dieser
von der Beschreibung in meinen Augen jedes Recht zu maechtigen Zauberspruechen
hat.

Uebrigens werte ich auch dein "Ich kann kann dir da mehrere, vor allem fuer
Zaubis wichtig, NPCs aufzaehlen." nicht als weitere NPC.

OrkT.

-----------------------------------------------------------------------------



Re^10:  Re: Diskussion (Goethe, 23. Jan 2003, 18:06:44):
~#! rn=Orktoeter rt=1043341369 rg=gilden.zauberer
~#! tid=1043168066
Wobei sowohl wenn FP in die Skills eingehen wuerden das sicher zu Listen u.ae.
fuehren wuerde, als auch wenn das  Level allgemein beruecksichtigt wird dies
nur noch mehr zu Scripten und Toplistengeilheit fuehren wuerde. Muss also echt
nicht sein, wobei die gesammten Stufenpunkte noch das kleinere Uebel waeren.

G

-----------------------------------------------------------------------------



Re^14:  Re: Diskussion (Miril, 23. Jan 2003, 18:07:48):
~#! rn=Croft rt=1043341622 rg=schmarrn
~#! tid=1043168066
Ich seh schon, ich glaube noch zuviel an das Gute im Spieler.

-----------------------------------------------------------------------------



Re^15:  Re: Diskussion (Goethe, 23. Jan 2003, 18:11:48):
~#! rn=Miril rt=1043341668 rg=gilden.zauberer
~#! tid=1043168066
Glaubst Du das auch noch wenn eine halbe Stunde nach Anschluss einer Quest ein
Komplettscript fuer selbige im Umlauf ist? Ausserdem gibts heutzutage genug
"intelligente" Scripte die die noetigen Stufenpunkte dann wahlweise per
metzeln (XP), Skillscripte (Gildenstufenpunkte), EK-Ablaufpakete sowie
Untersuchescripte zusammenkratzen.


-----------------------------------------------------------------------------



Re^10:  Re: Diskussion (Asuka, 23. Jan 2003, 18:12:34):
~#! rn=Orktoeter rt=1043341369 rg=gilden.zauberer
~#! tid=1043168066
Mensch Orktoeter, wenn Du nichts konstruktives zu dem Thema beisteuern
kannst, dann sei gefaelligst ruhig.
Aber das ist wohl wirklich zuviel verlangt.

Und damit wenigstens meine Meinung hier drin steht:
Mir gefaellt die Idee das die mittlerweile stiefmuetterlich-
lich behandelten Sprueche wie rueste und eventuell auch anpassung
wieder mehr Bedeutung erlangen.

Das damit Aenderungen an den bestehenden Ruestungskonzept heinhergehen
kann ich, wenn der Ausgleich entsprechend ist, durchaus verkraften.


Asuka

Asuka



-----------------------------------------------------------------------------



Re^11:  Re: Diskussion (Patryn, 23. Jan 2003, 18:57:07):
~#! rn=Asuka rt=1043341954 rg=gilden.zauberer
~#! tid=1043168066
Vielfalt kann man auch durch die Entscheidungsfindung gewinnen,
welche Ruestungich wo anziehe, die Abwaegung zwischen Schutz und
Behinderung...etwas worueber man sich frueher mal nen Kopp machen musste.
IMHO eine lokalere Abwaegung als ein "Welches Standardset fuer
 Unterstuetzungen hast Du denn?"

-- 
Patryn

-----------------------------------------------------------------------------



Re^10:  Re: Diskussion (Foobar, 23. Jan 2003, 19:00:10):
~#! rn=Orktoeter rt=1043341369 rg=gilden.zauberer
~#! tid=1043168066
Orktoeter,

Deiner Meinung nach kann ich also irgendwo einen NPC namens "Drache"
hinstellen, der dann einen HitPoint hat und nocht nicht mal eine Kakerlake von
der Hochebene kratzt, aber Zaubi-Huellen aufloesen kann weil er ja
schliesslich ein Drache ist?

Foobar


-----------------------------------------------------------------------------



Re^11:  Re: Diskussion (Elberet, 23. Jan 2003, 19:05:17):
~#! rn=Goethe rt=1043341341 rg=gilden.zauberer
~#! tid=1043168066
wieso? also ich find den gedanken schoen, dass forschen auch belohnt wird. Ich
mein (das ist jetzt an die allgemeinheit gesprochen und nicht auf jemanden
persoenlich) Wissen ueber Ausruestungsgegenstaende und Taktiken kann man
weiter geben, fps nicht so richtig. Somit garantieren fps wenigstens zu einem
gewissen Grade, dass man sich den Vorteil selber erarbeitet hat.

Elbi (Dummschwaetzer von Beruf)

-----------------------------------------------------------------------------



Re^12:  Re: Diskussion (Legas, 23. Jan 2003, 19:22:01):
~#! rn=Patryn rt=1043344627 rg=gilden.zauberer
~#! tid=1043168066
Hmm.. sowohl Vectors Argument mit den Unterschieden zwischen 0815 Wuersten
(wie mir) und echten Zauberern, als auch Patryns Argument mit der
Entscheidungsfindung haben was fuer sich.
Darum mal folgener Vorschlag: Es unterstuetzen nur noch Ringe und Amulette
(und nicht so, das jedes Item auf nur einen Zweig spezialisiert ist). Es also
z.b: Angriff/Beherrschungsringe, aber z.b. auch Angriff/Hellsichtamulette
gibt. Der Vorteil: der Wunschzustand wie Zauberer sein sollen, kommt dem
wieder naeher. Es bleibt Spielraum zum ruesten und anpassen _aber_ auch Zaubis
muessen sich weiterhin ausruesten und noch mehr als bisher sich vor Kaempfen
darauf einstellen (zusaetzlich auch noch durch die Wahl der gewuenschten
Unterstuetzungen). Dazu kommt natuerlich noch, das magische Unterstuetzung von
Ringen und Amuletten auch irgendwie stilistisch schoener ist. Alternativ
koennte die Unterstuetzung auch von Objekten ausgehen, die man an seinem
Zauberstab befestigen kann. Ich faende es jedenfalls sehr sehr Schade wenn das
Konzept der Unterstuetzung, das eine differenzierung zwischen den Zaubis
bewirkt, aufgegeben wuerde.

Legas

-----------------------------------------------------------------------------



Re^13:  Re: Diskussion (Cuchullin, 23. Jan 2003, 20:02:20):
~#! rn=Legas rt=1043346121 rg=gilden.zauberer
~#! tid=1043168066
Hoffnungslos Unsinn.

YTCu

-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Ark, 23. Jan 2003, 21:08:03):
~#! rn=Vardion rt=1043340434 rg=gilden.zauberer
~#! tid=1043168066
Wuerde einer mal jemand den Widerspruch zwischen "interessanten,
herausfordernden Monstern" und "baeh, die machen meinen Schutz kaputt, ziehen
mich aus, etc." mal loesen?
Ja klar, man kann bestimmte Gilden ueber Gebuehr aergern mit immer gleichen
Kampf"taktiken", aber was wollt ihr nun, Abwechslung oder Stupse/EPs abideln?


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Ark, 23. Jan 2003, 21:10:15):
~#! rn=Miril rt=1043341082 rg=gilden.zauberer
~#! tid=1043168066
Stoesst eher auf weiterentwickelte und detailliertere FP Listen und
Magier-Lookup-Devices *seufz*


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^16:  Re: Diskussion (Mupfel, 23. Jan 2003, 23:18:15):
~#! rn=Goethe rt=1043341908 rg=gilden.zauberer
~#! tid=1043168066
Woher weisst Du denn das? Hast Du selbst solche Scripte? Mail mir doch mal
eins ;)


-mupfel-

-----------------------------------------------------------------------------



Re^10:  Re: Diskussion (Vardion, 24. Jan 2003, 00:46:08):
~#! rn=Ark rt=1043352483 rg=gilden.zauberer
~#! tid=1043168066
So, jetzt mit korrekter Referenz...

Man sollte ja meinen, dass sich ein Magier zu jeder Aktion, die er in einen
NPC einbaut, irgendetwas denkt. So z.B. auch, wie die Spieler darauf reagieren
werden.
Nun, was denkt sich ein Magier, der einen Huellenumkehrer in seinen NPC baut,
wie der Spieler darauf reagieren soll? Er kann wohl kaum erwarten, dass
selbiger im Raum bleibt und in den naechsten 2 Runden den Exitus erleidet.
Darauf gibts es nur die Reaktion der Flucht. Und da dies umgehend erfolgen
muss, natuerlich per Trigger/Client. Also sonderlich spannend finde ich das
nicht.
Interessant sind doch eher Aktionen, auf die der Spieler mehrere moegliche
Reaktionen hat und nicht nur zwangsweise eine einzige bleibt.
Es gibt doch nun wirklich genug Sachen, die einen NPC vom langweiligen
/std/npc abheben. Sei es nun das Wechseln von Anfaelligkeiten, aendern der
eigenen Kampftechnik/Angriffsart, Beschwoeren von Helfern, ordentlicher
Teamkampf von mehreren NPCs... seid doch mal kreativ :-)

Vardion

-----------------------------------------------------------------------------



Re^11:  Re: Diskussion (Orktoeter, 24. Jan 2003, 08:45:34):
~#! rn=Vardion rt=1043365568 rg=gilden.zauberer
~#! tid=1043168066
Ah, das MG ist also ein SUD? Du musst sofort (und per Trigger) fliehen, wenn
du auf einen solchen Gegner triffst? Du kannst nicht schon im vorhinein deine
Chancen dadurch verbessern das du nicht alleine hingehst? 
Ausserdem ist da immer noch das Argument das eben manche NPC fuer bestimmte
Gilden schwerer sein sollen. Das ist ganz im Sinne des Erfinders. Wenn es eine
Gilde gibt die alle Gegner bequem umhauen kann moeglichst noch ohne eigenes
Risiko dann wird es nur wenige Enthusiasten geben die noch in den anderen
Gilden spielen.

OrkT, langsam wirklich dafuer das Zauberer das Hand weggenommen und dafuer die
Faehigkeit jammern bekommen... (entwerder das macht Laermschaden bei den NPC
oder Nervschaden oder die NPC werden einfach ganz mitleidig (alle Angriffe nur
noch 1/10 der normalen Staerke, damit es dem armen Zauberer auch nicht weh
tut).

-----------------------------------------------------------------------------



Re^12:  Re: Diskussion (Patryn, 24. Jan 2003, 10:11:42):
~#! rn=Orktoeter rt=1043394334 rg=gilden.zauberer
~#! tid=1043168066
Du bist ein Troll, permanentes Ignorieren von Argumenten anderer und das
Wiederholen von Bloedsinn zeichnet Dich im insbesonderen Masse aus.
Im uebrigen stellst Du Dir oft genug selbst ein Bein, die von Dir
im oberen Absatz beschriebene Gilde gibt es, schau mal in den Spiegel.
Das mit der 'Hand' hab ich Dir auch schon ungefaehr 10 trillionen Mal
erklaert, wir stehen wenigstens dazu, dass sie ein Fehler ist der zu
aendern ist, zu was genau steht eine gewisse Gilde ausser zum Aussitzen und
Ableugnen...

-- 
Patryn

-----------------------------------------------------------------------------



Diskussion - noch n Kommentar (Rangorn, 24. Jan 2003, 20:17:52):
Als gefrustete Ex-Zauberine, die der Gilde aeusserst enthusiastisch den
Ruecken kehrte, mal so Sachen, die ich mir in meiner Handwedellaufbahn
ueberlegte:

Hand ab. (Darueber waren wir uns ja fast schon einig, oder?)
Ein Zauberer kaempft nicht mit seinen Haenden. Allerdings haben Zauberer so
etwas wie Staebe. (Nein, ich rede jetzt nicht von diesem etwas merkwuerdigen
LotR-Duell). Ein ausgebautes Stabschadenskonzept waere schon klasse (nicht
direkt Schadensaufwertung, aber billiger im Anschmeissen). Auf diese Weise
waere ein Zaubi nicht voellig hilflos bei den inzwischen ach so beliebten
Spell-Defend.

Unterstuetzende Ruestungen .. nun, ich bin da wohl nicht ganz objektiv. Mir
waren sie schon immer ein Dorn im Auge. Asaniels Gewand ist eigentlich nicht
mal ebend leicht beschafft. Und gerade im Vorbeigehen nahm ich den
Eisschamanenpanzer fuer Zweities (? *huestel*) auch nicht mit. Trotz allem
sollte man das eigentlich schoene Konzept nicht wegwerfen. 
Aber etwas ausduennen waere nett. Fuer die letzten Prozente dann ebend ein
paar Amulette und Ringe (die durch Mischunterstuetzungen durchaus gleichwertig
sein koennen).

An Ruestungen sollte ein Zauberer nur leichte, nichtmetallische Sachen tragen.
(Rueste aufwerten). Metallene Sachen anpassen zu wollen ist in meinen Augen
ein Widerspruch.
Einen Vorteil, den ich in einer Wiederaufnahme des Rueste-Konzepts sehe, ist
die Wappnung gegen NPCs mit Mischschaden. Wird wohl allerdings die Praxis
zeigen.

Es waere auch schoen, wenn all die anderen Spells (rausch, stille zwingtanz)
einen erkennbaren Effekt haben wuerden. Aber das ist dann wohl eher Sache der
Magier, die sich einen NPC hinstellen. (Idee: nur besoffen kann man den
umhaun. ect.)

Schutzhuellenklauer: Wie bereits angesprochen waere eine "Vorwahnung" nett.
Also ein gemaechliches Aufloesen und keine Fingerschnippwegaktion. Ansonsten
gibt es halt Gegner, die man nicht (alleine) haut. Muss man ja auch nicht.
Vielleicht hab ich deswegen nie die Topausruestungen an. :o)

- Rangorn Khur'Tigres - - - wurstet

-----------------------------------------------------------------------------



Re^7:  Re: Diskussion (Gnome, 24. Jan 2003, 22:39:59):
~#! rn=Vector rt=1043339761 rg=gilden.zauberer
~#! tid=1043168066
fast dafuer.
90% aller unterstuetzungen sollte man abklemmen. dadurch kriegen rueste
und schutz wieder einen sinn, weil ein grosser teil der 90% fuer zaubis
dann schlichtweg nicht mehr nutzbar sind. das waere - zum grossen teil -
patryns vorschlag.

die restlichen 10% koennen die unterstuetzung behalten. das sollten
dann aber dann wirklich schwer zu holende sachen sein UND es sollte
sinn machen, was sie unterstuetzen. tigamu und asagewand sind da
gute beispiele. damit koennte sich dann a) der 1tie-zauberer von der
grauen masse abheben, b) haetten diese gegenstaende noch ihre
daseinsberechtigung. wer wuerde sich asaniels gewand sonst noch holen?

@orktoeter:
*seufz* bitte... uffz... was soll man da sagen? *verzweifel*
geh doch erstmal deinen ersten ork toeten, ja? :)

@sou:
reduziere deine artikel bitte auf 0,3*n, dafuer schreib mehr informationen
rein... das waere toll. :)

@ark:
huellen aufloesen, sachen ausziehen lassen, teams aufloesen...
das ist nicht herausfordernd, sondern einfach nur nervig.
wenn einem als magier nichts besseres einfaellt... naja.

gnOme, i. A.

-----------------------------------------------------------------------------



Re^8:  Re: Diskussion (Amaryllis, 24. Jan 2003, 22:43:44):
~#! rn=Gnome rt=1043444399 rg=gilden.zauberer
~#! tid=1043168066
Ich kenne die Zaubis nur wenig, aber bezueglich Deines Kommentars zu Ark
("wenn einem nix besseres einfaellt"):

Dann sollte man sich vielleicht mal ueberlegen, _warum_ manchen nichts mehr
besseres einfaellt.
Und nein, ich meine das jetzt gilden/balance-allgemein, nicht nur
zaubi-spezifisch.

Ama*

-----------------------------------------------------------------------------



Re^8:  Re: Diskussion (Madness, 24. Jan 2003, 22:52:07):
~#! rn=Gnome rt=1043444399 rg=gilden.zauberer
~#! tid=1043168066
Ich mchte mal 2 Punkte ansprechen:
1. Die Sachen mit den reduzieren der Unterstuezung auf Sachen wie Asaniels
Gewand:
Ich spreche hier als Erstie und ich finde das diese Vorschlaege |bertrieben
sind. Um so eine Ruestung/Gegenstand zu holen bedarf es ein Team und nicht
jeder hat auf solche Aktionen Lust oder Zeit.
Und komisch ist doch, das solche Vorschlaege meist nur von Kaempfer kommen.
Dann sollten auch deren Guten Waffen reduziert werden und nur von richtig
Starke NPCs bewacht werden und nicht ala Aetzaxt mal ebend so zu holen sein.
Ich finde das sowas die zu stark Erschwert. Evtl sollte man eher hingehen und
ein paar richtig gute Unterstuezungen einbauen die dann 120% oder mehr
bringen. Diese koennten ruhig dann begrenzt sein.
Wie bei Kaempfer z.B. der VS, der einen schlieslich nen (meiner Erfahrung
nach) KOSTENLOSES Todesstoss ermoeglicht.

2. Was mich persoenlich interessiert ist, was nach dem 'Hand ab' mit Extrahand
passiert.
Ich kenne zwar kein Buch, wo ein Zauberer ne dritte Hand hat, aber ich finde
das sowas die Zaubis nen gewissen Touch gibt.
Evtl Kann man ja die Anzahl der Sprueche oder die Staerke ja Hand-Anzahl
abhaengig machen.

Madness, will gerne seine Extrahand behalten! ;)

-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Gnome, 24. Jan 2003, 23:01:24):
~#! rn=Madness rt=1043445127 rg=gilden.zauberer
~#! tid=1043168066
warum denn nicht?
wenn du als zauberer das gewand haben moechtest, trommel nen team
zusammen und legt los. ansonsten musst du halt mit 'normalem' schutz
weiterzaubern.

was die guten waffen betrifft: sofort dafuer. ehrlich.

und btw: JEDER hat nen kostenlosen todesstoss mit dem VS. ;-)

gnOme, i. A.

-----------------------------------------------------------------------------



Re^10:  Re: Diskussion (Vector, 24. Jan 2003, 23:37:07):
~#! rn=Gnome rt=1043445684 rg=gilden.zauberer
~#! tid=1043168066
Erwaehnte ich bereits, dass ich gegen "hand ab" bin?
Das die Komponentenhand nicht das Gelbe vom Ei ist,
und eine Aenderung her muss, ist klar.
Jedoch bin ich als Spieler erst bereit, diese aufzugeben,
wenn man mit _gleichzeitig_ Alternativen gibt.
Nicht nach dem Motto: Erstmal Hand ab und dann sehen wir weiter.
Die Komponentenhand wird Hand in Hand (schoener Satz, gell)
mit dem SpellDefend verschwinden.
Und noch zu den unterstuetzenden Ruestungen, da jetzt schon
einige meinen Post diesbezueglich falsch verstanden haben:
Keiner behauptet, dass Sachen wie Tigonenamulett oder Asaniels
Gewand mal eben fuer jeden Erstie leicht zu besorgen sind.
Es ging darum, das ein Erstie bereit ist, mehr Zeit und Muehe
in Ausruestungsbeschaffung zu investieren, als ein Zweitie.
Und deshalb von der Tendenz besser ausgeruestet ist, sprich
Ruestungen hat, die besser unterstuetzen.
Das das immer im Verhaeltnis zu sehen ist, oder auch auf den
Erstie-Charakter des Zweities sollte sich von selbst verstehen.
Das ist ja auch nicht nur bei Zaubi-2ties so, den Kaempfer2ties
reicht es eben, wenn sie einen geschick+2 Ring haben, da fuehlt
sich kein X-tie zum Schreckensdrache berufen.
Oder wieviele Daemonen von Chaoten2ties sind im Besitz von Hand-
schuhen?!
Bei der Ausruestung trennen sich Erstie und Zweitie, Drittie, Xtie
recht deutlich; fuer mich also ideal, wenn dadurch auch in der 
Metzelstaerke ein Unterschied entsteht, und der Erstie eben
ein bissl besser zulangen kann, als der Xtie.
Deswegen weiterhin pro unterstuetzende Ruestungen.

--Vector--

-----------------------------------------------------------------------------



Re^11:  Re: Diskussion (Patryn, 24. Jan 2003, 23:39:06):
~#! rn=Vector rt=1043447827 rg=gilden.zauberer
~#! tid=1043168066
Die Kurzsichtigkeit, erst Hand ab und dann weiterschauen, traust Du mir
hoffentlich nicht zu. Dafuer hab ich die lange genug gegen frisch motivierte
Gildenbalancer verteidigt, die zumeist ind er Tat auch nicht so kurzsichtig
sind, dies vehement ohne gebuehrenden Ersatz zu fordern.

-- 
Patryn hat inzwischen einen gewissen Plan

-----------------------------------------------------------------------------



Re^11:  Re: Diskussion (Cuchullin, 24. Jan 2003, 23:43:26):
~#! rn=Vector rt=1043447827 rg=gilden.zauberer
~#! tid=1043168066
Halte ich fuer unpassend. Wenn Du "Premium Equipment" zugestehst, 
unterstuetzende Wirkung zu haben, wertest Du per se nicht nur die
gripslosen Zweitspieler ab, sondern auch die Zauberer-Ersties, die
nicht 12412414 Tage ins Ausruestungsbeschaffen stecken wollen bzw.
nicht das halbe Mud willig auf dem Fband haben. Ich wuerde mir nicht
die Beine fuer ein Tigonenamulett wundlaufen, dafuer habe ich nicht
die richtigen Scripts, das Fband fehlt mir dazu auch.

Es muss andere Moeglichkeiten geben, Wurst von Nichtwurst zu 
unterscheiden. Die Trves koennen's auch. Ab und zu kann man sich
auch als Zauberer ein Beispiel an der Konzeption nehmen.

YTCu

-----------------------------------------------------------------------------



Re^12:  Re: Diskussion (Patryn, 24. Jan 2003, 23:45:10):
~#! rn=Cuchullin rt=1043448206 rg=gilden.zauberer
~#! tid=1043168066
Mit hinreichend komplexen Spellkombos und Auswahlmoeglichkeiten nebst
Hand ab sollte diese Unterscheidung durchaus auch ohne Ausruestungsrennerei
machbar sein. Und das ist in meinen AUgen sehr Zaubererlike.

-- 
Patryn kontra Unterstuetzungen

-----------------------------------------------------------------------------



Re^12:  Re: Diskussion (Vector, 24. Jan 2003, 23:45:21):
~#! rn=Cuchullin rt=1043448206 rg=gilden.zauberer
~#! tid=1043168066
Wem Tigonenamulett zu viel Aufwand ist, kommt auch selten
zu den NPCs bei denen er das Amulett wirklich brauchen und
Ausreizen koennte oder? :)
Es muss ja auch kein Level-8-Zaubi meinen, dass man jetzt
Tigonenamulett braucht um Gardewaechter zu hauen.

-----------------------------------------------------------------------------



bug (Patryn, 25. Jan 2003, 02:17:32):
schutz sollte wieder normal gehen, versehentlich waren
unterstuetzungen 2 tage abgeklemmt durch eine umstellung.
 (schon lustig dass es nur an schutz bemerkt wurde *g*)
ein weiterer bug war seltene derbe patzer, die einen ueberlauf zur
hatten die den spell dorch gelingen liessen. also aufpassen, derbe patzer
koennten jetzt im gegensatz zu vorher wirklich welche sein, aber eh sehr
selten in der heftigsten patzerform.

-- 
patryn

-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Vardion, 26. Jan 2003, 22:57:16):
~#! rn=Madness rt=1043445127 rg=gilden.zauberer
~#! tid=1043168066
Kleine Anmerkung: der TS des VS hat nix mit dem der Kaempfergilde zu tun.
Letzterer ist deutlich staerker.

Vardion

-----------------------------------------------------------------------------



Re^10:  Re: Diskussion (Muadib, 27. Jan 2003, 00:38:31):
~#! rn=Vardion rt=1043618236 rg=gilden.zauberer
~#! tid=1043168066
vor allem wenn der npc eh nur noch 1 lp hat gell :)

-----------------------------------------------------------------------------



Re^8:  Re: Diskussion (Ark, 28. Jan 2003, 22:41:07):
~#! rn=Gnome rt=1043444399 rg=gilden.zauberer
~#! tid=1043168066
Mir faellt immer mal wieder was ein. Allerdings haengt es dann oft an der
Nichtumsetzbarkeit (Spieler verwandeln, nicht Froesche :-) ) oder
Barmherzigkeit (Spieler bezaubern, _komplette_ Beherrschung) oder
Selbsterfahrung (Spieler versteinern, siehe uralte MPA Artikel .-) ).
Tja, und zum Schluss kommen halt dann meist Sachen raus, die keinen Spieler
wirklich reizen, oder? ;-) M.a.W. bei denen man schon fast erwartet, nicht
mehr zu sterben, wenn man den Gegner einmal geschafft hat.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^9:  Re: Diskussion (Cadrach, 29. Jan 2003, 09:57:31):
~#! rn=Ark rt=1043790067 rg=gilden.zauberer
~#! tid=1043168066
Schau Dir mal die Shadowprogrammierung an Ark, damit duerftest Du wirklich
nahezu 100% Deiner kranken Ideen umsetzen koennen :o)

Cad*

-----------------------------------------------------------------------------



Re^10:  Re: Diskussion (Ark, 29. Jan 2003, 13:07:29):
~#! rn=Cadrach rt=1043830651 rg=gilden.zauberer
~#! tid=1043168066
Tja, da die aber (zu Recht) genehmigungspflichtig sind, ist das nicht wirklich
eine Alternative. Und meist geht es auch mit etwas Kompromiss auch anders.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Website (Bambi,  9. Feb 2003, 00:06:30):
Hi alle.
Die Zauberergildenseite ist voruebergehend im Bereich der Region Gebirge zu
finden.
Sollte sich jemand berufen fuehlen, die Wartung der Website zu uebernehmen, so
melde er sich an geeigneter Stelle.

-----------------------------------------------------------------------------



Wartung der Gildenwebsite. (Bambi,  4. Mar 2003, 15:23:27):
Hallo Zauberer und die, die sich fuer selbige interessieren.
Strohalm hat sich freundlicherweise bereiterklaert, die Gildenwebsite zu
warten und zu ueberarbeiten. Die Website ist unter
http://www.imaginetion.de/zaubis/ zu finden und wird demnaechst direkt von der
Homepage aus verlinkt.

-----------------------------------------------------------------------------



Gildenseiten (Strohalm,  6. Mai 2003, 02:33:54):
Die Seiten ueber "Abwehr" sind wiederhergestellt.
Erreichbar ist die Homepage nach wie vor unter
http://www.imaginetion.de/zaubis/

Haelmchen, Apophis dankend

-----------------------------------------------------------------------------



Re: Gildenseiten (Vardion,  6. Mai 2003, 11:04:18):
~#! rn=Strohalm rt=1052181234 rg=gilden.zauberer
~#! tid=1052181234
Die FAQ auf der Seite ist aber immernoch gnadenlos veraltet ;-)

Vardion

-----------------------------------------------------------------------------



Re: Re: Gildenseiten (Strohalm,  7. Mai 2003, 12:33:42):
~#! rn=Vardion rt=1052211858 rg=gilden.zauberer
~#! tid=1052181234
sobald ich zeit hab, wird das ganze ueberarbeitet.. ihr duerft mir auch gerne
verbesserungsvorschlaege mailen ;)

Haelmchen

-----------------------------------------------------------------------------



komponenten (Patryn, 18. Mai 2003, 12:50:33):
Es ist moeglich dass es Probleme mit Komponenten gibt.
Es wurden mehrere Sicherungen gegen unendliche Komponenten, die nicht in
Spielerhaende gehoeren, eingebaut (es gab da missverstaendnisse *g*),
es wurden Sicherungen gegen mir unbekannte Komponenten eingebaut.
Bei Problemen halt an mich wenden.

-- 
patryn

-----------------------------------------------------------------------------



Eure Meinung... (Strohalm,  4. Jun 2003, 13:58:32):
... ist gefragt, und zwar zum neuen Design der Zaubiseiten.

Wollt ihr eine schlichte, usability-gerechte Seite, die auch unter
Textbrowsern wunderbar lesbar ist, oder eher eine design-strotzende Page, die
optisch was daher macht?

Haelmchen

-----------------------------------------------------------------------------



Re: Eure Meinung... (Strohalm,  4. Jun 2003, 13:59:56):
~#! rn=Strohalm rt=1054727912 rg=gilden.zauberer
~#! tid=1054727912
Achja, bevor noch mehr anfragen kommen: Ein Forum zum jammern wird dann wohl
auch integriert ;)

-----------------------------------------------------------------------------



Re: Re: Eure Meinung... (Bambi,  4. Jun 2003, 14:13:42):
~#! rn=Strohalm rt=1054727996 rg=gilden.zauberer
~#! tid=1054727912
An was fuer ein Forum hast Du denn gedacht? So ein 1&1-Std.-Forum oder was
eigenes?

-----------------------------------------------------------------------------



Re^3: Eure Meinung... (Strohalm,  4. Jun 2003, 14:14:23):
~#! rn=Bambi rt=1054728822 rg=gilden.zauberer
~#! tid=1054727912
Was eigenes, ich mag keine Standardforen

Haelmchen

-----------------------------------------------------------------------------



Re^4: Eure Meinung... (Croft,  4. Jun 2003, 15:02:54):
~#! rn=Strohalm rt=1054728863 rg=gilden.zauberer
~#! tid=1054727912
Hm.  Wie waers mit beidem?  Guard hat das bei der Trvesseite imho gut geloest.

Croft

-----------------------------------------------------------------------------



Re: Eure Meinung... (Muadib,  4. Jun 2003, 18:29:55):
~#! rn=Strohalm rt=1054727912 rg=gilden.zauberer
~#! tid=1054727912
also ich wuerde strukturierter text huebschen bildchen vorziehen, zumindest
dort wo die relevanten infos liegen. 

-----------------------------------------------------------------------------



Re: Re: Eure Meinung... (Darklor,  4. Jun 2003, 18:44:51):
~#! rn=Muadib rt=1054744195 rg=gilden.zauberer
~#! tid=1054727912
Text is gut. Bilder waeren auch ok - solange die Seite dann auch noch mit
aelteren Browsern lesbar bleibt. 

Darklor

-----------------------------------------------------------------------------



Re^3: Eure Meinung... (Anatol,  5. Jun 2003, 00:22:59):
~#! rn=Darklor rt=1054745091 rg=gilden.zauberer
~#! tid=1054727912
Zuegige Seite, gut strukturiert, html/css-Standard einhaltend. 

Anatol hat doch gerne Wuensche


-----------------------------------------------------------------------------



Re^4: Eure Meinung... (Birdy, 12. Jun 2003, 18:49:55):
~#! rn=Anatol rt=1054765379 rg=gilden.zauberer
~#! tid=1054727912
Ich will Bilder!

-----------------------------------------------------------------------------



Re^5: Eure Meinung... (Lug, 12. Jun 2003, 20:43:39):
~#! rn=Birdy rt=1055436595 rg=gilden.zauberer
~#! tid=1054727912
www.atkimgdom.com
Aber nur wenn Du 18+ bist...
Kopschuettelnd
L.

-----------------------------------------------------------------------------



austritt (Patryn, 12. Aug 2003, 18:03:20):
Vorsicht bei Austritt, Skillverluste von 50%

-- 
patryn

-----------------------------------------------------------------------------



Re: austritt (Anatol, 13. Aug 2003, 17:59:48):
~#! rn=Patryn rt=1060704200 rg=gilden.zauberer
~#! tid=1060704200
Hey, warum setzen wir die Gilde nicht gleich beim ersten Einloggen fest?

SCNR
Anatol

-----------------------------------------------------------------------------



Re: Re: austritt (Ogo, 13. Aug 2003, 18:00:45):
~#! rn=Anatol rt=1060790388 rg=gilden.zauberer
~#! tid=1060704200
Weil dann niemand mehr Tanjian wird? Oder kommst du mit Level 5 auf die Welt?

Ebenfalls SCNR
Ogo

-----------------------------------------------------------------------------



Re^3: austritt (Orktoeter, 13. Aug 2003, 18:06:47):
~#! rn=Ogo rt=1060790445 rg=gilden.zauberer
~#! tid=1060704200
Du willst doch Abenteurer nicht als Gilde bezeichnen, oder?

OrkT, Abenteuter.

-----------------------------------------------------------------------------



Suche... (Strohalm, 21. Aug 2003, 08:13:32):
... gueltigen Garantieschein fuer ewigen Guertel.
Biete 20000 Muenzen, einen abgewetzten Teddybaer, eine neue Zeitung und eine
stubenreine Maus.

Angebote bitte an strohalm@mg.mud.de

Haelmchen

-----------------------------------------------------------------------------



Re: Suche... (Strohalm, 21. Aug 2003, 08:17:06):
~#! rn=Strohalm rt=1061446412 rg=gilden.zauberer
~#! tid=1061446412
Fuer schnelle Gebote leg ich noch einen Satz Winterreifen fuer Rollstuehle
drauf.

-----------------------------------------------------------------------------



guertel (Patryn, 21. Aug 2003, 22:23:25):
Irgendwie sind autoloader beim Crash verschwunden, meistens wohl ewige
Guertel, oder da faellts halt auf.
Da ich zu faul bin, jedem das Ding da zu clonen, einfach den Alchemisten
nach Guertel fragen.
Danke fuer die Aufmerksamkeit.

-- 
patryn, wollt gar nix machen jetzt . o O(spieler!)

-----------------------------------------------------------------------------



Re: Re: austritt (Seno, 26. Aug 2003, 05:37:59):
~#! rn=Anatol rt=1060790388 rg=gilden.zauberer
~#! tid=1060704200
Tja ... Du musstest Patryn ja vor 2 Jahren mit ganzem rhetorischen Einsatz und
einer gehoerigen Portion Arroganz dabei unterstuetzen, die Gilde endgueltig an
die Wand zu setzen ;)

Immer wenn sich zeigte, dass die Zauberer ausser Balance waren und der Run auf
sie zu gross, wurden vor allem die Bedingungen fuer das Hochspielen erschwert.
Drastisch vor 2 Jahren, in diversen, kleineren Schritten in den Jahren davor.
Fuer junge Charaktere ist die Gilde damit mittlerweile nur sehr schlecht
spielbar, deshalb war ich ein entschiedener Gegner vor allem dieser letzten
"Korrektur".

Jetzt versucht Patryn offenbar der Abwanderung aus der Gilde entgegenzuwirken,
indem er mit hoeheren Skill-Verlusten droht. Eine gildenpolitische
Bankrotterklaerung. Und das MG schaut seit 2 Jahren zu. Ich hab meinen
Entschluss, das MG damals zu verlassen, jedenfalls nie bereut, es ist mir aber
auch noch nicht egal, was hier passiert.

Seno

-----------------------------------------------------------------------------



Re^3: austritt (Vardion, 26. Aug 2003, 10:20:20):
~#! rn=Seno rt=1061869079 rg=gilden.zauberer
~#! tid=1060704200
Du hast keinen blassen Schimmer, warum der Skillverlust beim Austreten erhoeht
wurde.

Vardion

-----------------------------------------------------------------------------



Re^4: austritt (Nonne, 26. Aug 2003, 10:27:46):
~#! rn=Vardion rt=1061886020 rg=gilden.zauberer
~#! tid=1060704200
Weiss ich auch nicht, erklaerst Du es mir?

Nonne, keine Ahnung habend, ehrlich!

-----------------------------------------------------------------------------



Re^3: austritt (Ark, 26. Aug 2003, 10:29:50):
~#! rn=Seno rt=1061869079 rg=gilden.zauberer
~#! tid=1060704200
Also entweder verlassen oder nicht. So halb verschwinden und staenkern? Was
ist denn das? Nebenwirkungen der Sucht?


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^5: austritt (Nonne, 26. Aug 2003, 10:33:45):
~#! rn=Nonne rt=1061886466 rg=gilden.zauberer
~#! tid=1060704200
Bevor mir den Grund noch alle per TM mitteilen: Ich weiss es inzwischen, danke
fuer die Hilfe.

Nonne, nicht mehr dumm.

-----------------------------------------------------------------------------



Re^5: austritt (Nonne, 26. Aug 2003, 10:37:08):
~#! rn=Nonne rt=1061886466 rg=gilden.zauberer
~#! tid=1060704200
Super, jetzt fragen sie mich alle nach dem Grund *g*

Zitat:  kurz und buendig: der skillverlust durch austritt war vorher niedriger
als die lernmenge der questbelohnungen (llys setzt nach quests den absolut
schlechtesten skill immer etwas hoch)

Man konnte also durch aus- und eintreten und nochmal alle GQ machen, seine
Skills erhoehen, ohne die Gefahren, die mit effektivem Ueben verbunden sind. 

Nonne.

P.S: Sorry fuer die vielen Selbstreplies.

-----------------------------------------------------------------------------



Re^3: austritt (Patryn, 26. Aug 2003, 11:00:37):
~#! rn=Seno rt=1061869079 rg=gilden.zauberer
~#! tid=1060704200
Hach, endlich mal wieder ein toller neuer Thread.
Auf gehts :)

-----------------------------------------------------------------------------



Re^3: austritt (Medic, 26. Aug 2003, 12:55:10):
~#! rn=Seno rt=1061869079 rg=gilden.zauberer
~#! tid=1060704200
Fuer junge Charaktere ist die Gilde kaum spielbar? Hm, da darf ich dann aber
auch mal meinen Senf dazu geben.
Mein Char existiert erst seit Anfang Mai, und ich bin auch ueber das meiste
sicher nicht im Bilde, was vor 2, 3 oder n Jahren hier mit den Zaubis los war.
Ich habe meinen Char zum Zaubi gemacht, ohne das ich wusste, was genau auf
mich zukommt, sondern
deswegen,weil ich in Rollespielen eigentlich bisher immer Zauberer gespielt
habe, egal ob AD&D, DSA oder Shadowrun.
Das tut aber auch nix zur Sache.
Was aber Fakt ist: mir macht das Zaubisein hier sehr viel Spass. Ja, man muss
sich sehr lange hochueben
und auch die eine oder andree Gildenquest fand ich supernervig. Als ich mit
(ich glaube) ca. Spielerlevel 10 in die Gilde eintrat,
bekam ich schon Probleme mit den Viechern auf der Hochebene beim Metzeln.
Aber was will ich denn als Zauberer? Innerhalb von 6 Spielstunden zum
Erzmagister aufsteigen
und jedes noch so starke Viech achselzuckend wegpusten? Sicher nicht.
Ich finde die Aufstiegshuerden sicher - wie jeder - manchmal nervig, aber
nicht,
weil sie keinen Sinn machen, sondern hoechstens, "weil man's ja doch gernschon
koennen wuerde".
Von daher, Seno, kann ich deine Aussage von den unspielbaren neuen Zaubichars
ueberhaupt nicht verstehen.

Gruss,
medic (Zaubi aus Ueberzeugung)

-----------------------------------------------------------------------------



Re^6: austritt (Seno, 26. Aug 2003, 13:18:03):
~#! rn=Nonne rt=1061887028 rg=gilden.zauberer
~#! tid=1060704200
Hm ...

Warum nennt Patryn seine Gruende nicht gleich ?

50% der Skills koennen durch die Gildenquesten erspielt werden ?
Das kann ich mir nur auf eher niedrigem Skillniveau vorstellen und die
Gildenaufgaben, die dem Aufwand von mindestens 900 APs entsprechen, muessen
dazu auch erst mal "abgearbeitet" werden. Ausserdem: Warum muessen
Wiedereintretende nochmal _alle_ davon durchnudeln ? Hier wuerde ja auch eine
moegliche Loesung des angefuehrten Problems liegen.

@Ark: Ich spiele nicht mehr hier, lese aber noch sporadisch Zeitung und hab
noch Kontakt zu Leuten hier. Aus gegebenem Anlass wollte ich auf die Folgen
der Verschaerfungen vor 2 Jahren aufmerksam machen, ueber die damals nur
spekuliert werden konnte.

Seno

-----------------------------------------------------------------------------



Re^7: austritt (Muadib, 26. Aug 2003, 13:21:56):
~#! rn=Seno rt=1061896683 rg=gilden.zauberer
~#! tid=1060704200
egal was du dir vorstellen kannst oder nicht, die prozente der skills die man
gefoerdert bekommt sind berechenbar und nicht von vorstellungskraft abhaengig.

wie kommst du auf den aufwand von 900 aps?

warum soll man nicht nochmal die gildenquests spielen muessen wenn man der
gilde den ruecken kehrt und sich dann entschliesst doch wieder in die gilde zu
gehen?
warum soll handeln keine konsequenzen haben?

das problem dass man durch gildenaustritte seine skills verbessern konnte
wurde entschaerft also welches problem meinst du?

fragen ueber fragen

muadib

-----------------------------------------------------------------------------



Re^7: austritt (Patryn, 26. Aug 2003, 13:22:08):
~#! rn=Seno rt=1061896683 rg=gilden.zauberer
~#! tid=1060704200
Fassen wir doch zusammen, ich bin doof, arrogant und gemein, auch wenn es
diesmal nicht so recht geklappt hat, weil der Polemik-Faktor umgekehrt
proportional zur Ahnung des Spielers steht.
Du bist der einzige der hier rumzoffte, und das als quasi inaktiver,
der schon frueher gern nur sinnlos rumstaenkerte.
Vor allem erinnert mich das daran, warum ich zeitweise voellig keinen Bock
mehr hatte, das war jetzt mal eine Aenderung in Monaten, und Du schlaegst
hier mit so einem Artikel ein, frueher warens manchmal mehrere Aenderungen
am Tag...na das gab ein Gekreische ;) Und ueberlebt habens alle.

-- 
patryn

-----------------------------------------------------------------------------



Re^8: austritt (Seno, 26. Aug 2003, 15:08:46):
~#! rn=Patryn rt=1061896928 rg=gilden.zauberer
~#! tid=1060704200
>weil der Polemik-Faktor umgekehrt proportional zur Ahnung des Spielers steht

wieder das bekannte "Du hast ja keine Ahnung"-Argument, wurde schon immer gern
verwendet, besonders in dieser Rubrik.


>der schon frueher gern nur sinnlos rumstaenkerte

damit stellst du mich voellig falsch dar, ueberrascht mich aber nicht


Ueberzeugt hat mich Medics Artikel. Es sieht, wie ich lesen konnte, anders
aus, wenn man voellig unvorbelastet hier beginnt (hatte seinen Artikel noch
nicht gelesen, als ich meinen letzten veroeffentlichte). Fakt ist aber auch,
dass in den letzten Jahren relativ viele Zauberer der Gilde den Ruecken
gekehrt haben und dass sie schrumpft, relativ wenig Nachwuchs hat.

@Muadib: Vor 2 Jahren wurden fuer die Gildenquesten noch Gildenquestpunkte
vergeben. Diese entsprachen in ihrer Wertigkeit den APs. Es gab damals etwa
870 GQP zu erreichen, soweit ich mich erinnere, inzwischen sind einige neue
Gildenaufgaben hinzugekommen.

Seno

-----------------------------------------------------------------------------



Re^9: austritt (Vardion, 26. Aug 2003, 15:11:34):
~#! rn=Seno rt=1061903326 rg=gilden.zauberer
~#! tid=1060704200
> Vor 2 Jahren wurden fuer die Gildenquesten noch Gildenquestpunkte
> vergeben. Diese entsprachen in ihrer Wertigkeit den APs.

Wie kommst Du denn auf dieses duenne Brett?

Vardion

-----------------------------------------------------------------------------



Re^9: austritt (Croft, 26. Aug 2003, 15:11:44):
~#! rn=Seno rt=1061903326 rg=gilden.zauberer
~#! tid=1060704200
> Fakt ist aber auch,
> dass in den letzten Jahren relativ viele Zauberer der Gilde den Ruecken
> gekehrt haben und dass sie schrumpft, relativ wenig Nachwuchs hat.
Koenntest du das mal bitte belegen?  Ich seh das naemlich nicht so :-)

Croft

-----------------------------------------------------------------------------



Re^9: austritt (Humni, 26. Aug 2003, 15:11:52):
~#! rn=Seno rt=1061903326 rg=gilden.zauberer
~#! tid=1060704200
> Relativ viele Zauberer der Gilde den Ruecken...

Hab ich nicht beobachtet. Mag faktisch richtig sein, die meisten aktiven
Spieler die ich kenne und die (ueberzeugte) Zauberer sind sind das nach wie
vor. Mir faellt auf Anhieb nur Brotnael ein, und der war immer eigentlich
Kleriker...

Aber ich mag mich irren...

Humni

-----------------------------------------------------------------------------



Re^10: austritt (Mandragon, 26. Aug 2003, 15:12:47):
~#! rn=Humni rt=1061903512 rg=gilden.zauberer
~#! tid=1060704200
Hey. Ihr koennt doch nicht mit rationalen Ueberlegungen kommen ...

Ma* (hat gerade das Popcorn ausgepackt)

-----------------------------------------------------------------------------



Re^9: austritt (Bambi, 26. Aug 2003, 15:14:53):
~#! rn=Seno rt=1061903326 rg=gilden.zauberer
~#! tid=1060704200
> relativ viele Zauberer der Gilde den Ruecken gekehrt

Die Zauberer haben Nachwuchsprobleme? Mach mal "kwer gilde katzenkrieger"...

-----------------------------------------------------------------------------



Re^10: austritt (Mandragon, 26. Aug 2003, 15:15:38):
~#! rn=Bambi rt=1061903693 rg=gilden.zauberer
~#! tid=1060704200

Gibt es eigentlich neue Bierschuettler?

Ma*

-----------------------------------------------------------------------------



Re^11: austritt (Morgoth, 26. Aug 2003, 15:16:24):
~#! rn=Mandragon rt=1061903738 rg=gilden.zauberer
~#! tid=1060704200
Es gibt 4 Ork/Urukhai-Testies :)

M*

-----------------------------------------------------------------------------



Re^10: austritt (Seno, 27. Aug 2003, 02:58:30):
~#! rn=Bambi rt=1061903693 rg=gilden.zauberer
~#! tid=1060704200
Das hab ich dann falsch eingeschaetzt und moechte mich fuer Aeusserungen wie
"Gilde an die Wand gesetzt", "gildenpolitische Bankrotterklaerung" und "das MG
schaut seit 2 Jahren zu" entschuldigen.

In meinem Bekanntenkreis waren es jedenfalls relativ viele, die die Gilde
gewechselt haben oder deren Zauberer-Char nicht mehr aktiv ist. Ich war auch
der Meinung, dass die Zahl der aktiven Spieler in der Gilde abgenommen hat,
man kann eine entsprechende Liste bei Llystrathe abrufen. Aber ich hab das
wohl falsch eingeschaetzt und ueberschaetzt, sorry.

Seno

-----------------------------------------------------------------------------



Re: austritt (Seebee, 27. Aug 2003, 14:35:18):
~#! rn=Patryn rt=1060704200 rg=gilden.zauberer
~#! tid=1060704200
Also bevor Seno total alleine im Regen steht:


Ja, es gibt Leute, die der Gilde entnervt den Ruecken kehrten. Ich bin einer
davon. 
Allerdings sage ich mir: Ich komm mit der Gildenpolitik/dem Gildenfeeling
nicht klar. Ok. Nehm ich ne andere. Das ist zwar schade, da mich das
Grundkonzept von Zauberern (nicht das der hiessigen) ziemlich anspricht, aber
die Konsequenz, wenn ich mich nicht selber und den Gildenbug aeh mag bis aufs
aeusserste nerven moechte.

Zu meckern gibts an der Gilde genug. Aber solange es Spieler wie Medic gibt,
die trotz allem (oder vielleicht gerade deswegen) Spass an der Gilde haben, so
kann man getrost die Klappe halten und die Zaubis akzeptieren, wie sie sind:
bratzig und lernintensiv. Dass ich als Stabschwinger ueberhaupt nicht klar kam
heisst ja dann jofseidank anscheinend nicht, dass es andere nicht doch
koennen. Ich zieh beeindruckt meinen Hut vor allen Jungzauberen und meine zu
dem Thema nur noch: Katzenkrieger vor!! :o)

- Rangorn Khur'Tigres -

-----------------------------------------------------------------------------



allgemeines Verhalten (Patryn, 29. Sep 2003, 23:20:54):
Also ich will hier keinen auflaufen lassen, deshalb ein allgemeines Statement,
jeder darf sein Tun ueberdenken und es schnell umstellen.
Es gab einige Beschwerden darueber, dass Leute die Moeglichkeiten der
Zauberergilde ausnutzen um sich als jemand anderes auszugeben und damit
boeswilligen Unfug treiben.
Es gibt mal wieder ein neues LOg, eines der Vielen, die nich auf meinem
Mist gewachsen sind, sondern zu einem Grossteil auf Anforderung wegen
des seltsamen Verhaltens einiger Leute basieren.
Jeder Angesprochene mag sein MUD-Leben rechtzeitig entsprechend anpassen.

-- 
patryn, nur halbmotiviert, Kindergarten ole'

-----------------------------------------------------------------------------



Pentagramm (Medic, 19. Dez 2003, 20:06:32):
Hiho,

mich freut es ja einerseits, wenn an Gilde und Gildenraeumen geschraubt wird,
aber welchen Zweck hatte die Umstellung des Pentagramms am heutigen Tage?
Ich will ja nicht inhaltslos meckern, aber ich fand die alte Version einfach
besser...

Gruss,
Medic

-----------------------------------------------------------------------------



Re: Pentagramm (Patryn, 19. Dez 2003, 20:07:13):
~#! rn=Medic rt=1071860792 rg=gilden.zauberer
~#! tid=1071860792
Was ist jetzt genau der Inhalt? :)

-----------------------------------------------------------------------------



Re: Re: Pentagramm (Medic, 19. Dez 2003, 20:07:35):
~#! rn=Patryn rt=1071860833 rg=gilden.zauberer
~#! tid=1071860792
Ein Feedback.

-----------------------------------------------------------------------------



Re: Pentagramm (Grumpf, 19. Dez 2003, 20:08:29):
~#! rn=Medic rt=1071860792 rg=gilden.zauberer
~#! tid=1071860792
Magierwillkuer sonst nix. Und frag bei dieser Gilde nie nach dem Sinn
irgendwelcher Aenderungen.
Grumpf grumpft.

-----------------------------------------------------------------------------



Re: Re: Pentagramm (Patryn, 19. Dez 2003, 20:10:03):
~#! rn=Grumpf rt=1071860909 rg=gilden.zauberer
~#! tid=1071860792
Magierwillkuer...wow, das Wort hab ich ja schon lang nicht mehr gehoert,
von wegen frueher war alles besser, geht doch noch! :)

-----------------------------------------------------------------------------



Re^3: Pentagramm (Medic, 19. Dez 2003, 20:12:10):
~#! rn=Patryn rt=1071860973 rg=gilden.zauberer
~#! tid=1071860792
Die Magierwillkuer kam nicht von mir. Ich denke (hoffe ;) mal, dass Patryn
schon einen Gedanken daran verschwendet, warum er wann wass fuer die Gilde
programmiert. Zufaellig gestern mal im mpa-Archiv von gilden.zauberer
geblaettert und dabei auch entdeckt, dass dasPentagramm ja nicht immer so
ausgesehen hat wie bis vor ein paar Stunden. Und alles was ich gesagt habe,
ist, dass ich die bisherige Variante besser finde als die jetztige.

Medic

-----------------------------------------------------------------------------



Re^4: Pentagramm (Patryn, 19. Dez 2003, 20:14:20):
~#! rn=Medic rt=1071861130 rg=gilden.zauberer
~#! tid=1071860792
Also das Ding ist nicht von mir sondern von einem Spieler, der sich hier
dann gern selbst dazu bekennen darf, aber gern auch alles Beschwerden
an mir abprallen lassen kann, wenn ihm das zu bunt ist.
Hoffe mal, er wird nicht allzu abgeschreckt durch das miese
Tauschverhaeltnis von Arbeit und Anerkennung bei den hiesigen
Besitzstandswahrungsverhaeltnissen (Mist, Wort das Jahres ist gewaehlt!)

-----------------------------------------------------------------------------



Re^5: Pentagramm (Medic, 19. Dez 2003, 21:05:07):
~#! rn=Patryn rt=1071861260 rg=gilden.zauberer
~#! tid=1071860792
Es ist - wie hoffentlich ersichtlich - nicht mein Ziel, irgendeine motivierte
Person, ob Spieler oder Magier, davon abzuhaltem, etwas im MG zu
programmieren. Und auch ist es weder meine Absicht, nochmeine Aufgabe, hier
Schelte zu verteilen. Aber ein "jemand hat sich Muehe gegeben, also muss es
auch gut sein"-Freibrief existiert nun mal nicht und daher sei es den
Spielern, die an dieser Arbeit dann herumspielen, auch erlaubt, mal Kritik zu
aeussern.
Konkret missfaellt mir an dem neuen Pentagramm die Veraenderungd er Ziele. Ein
Portal benutze ich, weil ich weiss, wo ich hin will (naja, ausser bei para-p8
;). Aehnlich war es bisher beim Pentagramm: Ich weiss, wo ich hin will, also
nutze ich das Pentagramm. Okay, als tf'ler ist es nicht weiter schwer, die
Wegeskripte anzupassen und dabei das Pentagramm aussen vor zu lassen, aber das
ist ja nicht Sinn der Sache. Ich habe gerade, als ich mit Spielerlevel 8 oder
so der Gilde beigetreten bin und zuerst noch telnet, dann andere, einfacher
gestrickte Clients benutzt habe, das Pentagramm zu schaetzen gewusst, weil ich
eben nicht immer per Hand den ganzen Weg zurueck laufen musste oder immer auf
die karawane nach Fernwest wartenmusste (jaja, andere Gildenkoennen es nicht
benutzen, weiss ich ja. Aber die haben andere Vorteile an anderen Stellen, die
Zaubis nunmal u.a. bisher mit dem Pentagramm eines).
Wird das nun alles auf Random gesetzt, weiss ich nie, wo die Spiegel gerade
hinfuehren. Das mag ja ganz interessant sein, wenn man eine Gegend noch gar
nicht kennt und die dann einfach mal betritt, aber ich persoenlich renne
sicher nicht staendig zu einemPentagramm und untersuche dann immer alle
Spiegel, um zu schauen, wo diese denn gerade hinfuehren.
Dann doch lieber das Seherportal im Cronoertal ;) Und Taramis auch. Und im
uebrigen die Gilde aufwerten.

Just my 2c,
Medic (jammernder Zaubi ;)

-----------------------------------------------------------------------------



Re^6: Pentagramm (Pale, 19. Dez 2003, 23:40:20):
~#! rn=Medic rt=1071864307 rg=gilden.zauberer
~#! tid=1071860792
Hallo Zaubis, Patryn ...
also jammern moecht ich hier nicht unbedingt, aber meinen Senf zum Thema
dazugeben schon. Ich schliesse mich mit meiner Meinung Medic an. Den Sinn oder
unsinn des neuen Pentagramms verstehe ich (bisher) nicht. Vielleicht auch
deshalb, weil wieder einmal nicht erklaert wurde, warum diese Umstellung
noetig war. In meinen Augen wird der Spielspass zwar nicht beeintraechtigt,
weil man Wegescripte ja anpassen kann, aber warum Energie in so (meiner
Meinung nach) nutzlose Aenderungen stecken, anstatt dann doch mal das lange
angekuendigte Taramis anzuschliessen.
Mir wuerde ja schon einmal ein Hinweis genuegen, warum diese Aenderung so
implementiert wurde. Soll es jetzt einen Mehrwert fuer uns Zaubis darstellen,
oder nur eine Strafmassnahme wegen irgendwas sein? Irgendeinen Sinn muss es
doch geben. Nur welchen?

Pale *jammernder Zaubi, der nicht dumm bei Lars erscheinen moechte*

-----------------------------------------------------------------------------



Re^7: Pentagramm (Shaeena, 19. Dez 2003, 23:46:08):
~#! rn=Pale rt=1071873620 rg=gilden.zauberer
~#! tid=1071860792
Huhu,
der Sinn der Aenderung wuerde mich auch mal interessieren,
ohne diesen Sinn find ich die Aenderung recht.. sinnlos.. :)
Die Meldungen bei Betreten/Verlassen sind nett, 
aber die "neuen" Spiegel find ich nicht so toll.
Shaeena

-----------------------------------------------------------------------------



Re^8: Pentagramm (Patryn, 19. Dez 2003, 23:47:22):
~#! rn=Shaeena rt=1071873968 rg=gilden.zauberer
~#! tid=1071860792
Na endlich mal wieder ein paar Artikel hier ;)

-----------------------------------------------------------------------------



Re^9: Pentagramm (Dotz, 19. Dez 2003, 23:49:11):
~#! rn=Patryn rt=1071874042 rg=gilden.zauberer
~#! tid=1071860792
Der Sinn des neuen Pentagramms war es, hier Artikel zu produzieren?

Dotz, WG, nach schmarrn schielend.

-----------------------------------------------------------------------------



Re^9: Pentagramm (Medic, 19. Dez 2003, 23:50:23):
~#! rn=Patryn rt=1071874042 rg=gilden.zauberer
~#! tid=1071860792
Ja, gibt ja auch was zu jammern ;)
Aber im Ernst, Patryn (ich hab keine Ahnung wer es letztendlich vorgeschlagen
und/oder umgesetzt hat, und du bist nunmal Gildenmagier, daher spreche ich
einfach dich an): Welchen Sinn hat das Ganze?

-----------------------------------------------------------------------------



Re^10: Pentagramm (Patryn, 19. Dez 2003, 23:51:17):
~#! rn=Dotz rt=1071874151 rg=gilden.zauberer
~#! tid=1071860792
Ach so, natuerlich auch: Ich finde das Pentagramm gut, danke fuer die
Arbeit, xyz.

-----------------------------------------------------------------------------



Re^11: Pentagramm (Thufhir, 20. Dez 2003, 10:15:27):
~#! rn=Patryn rt=1071874277 rg=gilden.zauberer
~#! tid=1071860792
Die Informationspolitik ist wieder mal grossartig. Riesenthread, in dem die
einzige Information ist, dass dieses Dingen ein Spieler verbrochen hat. Sonst
absolut null Gehalt. In ansonsten jedem Gebiet kennt man den Verantwortlichen
(Magier) des Raumes. Klar, dass wir auf die Frage, wer konkret diese Abwertung
der Kneipe vorgenommen hat, auch keine Antwort bekommen. Eine Abwertung ist es
auf jeden Fall, beim Metzeln kann man das Tanken in der Gildenkneipe
vergessen, alle anderen Wege aus dem Cronoertal sind mit Restriktionen belegt,
die voellig inakzeptabel sind (nich vollgefressen sein, zwingend irgendwas an
Ausruestung tragen muess, etc.) Also bleibt als Fazit nur, die Kneipe nicht
mehr zum Tanken zu benutzen. Sicher werden wir auch auf die Frage, warum man
uns die Vielfalt der Zaubererkneipe entzieht, auch wieder keine Antwort
bekommen. Macht weiter so, steckt ne Menge Arbeit in Dinge, ueber die vorher
offensichtlich nicht nachgedacht wird, und erklaert diese nicht. So schafft
man ein gutes Gildenfeeling und zufriedene Spieler. Meine Meinung: weiter so!

szzt

-----------------------------------------------------------------------------



Re^12: Pentagramm (Medic, 20. Dez 2003, 11:20:39):
~#! rn=Thufhir rt=1071911727 rg=gilden.zauberer
~#! tid=1071860792
Hm, da Taramis ja in absehbarer Zeit sicher kaum angeschlossen werden
duerfte...wie waere es denn mit dem eigentlich mal fuer das Cronoertal
vorgesehenen Seherportal? Nur mal so als Anregung....

-----------------------------------------------------------------------------



Re^13: Pentagramm (Bambi, 20. Dez 2003, 11:48:42):
~#! rn=Medic rt=1071915639 rg=gilden.zauberer
~#! tid=1071860792
Gibt mir mal wer eine brauchbare Antwort auf mindestens eine der zwei
folgenden Fragen:
Was hat die Zauberergilde (egal ob bisherige oder zukuenftige) mit dem
Anschluss von Taramis zu tun, ausser, dass die Gildenraeume dann etwas anders
zu erreichen sind?
Was hat Patryn als Gildenmagier mit dem Anschluss von Taramis zu tun, das
meines Erachtens von Silvana programmiert wird (oder auch nicht)?

-----------------------------------------------------------------------------



Re^14: Pentagramm (Medic, 20. Dez 2003, 11:53:18):
~#! rn=Bambi rt=1071917322 rg=gilden.zauberer
~#! tid=1071860792
1. Vermutlich wenig bis gar nichts.
2. dito.

aber 3.
Waere es nicht sinnvoll, wenn man fuere eine Gegend, die urspruenglich mit
einem Sehertor ausgestattet werden sollte (siehe zfaq), die aber bisher nru
teilweise angeschlossen ist (naemlich teile des Cronoertals) - und wo nicht
abzusehen ist, wann oder ob der Rest jemals folgen wird - Alternativen
eingeplant werden?

-----------------------------------------------------------------------------



Re^15: Pentagramm (Bambi, 20. Dez 2003, 11:58:36):
~#! rn=Medic rt=1071917598 rg=gilden.zauberer
~#! tid=1071860792
Ich weiss leider nicht, welche Anforderungen an das geplante Sehertor
bestehen, also ob zum Beispiel eine Miniquest geloest werden muss, um das Tor
zu finden. Du koenntest, wenn Du das herausfinden willst, einen der
Verantwortlichen fragen.
Da waeren...
1. Der programmierende Magier: Silvana
2. Der Regionsmagier: Boing, Bambi
3. Ein Erzmagier: siehe hilfe erzmagier

Zu 2. Ich zumindest weiss nichts ueber besagtes Sehertor und mir ist auch
nicht klar, ob ich als RM da ueberhaupt gefragt oder informiert werde.

MfG, Bambi.

-----------------------------------------------------------------------------



Re^16: Pentagramm (Medic, 20. Dez 2003, 12:12:37):
~#! rn=Bambi rt=1071917916 rg=gilden.zauberer
~#! tid=1071860792
Fuehrt aber auch ein wenig vom Thema weg, sorry. Mir persoenlich gehts nicht
so sehr um Sehertor oder nicht Sehertor (dagegen hab ich nix ;-), sondern
einfach um Sinn oder Unsinn des neuen Pentagrammes. Und wie gesagt, ich finde
es unsinnig. Tutmirja leid fuer den Programmierenden, wenn er sich Arbeit
gemacht hat und keine Anerkennung dafuer bekommt, aber das ist nunmal dabei:
Stellt man ein Projekt in der Oeffentlichkeit vor, kann man halt nicht damit
rechnen, das jeder gleich ein begeistertes "Ahhh" hervorbringt. Den Frust
haette man sich allerdings sparen koennen, wenn man zumindest ein Konzept
erstmal vorstellt und sichein Meinungbild holt. (Ja, mir ist durchaus
bewuisst, dass das MG KEINE Demokratie ist).

-----------------------------------------------------------------------------



Re^17: Pentagramm (Foobar, 20. Dez 2003, 15:42:38):
~#! rn=Medic rt=1071918757 rg=gilden.zauberer
~#! tid=1071860792
Warum gibt's hier eigentlich Anforderungen fuer die Magierwerdung, wenn eh
jede Spielerwurst Kram zusammenschreiben darf unter der Vorraussetzung, dass
eine Magierwurst es anschliesst?

Foobar

-----------------------------------------------------------------------------



Re^18: Pentagramm (Patryn, 20. Dez 2003, 16:05:42):
~#! rn=Foobar rt=1071931358 rg=gilden.zauberer
~#! tid=1071860792
wow, der hat ja immer noch schaum vorm mund...zumindest in dieser rubrik hier
muss ich
leider auch alles lesen *seufz* was fuer zeitverschwendung

-----------------------------------------------------------------------------



Re^19: Pentagramm (Liara, 20. Dez 2003, 17:54:18):
~#! rn=Patryn rt=1071932742 rg=gilden.zauberer
~#! tid=1071860792
Fuer Nichtseher war die Moeglichkeit, gezielt durch die Spiegel bestimmte Orte
zu erreichen und aus der Gilde wieder in nicht abgelegenes Gelaende zu kommen,
absolut unverzichtbar.

-----------------------------------------------------------------------------



Re^20: Pentagramm (Patryn, 20. Dez 2003, 18:04:11):
~#! rn=Liara rt=1071939258 rg=gilden.zauberer
~#! tid=1071860792
Das geht nach wie vor, 2-3 sichere Ziele die jeder kennt sind immer bei.
Ansonsten darfst gern mal in anderen Gilden schaun, wie das die
Nichtseher dort so machen.

-----------------------------------------------------------------------------



Re^20: Pentagramm (Orktoeter, 20. Dez 2003, 18:10:46):
~#! rn=Liara rt=1071939258 rg=gilden.zauberer
~#! tid=1071860792
"absolut unverzichtbar"? Aha.. und nun? Was ist mit Zauberer-nicht-sehern?
Existoeren die jetzt nicht mehr, weil dieses "absolut unverzichtbare" feature
nicht mehr ist? 

Jammerskill schon ueber 100%?

OrkT.

-----------------------------------------------------------------------------



Re^21: Pentagramm (Kellybundy, 20. Dez 2003, 18:12:20):
~#! rn=Orktoeter rt=1071940246 rg=gilden.zauberer
~#! tid=1071860792
Koppelt datt dingens doch wie Para-Portal 8. Dann gibbet keine wurstzaubis mer
die jammern, harrrharrrr :)

Blondchen

-----------------------------------------------------------------------------



Re^22: Pentagramm (Apsu, 20. Dez 2003, 18:20:17):
~#! rn=Kellybundy rt=1071940340 rg=gilden.zauberer
~#! tid=1071860792
Das sollte vielleicht nach Schmarrn :)

-----------------------------------------------------------------------------



Ein wunderschoenes Hallo, (Meister, 20. Dez 2003, 22:10:21):
ich habe durch die unglaubliche Freundlichkeit unseres Gildenmagiers den Namen
des Verantwortlichen SPielers erfahren. Vielen Dank Anatol, dass du die viele
Arbeit auf dich genommen hast, ich finde die Idee toll und kann das nur
begruessen. Das Konzept ist stimmig und passt genau zur Gilde.

Vielen Dank, Meister der Schrecken seiner Meister

-----------------------------------------------------------------------------



Re: Ein wunderschoenes Hallo, (Patryn, 20. Dez 2003, 22:24:33):
~#! rn=Meister rt=1071954621 rg=gilden.zauberer
~#! tid=1071954621
falsch :) next try

-----------------------------------------------------------------------------



Re: Re: Ein wunderschoenes Hallo, (Meister, 20. Dez 2003, 22:28:33):
~#! rn=Patryn rt=1071955473 rg=gilden.zauberer
~#! tid=1071954621
naja, jetzt einfach so rauszureden ist auch ne taktik... irgendwie haette ich
wissen muessen, dass sowas passiert und alles abgestritten wird. aber
irgendwie zeigt es auch, dass es getroffen hat.

-----------------------------------------------------------------------------



Re^3: Ein wunderschoenes Hallo, (Patryn, 20. Dez 2003, 23:28:06):
~#! rn=Meister rt=1071955713 rg=gilden.zauberer
~#! tid=1071954621
was getroffen hat? dass anatol es war?
also selbst wenn er es war, was er nicht war, sind mir deine
anschuldigungen so ziemlich...ah, in deutschland verzieren wir ja eh alles
mit...super-egal ;)

-----------------------------------------------------------------------------



Re^4: Ein wunderschoenes Hallo, (Thufhir, 21. Dez 2003, 10:51:38):
~#! rn=Patryn rt=1071959286 rg=gilden.zauberer
~#! tid=1071954621
wenigstens wird noch auf die offensichtlich voellig sinnfreien artikel hier
eingegangen, wenn die sachargumente aus den anderen artikeln einfach ignoriert
werden.

szzt

-----------------------------------------------------------------------------



Re^5: Ein wunderschoenes Hallo, (Anatol, 21. Dez 2003, 14:26:41):
~#! rn=Thufhir rt=1072000298 rg=gilden.zauberer
~#! tid=1071954621
Okay, Meister hat es geschafft. Ich gehe jetzt in die Gilde und kucke,
was ich der Gilde beigesteuert haben soll... :)


-----------------------------------------------------------------------------



Re^6: Ein wunderschoenes Hallo, (Zook, 21. Dez 2003, 14:27:35):
~#! rn=Anatol rt=1072013201 rg=gilden.zauberer
~#! tid=1071954621
Berichtest Du mir bitte? Ich hab den Thread nicht mitverfolgt.

Zook.

-----------------------------------------------------------------------------



Re^7: Ein wunderschoenes Hallo, (Liara, 22. Dez 2003, 03:57:11):
~#! rn=Zook rt=1072013255 rg=gilden.zauberer
~#! tid=1071954621
Ok, mir bitte auch einen Bericht, ich habe auch keine Ahnung. ;>

-----------------------------------------------------------------------------



Re^8: Ein wunderschoenes Hallo, (Medic, 22. Dez 2003, 11:23:22):
~#! rn=Liara rt=1072061831 rg=gilden.zauberer
~#! tid=1071954621
:gibt auf.
Ich hab einfach versucht, ein Feedback zu geben und auch malo Kritik zu ueben.
Entweder, es wird verwurstet oder nicht ernst genommen. Also lassen wir das.
Ich glaub, ich sollte in den Semesterferien mal LPC lernen und einfach selber
Krams programmieren. Irgendein Magier wirds dann schon anschliessen....

-----------------------------------------------------------------------------



Re^9: Ein wunderschoenes Hallo, (Zook, 22. Dez 2003, 11:24:46):
~#! rn=Medic rt=1072088602 rg=gilden.zauberer
~#! tid=1071954621
Also ich wollte nix verwursten, ich hab den Anfang des Threads nur nicht
mitbekommen. 

Zook.

-----------------------------------------------------------------------------



Kabinett der magischen Spiegel (Amynthor, 22. Dez 2003, 11:40:01):
Als ich mir heute morgen die neuen Artikel ansah, freute ich mich und war
gleichzeitig bedrueckt. Inzwischen war mein neuer Spiegelraum angeschlossen
worden - ja, ich bin fuer die Aenderungen verantwortlich - und wurde, wie ich
schon befuerchtet hatte, mit viel Kritik aufgenommen. Da ich ein paar Tage
lang nicht da war, moechte ich nun Stellung dazu nehmen.

Schon seit einiger Zeit dachte ich daran, bei der Ueberarbeitung der
Zauberer-Gilde mitzuhelfen, bis ich vor ein paar Wochen etwas Zeit uebrig
hatte. Den Spiegelraum empfand ich als besonders trist, und so habe ich mich
mit seiner Gestaltung beschaeftigt und einiges so umgestaltet, wie es meiner
Empfindung nach eher zur Gilde passt oder mir einfach besser gefaellt.

In mehreren Artikeln wurde die Frage laut, warum die Funktionsweise der
Spiegel geaendert wurde: frueher habe ich sie oft als langweilig empfunden,
gerade einmal recht als Ausgang aus der Gilde. Nun bot sich mir auf diese
Weise die Gelegenheit, die Spiegel etwas interessanter (und umstaendlicher,
wie ich zugeben muss) zu gestalten. Dass man sie jedoch, wie Pale schrieb,
fuer eine Strafmassnahme halten kann, hat mich erschreckt.

Ich hoffe, dass ich euch das Spielen nicht zu sehr erschwert habe. Ich selbst
habe kein Problem damit, erst einmal zu schauen, welcher der Spiegel zu meinem
Ziel fuehrt, bevor ich blind hindurchgehe. Kritik gegenueber habe ich jedoch
ein offenes Ohr, auch wenn bisher nur Medic genauer geschrieben hat, was ihm
nicht gefaellt. (Danke, Medic!) Weitere Raeume werde ich mir uebrigens nicht
so schnell vornehmen, erst einmal habe ich andere Dinge vor.

Lasst Euch die Feiertage nicht verderben,

Amynthor


-----------------------------------------------------------------------------



Re: Kabinett der magischen Spiegel (Grumpf, 22. Dez 2003, 11:46:46):
~#! rn=Amynthor rt=1072089601 rg=gilden.zauberer
~#! tid=1072089601
Erst mal Grats zu dem Entschluss Dich hier zu outen nach all der Kritik ;-)
Aber mich beschaeftigen ein paar Fragen...
Kann man als relativ unerfahrener Spieler den Sinn und Unsinn einer Sache
wirklich komplett verstehen ohne die Gilde komplett zu kennen? (Ok, mag sein
das du noch nen Magister hast dann nehm ich das natuerlich zurueck.) Wie kommt
man als Spieler an Gildenfiles? Oder hast Du den Raum aus dem Bauch komplett
neu geschrieben? Und letztendlich wozu noch Magier werden?
Grumpf grumpft.

-----------------------------------------------------------------------------



Re: Re: Kabinett der magischen Spiegel (Karis, 22. Dez 2003, 13:24:02):
~#! rn=Grumpf rt=1072090006 rg=gilden.zauberer
~#! tid=1072089601
Eigentlich ist es doch voellig egal, ob Amynthor ein unerfahrener Spieler
ist oder eine Handvoll hoher Seher in der Familie hat. Tatsache ist, er hat
einen Vorschlag gemacht, wie man etwas, was ihm nicht adaequat schien,
veraendern koennte. Und er hat gleich noch Code geliefert, den ein Magier
hat anschliessen koennen. Ist doch lobenswert, oder? Dabei ist er auch 
durchaus nicht der erste, der diesen Weg geht.
Aber: verantwortlich fuer die Veraenderung ist der Magier, der den Code 
anschliesst. Der kann den Code dann an die entsprechenden Schnittstellen
hinhaengen. Wenn er das macht, gut. Wenn nicht, hat man sich die Arbeit
halt umsonst gemacht.
Und wenn Du glaubst, man muesse unbedingt Magier sein, um dem Mud etwas
Gutes zu tun - ok, sagen wir, um das Mud zu veraendern -, sei bitte auf die
Heerscharen der Magier Lvl 20 verwiesen, die es aus irgendwelchen Gruenden
nicht geschafft haben, das Mud zu veraendern. Ich persoenlich ziehe aber 
diejenigen vor, die selber Hand anlegen und sich nicht nur die 'Rechte' 
dazu verschaffen.

Karis, der das nicht als Anschiss an div. Magier verstanden haben will.

-----------------------------------------------------------------------------



Re: Kabinett der magischen Spiegel (Bran, 22. Dez 2003, 14:11:37):
~#! rn=Amynthor rt=1072089601 rg=gilden.zauberer
~#! tid=1072089601
Ich finde es prima, wenn jemand, ob Magier oder nicht, mal was tut, statt nur
zu maulen, wann Taramis angeschlossen oder die Gilde interessanter gestaltet
wird. Von daher: schoen, dass du da die Initiative ergriffen hast, Amynthor.
Allerdings verstehe ich deine Antwort auf die Fragen von Medic und den anderen
nicht ganz. Du sagst, der Raum sei dir zu langweilig gewesen und du wolltest
ihn interessanter gestalten, passender zur Gilde. Ich hab ihn mir angeschaut,
und mal ehrlich: was ist jetzt so viel interessanter? Es gibt keinerlei
commands (ausser dem Betreten der Spiegel, das es vorher schon gab) und 2 neue
Details, bei denen ich dachte, dass sie interessant sein koennten (Spiegelbild
und Versteinerung). Mit beiden konnte ich nicht viel anfangen (wenn ich da nur
ein Brett vorm Kopf habe und nicht auf den richtigen Befehl gekommen bin, nehm
ich das gern zurueck). Aber selbst wenn da was ginge, sehe ich nicht, dass
dadurch eine neue Atmosphaere geschaffen waere oder der Raum jetzt sonstwie
besser zur Gilde passen wuerde.

Ging es nicht doch in erster Linie einfach darum, den Weg durch die Spiegel
schwerer scriptbar zu machen? Ich will es ja nicht so sehen, aber der Verdacht
draengt sich mir einfach auf.

Gruss, Bran (gern bereit, sich vom Gegenteil ueberzeugen zu lassen)

-----------------------------------------------------------------------------



Neuer Portalraum (Vardion, 22. Dez 2003, 15:46:50):
Was mir an dem neuen Portalraum aufgefallen ist: ich finde es nett, dass
Magier immer wieder die selben Bugs produzieren. Wenn man in der Kneipe mal
eben "betrete portal" eingibt, wird man so grob 5 Sekunden spaeter in den
Spiegelraum transportiert - und zwar egal, ob man zu dem Zeitpunkt ueberhaupt
noch in der Kneipe steht, oder schon am anderen Ende des Muds ist. Mal wieder
ein netter Fluchtteleport mehr :-)

Insgesamt draengt sich nach einem fluechtigen Blick in den neuen Spiegelraum
der Eindruck auf, dass der Spiegelraum als scriptgeeigneter Ausgang aus der
ZGilde unbrauchbar gemacht werden sollte. Sowohl durch einfuegen der
5-Sekunden-Sequenz als auch durch verwuerfeln der Ziele.

Vardion

-----------------------------------------------------------------------------



Re: Neuer Portalraum (Zook, 22. Dez 2003, 15:52:14):
~#! rn=Vardion rt=1072104410 rg=gilden.zauberer
~#! tid=1072104410
Geht es nicht staendig um das gleiche? Dann bietet es sich doch in Ruecksicht-
nahme auf "ct" an, im Thread zu bleiben, oder?

Zook.

-----------------------------------------------------------------------------



Re: Re: Neuer Portalraum (Vardion, 22. Dez 2003, 15:54:11):
~#! rn=Zook rt=1072104734 rg=gilden.zauberer
~#! tid=1072104410
Oehm sorry. Fuer die naechsten 3 Tage duerfte es wohl auch ein "unsubscribe
g.z" tun :-)

Vardion

-----------------------------------------------------------------------------



Re: Re: Kabinett der magischen Spiegel (Thufhir, 22. Dez 2003, 17:27:32):
~#! rn=Bran rt=1072098697 rg=gilden.zauberer
~#! tid=1072089601
ich kann mich der meinung nur anschliessen, jede menge missing details in dem
neuen raum und ein move was nichtmal prueft, ob man noch im raum ist. das ist
eine stumpfe scripterschwerung, den koennen auch die eher laecherlichen
erklaerungsversuche nicht vertreiben. ich hatte es jeweils als sinnvoll
erachtet, dass hier nicht jede dumpfnase ohne ordentliche spielerfahrung was
anschliessen darf. dieses beispiel zeigt das nochmal ganz deutlich, besonders
wenn der magier dann ohne offensichtliche plausibilitaetspruefung des codes
diesen anschliesst. und dass medic der einzige mit anregungen war hab ich so
nicht gesehen. aber mit dem ignorieren (auch von argumenten) biste in feiner
gesellschaft, amynthor.

szzt

-----------------------------------------------------------------------------



Re: Kabinett der magischen Spiegel (Meister, 22. Dez 2003, 17:39:03):
~#! rn=Amynthor rt=1072089601 rg=gilden.zauberer
~#! tid=1072089601
Du spinnst wohl! Ich hab diesen Mist fabriziert, kannst mir doch nciht einfach
die Loorbeeren vom Brot klauen! Verkruemel dich wieder in dein Loch,
Plagiator!

-----------------------------------------------------------------------------



Re^3: Kabinett der magischen Spiegel (Grumpf, 22. Dez 2003, 18:40:51):
~#! rn=Foobar rt=1072114732 rg=gilden.zauberer
~#! tid=1072089601
Sobald er die neue Kaempfergilde fertig hat, allerdings hat die um das Feeling
zu verstaerken keinen Eingang, nicht mal fuer Magier. 
Grumpf grumpft.

-----------------------------------------------------------------------------



Re: Kabinett der magischen Spiegel (Toe, 22. Dez 2003, 21:01:11):
~#! rn=Amynthor rt=1072089601 rg=gilden.zauberer
~#! tid=1072089601
Also das alles ist schon sehr seltsam.
Weil jemand Langeweile hatte?
Seine Empfindungen umsetzen wollte?
Und jetzt wieder weg, da er andere Dinge vor hat?

Dann haette dieser gelangweilte Zauberer uns auch mit den Spiegeln verschonen
koennen.

toe

-----------------------------------------------------------------------------



Re: Re: Kabinett der magischen Spiegel (Humni, 22. Dez 2003, 22:00:50):
~#! rn=Toe rt=1072123271 rg=gilden.zauberer
~#! tid=1072089601
Ohne Wertung und ohne Einmischung in die Diskussion: Der Bug von Vardion
sollte nun draussen sein. Ihr koennt also aufhoeren, Skripte zu schreiben, die
ihn nutzen.

Und folgendes noch: Mir sieht der Code recht sauber aus. Den Fehler haette ich
auch mit Sicherheit uebersehen. Dennoch sehe ich persoenlich es lieber, wenn
Leute Magier werden, bevor sie was anschliessen, so faellt halt alles auf
Patryn zurueck. Aber wie gesagt, ich sehe mich da derzeit nicht genoetigt,
viel zu zu sagen.

Humni
PS: Nicht der Bug von Vardion, sondern den, den er gemeldet hat. Und in bester
megaschmarrn-Tradition die Antwort auf das letzte Posting in der Rubrik.

-----------------------------------------------------------------------------



Re^3: Kabinett der magischen Spiegel (Anatol, 22. Dez 2003, 22:16:56):
~#! rn=Humni rt=1072126850 rg=gilden.zauberer
~#! tid=1072089601
Es ist schnurzpiepegal, wer den Code geschrieben hat - der anschliessende
Magier ist dafuer verantwortlich. Auf Amydingens herumzuhacken ist daher
ziemlich daneben. Patryn ist das Ziel. Das hat noch den wichtigen Vorteil,
dass er den Spielerundank schon laenger gewohnt und in der Rolle des
Suendenbocks kein Unbekannter ist. ;)

Anatol


-----------------------------------------------------------------------------



Re^4: Kabinett der magischen Spiegel (Liara, 22. Dez 2003, 23:32:49):
~#! rn=Anatol rt=1072127816 rg=gilden.zauberer
~#! tid=1072089601
Du siehst den armen Patryn als Suendenbock? ;>
Du vergisst, dass er sich sein 'Ansehen' bei uns Zaubis hart erkaempft hat.
Nicht zuletzt durch zahllose voellig irrationale und inkonsequente Aussagen
und Handlungen und massives Gepoebel gegenueber den Gildenmitgliedern. Zum
Glueck ignoriert es uns ja inzwischen fast alle. :> Auch wenn er offen zugibt,
dass er zum Teil nicht mal mehr weiss, warum.

Liebe weihnachtliche Gruesse, ZZL

P. S.: Ich finde es besonders schaebig, in welcher Weise Patryn Amynthor durch
seine Nicht-Informationspolitik hier der Diskussion aussetzt.

-----------------------------------------------------------------------------



Re^5: Kabinett der magischen Spiegel (Bran, 22. Dez 2003, 23:38:22):
~#! rn=Liara rt=1072132369 rg=gilden.zauberer
~#! tid=1072089601
Naja, Amynthor hat sich dafuer hergegeben, Scheinargumente abgeliefert und
entsprechende Antworten dazu bekommen. So furchtbar viel Mitleid hab ich da
nicht. Ansonsten, klar: verantwortlich ist Patryn, vielleicht sagt er ja doch
noch was dazu.
Bran, ist mal gespannt.

-----------------------------------------------------------------------------



Re^6: Kabinett der magischen Spiegel (Patryn, 23. Dez 2003, 10:49:11):
~#! rn=Bran rt=1072132702 rg=gilden.zauberer
~#! tid=1072089601
Was soll ich dazu sagen, ich find den Raum gut und es waere gut,
wenn Amynthor die offenen Punkte die angesprochen wurden,
auch umsetzt.
Und Liara, Gepoebel ist immer ein zwischneidiges Schwert.
Sicher, ich bin nicht sehr diplomatisch hier, sicher, ich hab keine Lust,
mich vollnoelen zu lassen und denjenigen dann nicht zu ignorieren.
Ich ignoriere bestimmt keinen, weil er in die Gilde eingetreten ist.
Ansonsten nehme ich Leutte eh nicht ernst, die glauben, mit ein
paar Gefundenen oeffentlich verbreiteten notwendigen Nachbesserungen
hier hausieren zu gehen. Das schliesst auch Leute ein, die ich RL eigentlich
gut kinne *wink mit der finnischen Holzhuette*
Fuer mich jedenfalls, nennt mich sonstwas, sind die meisten Artikel hier
pure Jammerei.

-----------------------------------------------------------------------------



Re^7: Kabinett der magischen Spiegel (Bran, 23. Dez 2003, 10:58:10):
~#! rn=Patryn rt=1072172951 rg=gilden.zauberer
~#! tid=1072089601
Was Du sagen sollst? Die Frage, auf die Du noch immer nicht geantwortet hast,
ist, wozu die Aenderung gut war. Eine Verbesserung der
Gildenbeschreibung/-atmosphaere, wie behauptet wurde, ist es offensichtlich
nicht. Ich hab nichts dagegen, wenn Du das Scripten erschweren willst, nur sag
es dann doch offen. Ich lass mich einfach nicht gern fuer dumm verkaufen.

Gruss, Bran

-----------------------------------------------------------------------------



Re^8: Kabinett der magischen Spiegel (Grimmborn, 23. Dez 2003, 11:00:40):
~#! rn=Bran rt=1072173490 rg=gilden.zauberer
~#! tid=1072089601
Ich habe durchaus den Eindruck, dass die Aenderung die Stimmung und
Atmosphaere in der Jammerergilde sehr schoen weiterentwickelt hat. So eine
lange Jammerpause wie zuletzt ist man von dieser Gilde gar nicht gewohnt
gewesen.

GdA

-----------------------------------------------------------------------------



Re^8: Kabinett der magischen Spiegel (Patryn, 23. Dez 2003, 11:04:12):
~#! rn=Bran rt=1072173490 rg=gilden.zauberer
~#! tid=1072089601
Heut im Angebot, Ein dummes Bran, Fehlkauf...billig abzugeben ;)
Wenn Amynthor noch paar Details ergaenzt, ist doch alles in Butter.
Ich hab ihm nie was gesagt von Zeitsperre und rotierenden Spiegeln, das
waren seine Ideen und _ich_ kann mir das in einer Zaubergilde ziemlich gut
vorstellen, so ein Pentagramm, wo ich dann langsam verschwinde oder
diese _magischen_ rotierenden Spiegel, wo man abundzu auch mal nen
Blick draufwerfen muss und nicht Wegesystem xyz einmal im MUD-Leben
da durcholgern laesst.
Ich hatte in keiner Sekunde einen speziellen Blick auf tf und co, weil
ich der Meinung bin, dass sich prinzipiell alles Scripten laesst,
was mit dem Pentegramm immer noch nicht so schwierig ist.
Sicher, auch dann duest man immer nur durch den Raum durch, aber gerade
fuer die Nichtscripter wird die Vorstellung des ganzen Vorgangs, wie _ich_
meine, atmosphaerischer, unabhaengig davon, ob man wie heut uebertrieben
ueblich und Quasistandard 10 Millionen Detailebenen beschrieben hat.

-----------------------------------------------------------------------------



Re^9: Kabinett der magischen Spiegel (Bran, 23. Dez 2003, 11:05:53):
~#! rn=Patryn rt=1072173852 rg=gilden.zauberer
~#! tid=1072089601
Zitat: Und Liara, Gepoebel ist immer ein zwischneidiges Schwert.

Mehr faellt mir dazu echt nicht mehr ein. Gruss, Bran


-----------------------------------------------------------------------------



Re^9: Kabinett der magischen Spiegel (Nedime, 23. Dez 2003, 11:18:11):
~#! rn=Patryn rt=1072173852 rg=gilden.zauberer
~#! tid=1072089601
Ich find es durchaus verblueffend, wie aus einer harmlosen Anfrage eines
Spielers eine solches Geflame entstehen kann. Irgendwie steh ich immer 
fuer die Spieler proggen und deren Wuensche oder Kritik auch ernstnehmen
sollten. Und damit meine ich vor allem, wenn auch nicht nur diejenigen
Spieler, die hier wirklich viel aktiv sind, denn sie geben oft hilfreiches
Feedback und tragen eine Menge zum MG bei, sei es nun als Testspieler oder
durch gute Ideen. 
Insofern ist mir Deine Reaktion voellig unverstaendlich, Patryn.

Gruss Miril

-----------------------------------------------------------------------------



Re^10: Kabinett der magischen Spiegel (Nedime, 23. Dez 2003, 11:19:21):
~#! rn=Nedime rt=1072174691 rg=gilden.zauberer
~#! tid=1072089601
Mist wenn man zwischendurch immer rausfliegt ;-). Dazwischen fehlte eine
Zeile:
Irgendwie steht ich immer noch auf dem Standpunkt, dass wir fuer die Spieler
proggen.... sollte das heissen.

-----------------------------------------------------------------------------



Re^9: Kabinett der magischen Spiegel (Taranis, 23. Dez 2003, 11:19:43):
~#! rn=Patryn rt=1072173852 rg=gilden.zauberer
~#! tid=1072089601
Mal ne Verstaendnisfrage: Was haben denn rotierende Spiegel / Spiegel mit
wechselnden Zielen speziell mit Zauberern zu tun? Meiner Meinung nach wuerde
das eher zu Chaoten passen. Zauberer werden ja wohl in der Lage sein, stabile
Portale zu erschaffen...
Beim Langsamverschwinden im Pentagramm fuehle ich mich auch eher an das Beamen
aus StarTrek erinnert. *g* Soviel zum Gildenfeeling, was fuer mich jetzt eher
schlechter als vorher ist.

Alles IMHO, Taranis

-----------------------------------------------------------------------------



Re^10: Kabinett der magischen Spiegel (Foobar, 23. Dez 2003, 11:22:55):
~#! rn=Taranis rt=1072174783 rg=gilden.zauberer
~#! tid=1072089601
Und weil das Langsamverschwiden so stylish ist, wird Teleport hoffentlich bald
auch geaendert. ;o)

-----------------------------------------------------------------------------



Re^10: Kabinett der magischen Spiegel (Anatol, 23. Dez 2003, 11:24:46):
~#! rn=Taranis rt=1072174783 rg=gilden.zauberer
~#! tid=1072089601
Hey, wie waere es mit einem "Gildenportalraum-Contest"? Jeder, der mag und
kann, darf einen Gildenportalraum entwerfen (zzgl. der Methoden, dort
hineinzugelangen) und dann wird demokratisch abgestimmt, welcher Portalraum
der stimmungsvollste ist. :)

Fuer freizuegige Werte von "demokratisch", natuerlich... :)

Anatol hat schon gaaaaanz viele Ideen. :)


-----------------------------------------------------------------------------



Re^11: Kabinett der magischen Spiegel (Grimmborn, 23. Dez 2003, 11:25:57):
~#! rn=Foobar rt=1072174975 rg=gilden.zauberer
~#! tid=1072089601
...und das magische Feld des Morgengrauens vertraegt nur einen Teleport auf
einmal. Wenn Leute zur exakt gleichen Zeit teleportieren, kann es schonmal
vorkommen, dass die Ziele verwechselt werden. Oder dass man in seinem
gewohnten Koerper wegteleportiert, aber als Frosch ankommt (was bei den
Spitzohren allerdings Spielerhilfe waere).

GdA

-----------------------------------------------------------------------------



Re^7: Kabinett der magischen Spiegel (Turbo, 23. Dez 2003, 11:42:39):
~#! rn=Patryn rt=1072172951 rg=gilden.zauberer
~#! tid=1072089601
Hmm, vielleicht sollte ich mich ja ganz raushalten ..
aber zu spaet.

Ich habe bisher das Konzept eines fuer eine Gilde verantwortlichen
Magiers, Wizard oder wie das wo immer auch hiess (jedenfalls des
fuer die Gilde verantwortlichen Programmierenden) so aufgefasst,
dass der/die die Konzepte der Gilde gut kennt, umsetzt und pflegt
und sie in Kommunikation mit den der Gilde angehoerigen Spielern
realisiert und aendert, wobei das Feedback der Anwender, also
der Spieler, schon eine Rolle spielen sollte.

Typischerweise kenne ich es eigentlich eher so, dass der
oder die Gildenverantwortliche Partei fuer "seine/ihre"
Spieler ist und der Ausgleich gegenueber der Gesamtanwendung
bei Admins und Balance liegt.

Das Konzept "ich progge was ich will und fuer richtig halte,
was die Benutzer dazu meinen, ist mir voellig egal und wer
meckert, kommt auf ignore" erscheint mir zumindest erheblich
eigenwillig und reichlich autistisch.

Aber vielleicht habe ich da auch was falsch verstanden.

Turbo (stets neugieriger Kater)

-----------------------------------------------------------------------------



Re^10: Kabinett der magischen Spiegel (Patryn, 23. Dez 2003, 12:25:53):
~#! rn=Taranis rt=1072174783 rg=gilden.zauberer
~#! tid=1072089601
Na da sieht man mal wie unterschiedlich Meinungen so sein koennen.
Ich zumindest kenne nich viele Portale / Zauberspiegel in Buechern
ueber Zauberer und Magie, die derart festgenagelt zuverlaessig funktionierten,
wie die alte Super-MUD-Kreuzung.
Ueberhaupt sind Zauber oft chaotisch angehaucht, was die Zuverlaessigkeit
angeht, so strikt trennbar ist das nicht, wie manche Polemik weissmachen will.
Genauso stehts mit langsam verschwinden, an Star Trek magst Du dabei
denken, ich hab die Parallele ueberhaupt erst gesehen als Du sie
angesprochen hast.
Und zum Flamen gehoeren immer 2, Miril, wobei es ein Unterschied ist,
ob man offensichtlich flappsig einen Kommentar eines vorherigen Artikels
aufgreift, falls Du Dich grad auf Bran bezogst, die nun mal alles
unbedingt ernst nehmen will. Kannich nich aendern.

-----------------------------------------------------------------------------



Re^11: Kabinett der magischen Spiegel (Grimmborn, 23. Dez 2003, 12:31:36):
~#! rn=Patryn rt=1072178753 rg=gilden.zauberer
~#! tid=1072089601
Hier nur eine sachliche Richtigstellung, Du verwechselst da was: zum flamen
reicht einer. Zum streiten gehoeren zwei.

GdA

-----------------------------------------------------------------------------



Re^12: Kabinett der magischen Spiegel (Patryn, 23. Dez 2003, 12:34:32):
~#! rn=Grimmborn rt=1072179096 rg=gilden.zauberer
~#! tid=1072089601
Ah stimmt...na dann streiten wir uns also.
So eine richtige flame sehe ich auch noch nicht, dafuer muss man dann
wohl doch zu heise gehen oder hier noch etwas warten ;)

-----------------------------------------------------------------------------



Re^11: Kabinett der magischen Spiegel (Taranis, 23. Dez 2003, 13:23:32):
~#! rn=Patryn rt=1072178753 rg=gilden.zauberer
~#! tid=1072089601
Ja, genau, so unterschiedlich koennen Meinungen sein. Daher kann man solche
Sachen wie "Feeling wird duch xy verbessert" auch nicht einfach so festlegen
und erwarten, dass das immer von allen/der Mehrzahl auch so gesehen wird. Wenn
man solche stark unterschiedlich empfundenen Dinge dennoch vorgibt, muss man
damit rechnen, dass der Feedback evtl. kritisch ausfaellt (uebrigens
berechtigterweise, denn wenn Bran sagt, ihr Gildenfeeling wird dadurch nicht
verbessert, hat sie genauso recht wie Patryn, der sagt, dass seins nun besser
ist). In diesem Fall empfinden anscheinend die meisten Leute aehnlich wie Bran
oder ich, ich finde es nicht gerechtfertigt, diese alle einfach zu ignorieren
bzw. ihre Postings als Gejammer abzutun.
Ist es denn so schlimm, bei derartigen "Gefuehls"-Aenderungen das einfach mal
anzusprechen und zu schauen, wie die Resonanz ist? Ich finde nicht, dass man
sich damit einen Zacken aus der Krone bricht oder sein Autoritaet schwaecht.
Denn letztendlich schadet man, wenn viele Gildenmitglieder die Aenderungen
nicht fuer gelungen/sinnvoll halten, der Gilde, die bei vielen Mitgliedern an
Attraktivitaet verliert.
Und bevor jetzt hier jemand einwirft, dass das MG keine Demokratie ist: Ja,
ich weiss das. Aber wenn man nicht an der Meinung anderer interessiert ist und
man auf Interaktion mit den den Mitspielern keinen Wert legt, kann man auch
gleich im Homemud spielen bzw. dafuer proggen.
Wenn man bei bestimmten Dingen im Vorfeld miteinander spricht, kann man oft
Enttaeuschung auf beiden Seiten vermeiden, Enttaeuschung bei den Mitspielern,
die eine Aenderung nicht so doll finden und Enttaeuschung beim Programmierer,
der seine Arbeit nicht honoriert sieht.

Just my 2 cents und jetzt koennt ihr meinetwegen mein Posting mit "heul doch"
oder "Gejammer" kommentieren, aber 1. erwartet dann keine Antwort von mir und
2. geht mir das dann auch irgendwo vorbei,
Taranis

-----------------------------------------------------------------------------



Re^12: Kabinett der magischen Spiegel (Morgoth, 23. Dez 2003, 14:08:11):
~#! rn=Taranis rt=1072182212 rg=gilden.zauberer
~#! tid=1072089601
Sacht mal, es gibt ne Rubrik "gejammer", die is sogar leer. Koennt ihr das
nicht dahin verlegen? Hier steht eh nix sinnvolles mehr zu der Aenderung drin
und gejammer hab ich abbestellt.

M*

-----------------------------------------------------------------------------



Re^11: Kabinett der magischen Spiegel (Zook, 23. Dez 2003, 14:28:37):
~#! rn=Anatol rt=1072175086 rg=gilden.zauberer
~#! tid=1072089601
Ah, ich las was von "demokratisch"... Wird Zeit, den Thread zu uebergehen.

Zook.

-----------------------------------------------------------------------------



Re^12: Kabinett der magischen Spiegel (Zook, 23. Dez 2003, 14:36:26):
~#! rn=Taranis rt=1072182212 rg=gilden.zauberer
~#! tid=1072089601
Variante 3 fehlte: Gar nicht bis zum Ende durchlesen, weil der Artikel
ein "too-long-article"-Error geworfen hatte ;)

Zook.

-----------------------------------------------------------------------------



Re^11: Kabinett der magischen Spiegel (Liara, 23. Dez 2003, 19:37:10):
~#! rn=Anatol rt=1072175086 rg=gilden.zauberer
~#! tid=1072089601
Hm, eigentlich dachte ich, Ark waere fuer das Gildenfeeling zustaendig.

-----------------------------------------------------------------------------



Re^12: Kabinett der magischen Spiegel (Liara, 23. Dez 2003, 19:41:34):
~#! rn=Zook rt=1072186117 rg=gilden.zauberer
~#! tid=1072089601
Naja. Da dieses die Zaubirubrik ist, koennte demokratisches Gejammer ja ganz
nett sein.

-----------------------------------------------------------------------------



Re^12: Kabinett der magischen Spiegel (Ark, 29. Dez 2003, 13:11:28):
~#! rn=Liara rt=1072204630 rg=gilden.zauberer
~#! tid=1072089601
Noe. Die Kollegen nennen sich nicht Zauberer :-)
Bei der Gelegenheit, ich suche noch einen Gildenschreiber.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^13: Kabinett der magischen Spiegel (Darklor, 31. Dez 2003, 05:44:47):
~#! rn=Ark rt=1072699888 rg=gilden.zauberer
~#! tid=1072089601
Einen wie Amynthor?

Darklor

-----------------------------------------------------------------------------



Re^11: Kabinett der magischen Spiegel (Schlips, 20. Feb 2004, 19:38:20):
~#! rn=Anatol rt=1072175086 rg=gilden.zauberer
~#! tid=1072089601
Au ja - und dann bauen wir damit einen Gildenportalraumturm und jeder
sucht sich seinen Lieblingsportalraum - aeh Lieblingsgildenportalraum 
aus ...

Schlips ist begeistert

-----------------------------------------------------------------------------



Der gute Schutz (Humni, 14. Mar 2004, 20:09:28):
Huhu Zaubis.,
huhu Tanjians,
huhu Chaoten,

leider muss ich Euch mitteilen, dass der Schutz der Zauberer auf Euren
Haeuptern nun leider verblasst. Eure Magiearten waren leider doch nicht so
kompatibel, wie urspruenglich gedacht...

(OK, die Aussage gilt so natuerlich nicht fuer Zauberer, da es ihre Spells
betrifft, sollte das aber verkuendet werden).

So. Nun beginnt mich zu zerreissen.

Humni

-----------------------------------------------------------------------------



Re: Der gute Schutz (Humni, 14. Mar 2004, 20:13:46):
~#! rn=Humni rt=1079291368 rg=gilden.zauberer
~#! tid=1079291368
OK. Da wohl nicht jeder verstanden hat, was ich sagen will:

1. Der Schutz wirkt immer noch. Auf jeden.
2. Der Schutz wirkt schwaecher als BISHER auf Chaoten und Tanjian. Auf alle
anderen Gilden wirkt er unveraendert.

Humni

-----------------------------------------------------------------------------



Re: Re: Der gute Schutz (Darklor, 15. Mar 2004, 18:19:39):
~#! rn=Humni rt=1079291626 rg=gilden.zauberer
~#! tid=1079291368
Magier abwerten? ;)

Darklor

-----------------------------------------------------------------------------



Re^3: Der gute Schutz (Chuckylein, 21. Mar 2004, 15:38:21):
~#! rn=Darklor rt=1079371179 rg=gilden.zauberer
~#! tid=1079291368
lauter heulen :)

-----------------------------------------------------------------------------



Laden (Morgoth, 25. Mar 2004, 09:16:35):
Wegen eines Bugs gibts im Laden im Moment nix mehr zu kaufen...Patryn wird
sich sicherlich so schnell wie moeglich drum kuemmern, Mail ist raus :)

M*

-----------------------------------------------------------------------------



Laeden + Flaschen (Morgoth, 16. Apr 2004, 11:03:16):
Hi Zaubis

ich hab mir mal wieder den schwarzen Peter angezogen und die Alchemielaeden
der Kauf-Kommandos entledigt. Es scrollt wie teufel, wenn ihr hunderte
Flaschen kauft und die nicht mehr tragen koennt. Bis das erledigt ist (der Bug
ist schon alt), wirds wohl erstmal nix zu kaufen geben.

M*

-----------------------------------------------------------------------------



Re: Laeden + Flaschen (Patryn, 16. Apr 2004, 22:12:29):
~#! rn=Morgoth rt=1082106196 rg=gilden.zauberer
~#! tid=1082106196
wenn ftp wieder geht...

-----------------------------------------------------------------------------



Re: Re: Laeden + Flaschen (Humni, 16. Apr 2004, 23:31:23):
~#! rn=Patryn rt=1082146349 rg=gilden.zauberer
~#! tid=1082106196
Weichei.

  ;-)

Der Laden geht wieder.

Humi (hat das mit ed gefixt).

-----------------------------------------------------------------------------



Re^3: Laeden + Flaschen (Morgoth, 17. Apr 2004, 00:05:17):
~#! rn=Humni rt=1082151083 rg=gilden.zauberer
~#! tid=1082106196
Wehe wenn nicht, dann muss ich die armen Zauberer schon wieder mit meinen
Kuensten begluecken.

M*

-----------------------------------------------------------------------------



Re^4: Laeden + Flaschen (Humni, 17. Apr 2004, 00:08:38):
~#! rn=Morgoth rt=1082153117 rg=gilden.zauberer
~#! tid=1082106196
Wir werden sehen ;-) ich garantiere fuer nix, vermute aber, das passt.

Humni

-----------------------------------------------------------------------------



Licht... (Humni, 26. Jun 2004, 15:05:46):
Huhu,

ja, ab sofort sollte Licht an /aus auch so gehen, wie es eigentlich gehen
sollte, vor allem mit dem zuruecksetzen.

Bugreports dazu bitte an mich, da Patryn offenbar derzeit wenig Zeit hat.

Und sorry an Bambi, dass ich das damals nicht kapiert hab, als er mir den Bug
vor Ewigkeiten schonmal erklaert hat und ich zu doof war zu kapieren, was er
meint.

Der boesartige, schreckliche, gemeine und furchtbar fiese Drache Humni

-----------------------------------------------------------------------------



ihhh....forschen (Patryn, 24. Jul 2004, 21:58:46):
Dank Ark koennt ihr nun wieder mal dumpfes Ueben gegen unheimlich tolles
Forschen eintauschen.
Ach was sage ich: Ihr muesst es sogar, wenn Ihr Erzmagister werden wollt,
aber wer will das schon ;)

-- 
patryn

-----------------------------------------------------------------------------



Ein spezieller Ring (Arathorn, 14. Sep 2004, 20:42:15):
hat sich ueberreden lassen, Eure Spells wieder zu unterstuetzen. Diese
Faehigkeit war ihm vor kurzem abhanden gekommen, und Vanion war so nett,
ihn daran zu erinnern. ;-)

Ihr wisst, was ich meine, naemlich diesen Ring aus dem Grimmswald...

Gruss, Arathorn.

-----------------------------------------------------------------------------



Selbstverwandlung (Humni, 14. Sep 2004, 23:24:24):
Da dieser Spell wohl nur genutzt wird um Bugs zu nutzen, sich toll vorzukommen
und PKs zu provozieren habe ich ihn vorerst abgehaengt, bis wir eine
vernuenftige Loesung dafuer finden, wie man ihn gefahrlos einsetzen kann.

Humni

-----------------------------------------------------------------------------



Re: Selbstverwandlung (Morgoth, 14. Sep 2004, 23:26:48):
~#! rn=Humni rt=1095197064 rg=gilden.zauberer
~#! tid=1095197064
Gar nicht? 

M*

-----------------------------------------------------------------------------



Re: Selbstverwandlung (Rasiel, 15. Sep 2004, 00:22:22):
~#! rn=Humni rt=1095197064 rg=gilden.zauberer
~#! tid=1095197064
Hallo!

Erstmal muss ich mich entschuldigen fuer diese Sache. Das der Spruch 
abgehangen wurde, ist meine Schuld. Nur falls Ihr den Schuldigen sucht. 

Zu meiner Verteidigung: ich hatte den Spruch neu gelernt und wie es 
so ist, will man die Moeglichkeiten testen. Also Verwandlung als 
Dunkelelf und runter zu denen -> klappt. Dann hatte ich halt den 
Blitzgedanken, hey moeglicherweise kommt man damit an den Eisriesen 
etc. in der Schreckensspitze vorbei ohne zu metzeln. Tja und da isses 
dann passiert, dass ich unbeabsichtigter Weise andere Spieler behindert 
habe. Ich wiederhole noch einmal, es lag nicht in meiner Absicht andere 
Spieler zu behindern oder einen PK zu provozieren bzw. einen Bug 
auszunutzen. Das Ganze halt nach 10 bis 20 Minuten Benutzung dieses 
Spells. Sprich drei, vier Mal gezaubert.

Bezueglich PK und so steht ja in der Spruchbeschreibung auch noch drin, 
dass das abgefangen wird. Wie soll ich also nach so kurzer Zeit der 
Benutzung die Erfahrung haben, dass dem nicht so ist, wie von Humni 
angemerkt wurde. 

Wie gesagt, ich entschuldige mich bei Euch dafuer, mehr kann ich im 
Endeffekt auch nicht machen.


Rasiel

PS: Ich hoffe die Formatierung des Artikels haut hin.

-----------------------------------------------------------------------------



Re: Re: Selbstverwandlung (Bran, 15. Sep 2004, 10:40:54):
~#! rn=Rasiel rt=1095200542 rg=gilden.zauberer
~#! tid=1095197064
Soweit ich weiss, wird PK insofern schon abgefangen, als direkt beim ersten
Schlag sowohl Selbstverwandlung als auch Kampf beendet werden. So war das
jedenfalls noch, als ich Wandlungsmagister war. Die Magier bekommen dann schon
eine Meldung ueber einen PK-Versuch, das sollte aber auch alles sein. Im
uebrigen, _wenn_ sowas alle Jubeljahre mal vorkommt, betrifft es doch wohl wie
in diesem Fall einen neuen Wandlungsmagister, und dann wuerde ich denken, es
genuegt, wenn der Betreffende an diesem Punkt darauf hingewiesen wird, was
passieren kann (was er dann wahrscheinlich sowieso schon gemerkt hat).

Wenn es tatsaechlich ein Wandlungsmagister per SV auf PK-Provokation anlegen
sollte, warum ihn nicht genauso bestrafen (jailen oder wwi) wie jeden anderen
Spieler, der das mit anderen Mitteln versucht? Den Spruch abzuhaengen, halte
ich fuer ziemlich ueberzogen und nicht besonders sinnvoll. Und schade finde
ich es ausserdem, SV mag ja nicht der nuetzlichste Spell sein, aber man kann
viel Spass damit haben.

Bran, Rasiel aufmunternd am Kinn kitzelnd

-----------------------------------------------------------------------------



Re^3: Selbstverwandlung (Muadib, 15. Sep 2004, 11:52:11):
~#! rn=Bran rt=1095237654 rg=gilden.zauberer
~#! tid=1095197064
der missbrauch von sv ist kein element dass nur jubeljahrweise auftritt
leider

-----------------------------------------------------------------------------



Re^3: Selbstverwandlung (Morgoth, 15. Sep 2004, 12:16:30):
~#! rn=Bran rt=1095237654 rg=gilden.zauberer
~#! tid=1095197064
"...SV mag ja nicht der nuetzlichste Spell sein..." 
Hab ich da was verpasst oder hast Du einfach nur die macht dieses Spruches
nicht ganz kapiert?

M* wedelt mit dem "Zauberer loeschen"-Faehnchen

-----------------------------------------------------------------------------



Re^4: Selbstverwandlung (Medic, 15. Sep 2004, 13:27:50):
~#! rn=Morgoth rt=1095243390 rg=gilden.zauberer
~#! tid=1095197064
In dem Fall hab ich sie auch nicht ganz kapiert, die angebliche Macht. Ad hoc
faellt mir ausser "Spass haben" zu dem Spruch nicht wirklich viel ein, wo man
Ihn spielgestaltend sinnvoll einsetzen koennte....
Waere es dreist, um Erklaerung zu bitten?

-----------------------------------------------------------------------------



Re^5: Selbstverwandlung (Ark, 15. Sep 2004, 14:31:54):
~#! rn=Medic rt=1095247670 rg=gilden.zauberer
~#! tid=1095197064
Da sich kaum jemand findet, der solche Sachen mal foerdernd in seine Gebiete
einbaut ...
Ich greif mich an der Nase und mach mal.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^6: Selbstverwandlung (Humni, 15. Sep 2004, 14:36:40):
~#! rn=Ark rt=1095251514 rg=gilden.zauberer
~#! tid=1095197064
So. Da will ich Ark natuerlich nicht im Wege stehen. Der Spell ist wieder da,
wir werden sehen, was sich machen laesst (nicht zuletzt, da neue
Wandlungsmagister sonst auch keine Chance haben, an wandlung zu kommen).

Nur warne ich hiermit sehr eindringlich davor, diesen Spell zu missbrauchen.
Und ums klar zu sagen: Sich als SSP-Blocker zu verkleiden faellt unter
Missbrauch.

Weitere Einschraenkungen koennen jederzeit folgen. Nicht nur wegen der PKs,
auch wegen unerwuenschten anderen Effekten.

Humni

-----------------------------------------------------------------------------



Re^7: Selbstverwandlung (Medic, 15. Sep 2004, 17:43:41):
~#! rn=Humni rt=1095251800 rg=gilden.zauberer
~#! tid=1095197064
Besten Dank,

klappt denn nun trotzdem fuer den Fall des Falles die Abfangroutine,
dass sv und kampf beendet werden, falls spieler selbstverwandelte andere
spieler angreifen?

Gruss,
ein Anfuehrer der Or^W^W^W^WMedic

-----------------------------------------------------------------------------



Re^8: Selbstverwandlung (Chagall, 15. Sep 2004, 17:44:33):
~#! rn=Medic rt=1095263021 rg=gilden.zauberer
~#! tid=1095197064
Ich wuerd ja jetzt einfach sagen. Probiers aus.

Chagall.

-----------------------------------------------------------------------------



Re^9: Selbstverwandlung (Humni, 15. Sep 2004, 17:54:13):
~#! rn=Chagall rt=1095263073 rg=gilden.zauberer
~#! tid=1095197064
Eine Einschraenkung haben wir aber schon gemacht: In Spieler kann man sich
nicht mehr verwandeln. Danke an Medic, der gerade alles testen musste, was nun
auch funktioniert.

Humni

-----------------------------------------------------------------------------



Re: Licht... (Bran, 15. Sep 2004, 22:30:25):
~#! rn=Humni rt=1088255146 rg=gilden.zauberer
~#! tid=1088255146
Dankeschoen, Humni - schoen, dass sich jemand um all diese Sachen kuemmert.
Auch wenn ich erstmal rumgemeckert habe wegen der SV-Abhaengung. Die ja nun
auch neben der Bug-Reduzierung vielleicht noch was richtig Gutes bewirkt
hat...

Bran, gespannt in Richtung Ark schielend.

-----------------------------------------------------------------------------



Re^7: Selbstverwandlung (Thufhir, 17. Sep 2004, 11:16:36):
~#! rn=Humni rt=1095251800 rg=gilden.zauberer
~#! tid=1095197064
Hallo zusammen,

mal von dem Spell ganz abgesehen, warum werden nicht endlich die Bugs in der
SSP ausgebaut? Es gibt ja auch noch andere Moeglichkeiten als die
Zauberergilde. Und dass in der SSP keine Special-IDs benutzt werden ist ja nun
schon seit Jahren bekannt.

2 Cents, s'ZZT

-----------------------------------------------------------------------------



Re^8: Selbstverwandlung (Morgoth, 17. Sep 2004, 11:19:16):
~#! rn=Thufhir rt=1095412596 rg=gilden.zauberer
~#! tid=1095197064
Nun, diese IDs habs schon lange bevor Spieler irgendwelche Sachen machen
konnten, denen sie IDs verpassen konnten. Also hat sich gefaelligst dieses
neumodische Zeugs anzupassen und nicht die alt eingediente SSP.

M*

-----------------------------------------------------------------------------



Re^8: Selbstverwandlung (Boing, 17. Sep 2004, 11:22:56):
~#! rn=Thufhir rt=1095412596 rg=gilden.zauberer
~#! tid=1095197064
Die IDs aendere ich nicht, weil ich nicht einsehe dass ich Arbeit fuer
Leute investieren soll, die bewusst (!) das Spiel stoeren.
  Boing

-----------------------------------------------------------------------------



Re^9: Selbstverwandlung (Gloinson, 17. Sep 2004, 11:25:48):
~#! rn=Boing rt=1095412976 rg=gilden.zauberer
~#! tid=1095197064
Ui. Ein Magier, der sich der Feature-Konfrontation Spieler<->Magier
verschliesst. Wenigstens weiss ich jetzt endlich, warum du diverse andere
ID-Checks auch nicht geaendert hast. [Kritzel in Notzbuch mach]


-----------------------------------------------------------------------------



Re^9: Selbstverwandlung (Mupfel, 17. Sep 2004, 13:41:16):
~#! rn=Boing rt=1095412976 rg=gilden.zauberer
~#! tid=1095197064
Richtig so! Warum ueberhaupt diese IDs mit \n ueberall einfuehren? Alles
Quatsch. Seit wann programmieren wir hier Code, um Spielstoerern und anderen
missguenstigen Gesellen das Leben schwer zu machen?

-mupfel-

-----------------------------------------------------------------------------



Re^10: Selbstverwandlung (Darkwing, 17. Sep 2004, 16:35:13):
~#! rn=Mupfel rt=1095421276 rg=gilden.zauberer
~#! tid=1095197064
Ein Objekt namens "Padreic teilt Dir mit: Moment hier bugts" und der id "Ork"
ist auch eine Form von Spass :-))

Darkwing

-----------------------------------------------------------------------------



Re^11: Selbstverwandlung (Nizzl, 18. Sep 2004, 13:24:58):
~#! rn=Darkwing rt=1095431713 rg=gilden.zauberer
~#! tid=1095197064
--nur zufaellig auf den letzten Artikel geantwortet--

Der einzige (mir bekannte) Nutzen von SV ist eigentlich, dass man
sich ein gewisses Nibelungenquest-Item bzw. die Rassenzugehoertigkeit
einer bestimmten Rasse in einem bestimmten Gebiet sparen kann.
(Ihr wisst schon was gemeint ist)

Schoen faende ich jetzt z.B. wenn SV richtig Sinnvoll eingesetzt
werden koennte und sich nicht wie bereits erwaehnt nur als spassiges
Feature oder zum Ausnutzen von unsauber programmierten Stellen im
Mud (=Bugs) nutzen laesst. Da SV im Vergleich zu den anderen Glvl9
Spells doch deutlich zuruecksteht.

Eine imo gute Moeglichkeit waere z.B. eine Art Unsichtbarkeit, mit 
der man dann manche Block-Npc (keine NPCs mit Guardfunktion) "ueber-
gehen" kann oder gar vor  Autoattackern sicher ist. Fuer Spieler sollte
man dann natuerlich (*g*) aus logischen Gruenden weiterhin sichtbar
bleiben.

Zum Thema SSP, Eisriesen, Kampfbleche etc.: Man muss natuerlich be-
denken, dass dieses immer noch schoene "Kultgebiet" aus einer Zeit
stammt, in der das muddden bzw. der Mudder an sich noch einen etwas
anderen Stellenwert hatte. Wo Fehler bzw. Bugs auftauchen werden sie
heute halt einfach be- bzw genutzt, da kann man so viel jammern wie man
will, ist einfach so.

Ohne jetzt naeheres ueber den Code zu wissen, noch mich sonst irgendwie
auszukennen, wuerde ich vermuten, dass in der SSP (in vielen anderen
Gebieten uebrigends auch) die Blockfunktion durch eine (umstaendliche?)
Id- bzw. if present Abfrage funktioniert. Hat natuerlich den Nachteil, 
dass bekannterweise jeder mit oben genanntem Questobjekt, jeder mit
SV, jeder Spieler mit "unguenstigem" Namen und sogar erschaffene Objekte
die Moeglichkeit haben hier Wege fuer andere zu versperren. Im 
unguenstigesten Fall kommt das ganze Wochenende kein Spieler mehr in 
die SSP (bzw raus :)).

Hier sollte man meiner Meinung nach schon ein bisschen nachbessern.
z.b. einfach ein AddCmd (oben, kampfsprung oben) in(!) den entsprechenden
NPC schreiben. SOll jetzt natuerlich keine Kritik sein sondern nur mein
Standpunkt kundtun.

Um es kurz zu machen, bzw. um zurueck zum Thema zu kommen....
Selbstverwandlung entweder etwas umgestalten wie z.B. das der Selbst-
verwandelte noch eine zusaetzliche Bezeichung bekommt [*1], so dass er 
nicht mehr allzuleicht verwechselt werden kann, oder die komplette
Funktion von SV aendern wie oben als Beispiel mit "Unsichtbarkeit"
angesprochen, oder man laesst alles beim alten, vertraut auf die
Intelligenz der Spieler und muss sich halt ab und zu um kleinere
Vorfaelle (Gejammer) kuemmern.



[*1]

Bisher:
]selbstverwandlung -m Muellschlucker -->
]Ein Muellschlucker.

Aenderungsmoeglichkeit
]selbstverwandlung -m Muellschlucker -->
]Ein Muellschlucker..

Rechtschreibfehler oder Aeusserungen die einzelnen Personen missfallen 
koennten bitte ich zu entschuldigen :)

-----------------------------------------------------------------------------



Re^9: Selbstverwandlung (Ogo, 18. Sep 2004, 13:52:19):
~#! rn=Boing rt=1095412976 rg=gilden.zauberer
~#! tid=1095197064
Ein Glueck gibt es ja Regionsmagier, die ungewartetenden Code (in dem Bugs
nicht ausgebaut werden) reparieren...

Bambi uebernehmen Sie!

Ogo, lakonisch


-----------------------------------------------------------------------------



Wo wir grade so schoen am jammern sind... (Medic, 18. Sep 2004, 21:54:46):
Wo wir grade so schoen am jammern sind...
Aber im Ernst, waere es nicht eine moeglichkeit, den gimmicks "Weihe" bzw
"Verfluche" Zauberstab ihre Funktion zu geben? Vielleicht als Stabschaden? ein
"verletze mit heilig" muss es ja zugegebenermassen nicht gleich sein.

Obwohl.... ;-)

Was sagt denn unser GM eigentlich dazu? :-)

-----------------------------------------------------------------------------



Re: Wo wir grade so schoen am jammern sind... (Croft, 19. Sep 2004, 01:19:18):
~#! rn=Medic rt=1095537286 rg=gilden.zauberer
~#! tid=1095537286
Spaetestens der Gilden-EM wird mit dem Abgelehnt-Faehnchen wedeln ,o)

Croft

-----------------------------------------------------------------------------



Re: Re: Wo wir grade so schoen am jammern sind... (Darklor, 19. Sep 2004, 01:21:52):
~#! rn=Croft rt=1095549558 rg=gilden.zauberer
~#! tid=1095537286
Stellt doch mal n richtigen Gilden-EM ein, der das ganze wieder etwas aufpeppt
- und nich noch mehr einreisst...

Darklor ;)

-----------------------------------------------------------------------------



Re^3: Wo wir grade so schoen am jammern sind... (Ahab, 19. Sep 2004, 01:23:22):
~#! rn=Darklor rt=1095549712 rg=gilden.zauberer
~#! tid=1095537286
:weist mal vorsichtig auf den Unterschied zwischen GM und Gilden-EM hin.

Ahab.

-----------------------------------------------------------------------------



Re^4: Wo wir grade so schoen am jammern sind... (Gloinson, 19. Sep 2004, 01:23:52):
~#! rn=Ahab rt=1095549802 rg=gilden.zauberer
~#! tid=1095537286
Hautpsache man kann die bashen ;)


-----------------------------------------------------------------------------



Re^5: Wo wir grade so schoen am jammern sind... (Medic, 19. Sep 2004, 09:07:20):
~#! rn=Gloinson rt=1095549832 rg=gilden.zauberer
~#! tid=1095537286
Nunja, so schlecht fand ich die Idee jetzt nicht. Wenn ich an die Unzahl der
Waffen denke, die ihre jeweiligen Schadensarten machen und daran, dass andere
Gilden die (logischerweise) besser benutzen koennen als Zaubis....Dann seh ich
nicht, wieso man als Zauberer nicht auch einen heiligen oder satanischen
Schaden koennen machen sollte mit dem Stab. Meinetwegen auch nur eins von
beiden in Abhaengikeit vom Alignment.

-----------------------------------------------------------------------------



Re^6: Wo wir grade so schoen am jammern sind... (Humni, 19. Sep 2004, 10:50:02):
~#! rn=Medic rt=1095577640 rg=gilden.zauberer
~#! tid=1095537286
Heiliger und unheiliger Schaden sind fuer mich aus meiner Sicht als
Rollenspieler Schadensarten, die nicht einfach sowas wie Feuer, Wasser oder
Saeure sind. Sie stammen aus goettlichn bezihungsweise satanischen Eingriffen.

Ehrlich gesagt gefallen mir darum auch NPCs nicht, die einfach so beide
Schadensarten austeilen koennen. Dafuer sollte man sich eine verdammt gute
Begruendung einfallen lassen.

Durchaus moeglich ist, dass eine Gottheit ihre Macht einer Waffe verleiht.
Oder ein Daemon einer Waffe satanischen Schaden ermoeglicht. 

Zauberer stehen meines Erachtens nach ausserhalb des goettlichen Systems und
sollten daher diese Schadensarten nicht beherrschen.

Soweit meine Sicht als Rollenspieler.

Als Balancler kommt noch dazu, dass ich die aktullen Zauberer fuer stark genug
halte, und es ganz ok finde, dass die trotz recht weit reichnder Universalitat
eben nicht alles koennen.

Das Argument ,,Die Kaempfer, die Kampfer'' (das jetzt sofort kommen wird) wird
ignoriert. ;-)

Humni

-----------------------------------------------------------------------------



Re^7: Wo wir grade so schoen am jammern sind... (Anatol, 19. Sep 2004, 11:53:07):
~#! rn=Humni rt=1095583802 rg=gilden.zauberer
~#! tid=1095537286
Da sind wir, die zaubernden Rollenspieler, sicher bei Dir, Humni.
Heiligkeit, Unheiligkeit... da stehen wir doch drueber. Die Macht
der Goetter, egal ob gut oder boese, ja mein Jof, wir legen es 
nicht drauf an, sie zu veraergern, es sei denn wir haben grade Lust
dazu. Aber vertrauen tun wir eher unseren eigenen Faehigkeiten, 
unserer Faehigkeit, die Kraft in unserer Umgebung zu nutzen, zu
kanalisieren und das Verderben sogar ueber Goetter zu bringen. 
Bis auf Jof sind ohnehin alle Goetter sterblich. Und Jof idelt. ;)

Das Problem, mit dem Selbstverwandlung aufgekocht ist, ist die
Weigerung Boings, die SSP an _saemtliche_ Leitfaeden zur sauberen
Programmierung von Sperrobjekten/-monstern anzupassen.

Da es, fuer mich, keinen rationalen Grund gibt, sehe ich die SSP
als Ausnahme, als Spielwiese, in der es explizit gestattet ist, 
hie und da mal einen Spieler zu veraeppeln (toete ork, nimm hose
aus leiche, erschaffe f Orkhose, benenne orkhose ork, lege ork
in leiche, sueden) und zu nutzen, was geht. Nicht zuletzt die
SSP ist ein Benchmark fuer die Magier, die in anderen Regionen
diesen Kram abfangen _muessen_. Sollen sie froh sein, dass es 
einen Fleck gibt, wo die Spielerwelt bereitwillig zeigt, wie man
mit Stempel, Beutel, Zauberer, Tarnhelm oder dergleichen 
"ungewoehnliches Verhalten" hervorruft.

Dass auch das im Rahmen bleiben muss - PK z.B. bleibt PK - ist 
klar. Aber ein Objekt abzulegen, das "ork" heisst, ist in der SSP
kaum mehr "Bugnutzen". Morgoth bekam unglaublich was auf die
Schuessel, als er Wurfsternbugs nicht fixte, weil sie von der 
Lib verursacht wurden. Wieso sollte da an Boing ein anderer
Massstab angelegt werden? Das Verhalten der SSP ist seit vielen
Jahren so (war nie anders), das Verhalten ist seit Beginn des
magischen Beutels bekannt und wurde seit dem nie geaendert.

Anatol

-----------------------------------------------------------------------------



Re: Wo wir grade so schoen am jammern sind... (Patryn, 19. Sep 2004, 14:17:42):
~#! rn=Medic rt=1095537286 rg=gilden.zauberer
~#! tid=1095537286
Die Spells haben doch ihre Funktion...sehr nuetzlich wie ich meine,
mindestens so nuetzlich wie selbstverwandlung :)
Leider sind die Zauberer keine Kaempfer und duerfen deshalb nicht
alle Schadensarten in allen Staerken austeilen,
da steht die selektive Balance vor ;)))

-- 
patryn stichelt eher unmotiviert aber in gewohnter manir

PS: SV ist toll, die Moeglichkeit Spieler angreidfen zu duerfen wenn es
eh NoNo ist, ist superdaemlich

-----------------------------------------------------------------------------



Re: Re: Wo wir grade so schoen am jammern sind... (Darklor, 29. Sep 2004, 01:29:38):
~#! rn=Patryn rt=1095596262 rg=gilden.zauberer
~#! tid=1095537286
Irgendwie hoert sich SV ziemlich nutzlos an, wenn es doch auch einen Tarnhelm
gibt... 

Darklor

-----------------------------------------------------------------------------



Re^3: Wo wir grade so schoen am jammern sind... (Ogo, 29. Sep 2004, 10:07:44):
~#! rn=Darklor rt=1096414178 rg=gilden.zauberer
~#! tid=1095537286
Dann wasch deine Ohren. ;>

Ogo

-----------------------------------------------------------------------------



typos (Patryn,  2. Okt 2004, 19:19:10):
Die Gildenraumtypos wurden mal abgearbeitet, NPCs auch teilweise,
Objekte und NPC-Typos folgen alsbald.

-- 
patryn

-----------------------------------------------------------------------------



typos (Patryn,  3. Okt 2004, 22:32:51):
da es ja beschwerden gab wegen typos, objekte und npcs sind nun auch
abgearbeitet, also frohes neues typoabsetzen (so viele waren aber gar
nicht gemeldet)

-- 
patryn

-----------------------------------------------------------------------------



Schaetz (Medic,  4. Jan 2005, 01:45:31):
Hallo,

gibt es eine Moeglichkeit, "schaetz" in raeumen zu verwenden, in denen das
(zum Beispiel durch einen Laden) ueberschrieben ist?

-----------------------------------------------------------------------------



Re: Schaetz (Gloinson,  4. Jan 2005, 02:13:14):
~#! rn=Medic rt=1104799531 rg=gilden.zauberer
~#! tid=1104799531
Nicht das mir jetzt einfiele, da das Kommando des Raumes zuerst ausgefuehrt
wird und wenn dieses meint wirklich gemeint zu sein die Kommandoauswertung
auch beendet. Das ist bei "schaetz" natuerlich recht bloed, vielleicht laesst
sich ein EM mal einen tollen Namensraum-Trenner einfallen ;)

Sowas wie gilde::schaetz zB. ;)


-----------------------------------------------------------------------------



Re: Re: Schaetz (Vardion,  4. Jan 2005, 19:24:46):
~#! rn=Gloinson rt=1104801194 rg=gilden.zauberer
~#! tid=1104799531
Beim Zauberstab gibts jeden Befehl aus obigem Grund auch als z<Befehl>. Fuer
Spells scheint das leider nicht zu klappen. Patryn...?

Vardion

-----------------------------------------------------------------------------



Re^3: Schaetz (Amaryllis,  4. Jan 2005, 19:25:40):
~#! rn=Vardion rt=1104863086 rg=gilden.zauberer
~#! tid=1104799531
Also ich hab mir mal zzap gebaut, damit kann ich Zaubis jetzt hoechst effektiv
zappen :)

Ama*

-----------------------------------------------------------------------------



Re^4: Schaetz (Vardion,  4. Jan 2005, 19:26:14):
~#! rn=Amaryllis rt=1104863140 rg=gilden.zauberer
~#! tid=1104799531
Du stotterst :)

Vardion

-----------------------------------------------------------------------------



Re^5: Schaetz (Chagall,  4. Jan 2005, 19:26:46):
~#! rn=Vardion rt=1104863174 rg=gilden.zauberer
~#! tid=1104799531
:reicht der Unke eine Schippe und ein Eimerchen und schickt sie in die
Wueste.


-----------------------------------------------------------------------------



Re^6: Schaetz (Householder,  4. Jan 2005, 20:27:52):
~#! rn=Chagall rt=1104863206 rg=gilden.zauberer
~#! tid=1104799531
:schenkt der fee eine selpstgezimmerte Bueckvorrichtung und merkt an: "Wunsch
ist Wunsch !"

-----------------------------------------------------------------------------



spiegel (Vector, 18. Nov 2005, 10:13:54):
Mit den ...aeh... tollen, stimmungsvollen neuen Spiegeln sollte
man LLystrstathe als Ziel fuer Teleporte aendern, und dort nicht
mehr bei guten sondern bei missgluecktem Teleport ankommen....

-----------------------------------------------------------------------------



Re: spiegel (Shaeena, 20. Nov 2005, 22:48:57):
~#! rn=Vector rt=1132305234 rg=gilden.zauberer
~#! tid=1132305234
Meine volle Zustimmung, ist echt nervig geworden dort zu landen.
(Klar, tolles Wegeskript und das ist kein Problem mehr, nur stimmungsvoll ist
es dann auch erst recht nicht mehr.)

-----------------------------------------------------------------------------



Re: Re: spiegel (Chagall, 21. Nov 2005, 17:47:22):
~#! rn=Shaeena rt=1132523337 rg=gilden.zauberer
~#! tid=1132305234
Dann fehlt ja nur noch ein aktiver Gildenmagier...

MC

-----------------------------------------------------------------------------



Re^3: spiegel (Shaeena, 21. Nov 2005, 17:54:04):
~#! rn=Chagall rt=1132591642 rg=gilden.zauberer
~#! tid=1132305234
Ah, du bietest Dich freiwillig an?

-----------------------------------------------------------------------------



Re^4: spiegel (Chagall, 21. Nov 2005, 18:06:36):
~#! rn=Shaeena rt=1132592044 rg=gilden.zauberer
~#! tid=1132305234
He, ich sagte Gildenmagier und nicht Magierwurst :)

MC

-----------------------------------------------------------------------------



Re^5: spiegel (Birdy, 23. Nov 2005, 13:28:25):
~#! rn=Chagall rt=1132592796 rg=gilden.zauberer
~#! tid=1132305234
Uebung macht den Meister, wie dir jeder Zauberer bestaetigen kann. *g*


-----------------------------------------------------------------------------



Neuer Gildenmagier (Humni,  9. Apr 2006, 14:00:04):
Huhu Zauberer,

mit Freude darf ich verkuenden, dass Chagall sich bereiterklaert hat, Eure
Gilde weiterzuentwickeln. Fortan wird er sich drum kuemmern, dass ihr die
Haende abgehackt bekommt und solche Sachen... oder? ;-)

Naja, ich wuensche Euch allen viel Spass, und ich danke Patryn fuer die in
dieser Gilde geleistete Arbeit.

Chagall wuensche ich viel Erfolg beim Einlesen in die Gilde und erfolgreiches
Basteln!

Humni

-----------------------------------------------------------------------------



Re: Neuer Gildenmagier (Chagall,  9. Apr 2006, 14:26:26):
~#! rn=Humni rt=1144584004 rg=gilden.zauberer
~#! tid=1144584004
Huhu Zaubis,

bevor ihr mich jetzt mit Aenderungswuenchen und Vorschlaegen bombadiert,
lasst mir bitte einige Tage Zeit um mich mit den eigentlichen Interna
der Gilde vertraut zu machen (ok, schicken duerft ihr schon, aber ich
werde das dann erstmal zur Seite legen und spaeter darauf zurueck
kommen).

Das Mailalias gm_zauberer sollte auch bald umgestellt sein, bis dahin bitte
alles direkt an mich schicken.

Was gibts sonst noch? Magier koennen jetzt wieder Komponenten und
Unterstuetzungen fuer Ruestungen beantragen (auch wenn ich da erstmal
gucken muss, wie letzteres genau funktioniert. :))

Zu guter Letzt moechte ich dann noch Patryn fuer die Zeit und Arbeit danken,
die er in die Gilde investiert hat.

MC

-----------------------------------------------------------------------------



Re: Re: Neuer Gildenmagier (Montanus,  9. Apr 2006, 14:54:37):
~#! rn=Chagall rt=1144585586 rg=gilden.zauberer
~#! tid=1144584004
Oh! Wird Taranis jetzt endlich angeschlossen? :-)

-----------------------------------------------------------------------------



Re^3: Neuer Gildenmagier (Ark,  9. Apr 2006, 15:03:06):
~#! rn=Montanus rt=1144587277 rg=gilden.zauberer
~#! tid=1144584004
Ist schon ... finger Taranis :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Neuer Gildenmagier (Requiem, 10. Apr 2006, 07:08:46):
~#! rn=Humni rt=1144584004 rg=gilden.zauberer
~#! tid=1144584004
Ich fass meinen Kommentar mal in 2 Worte:

Danke! Endlich!

Dir viel Spass und Erfolg bei deiner Arbeit, Chagall. Und setz nicht wie dein
Vorgaenger die Haelfte der aktiven Gildenmitglieder auf ignore ;)

Fuer eine Zaubizukunft ohne Jammern,
Requiem

-----------------------------------------------------------------------------



Re: Re: Neuer Gildenmagier (Orktoeter, 10. Apr 2006, 09:35:10):
~#! rn=Requiem rt=1144645726 rg=gilden.zauberer
~#! tid=1144584004
Such das Originalfile der Zauberergilde, bau den Bug mit dem Schutz aus, passe
die Werte (in Uebereinkunft mit der Gildenbalance) an, schau wo ueberall ein
Spelledefend drin steht und mail die Magier bzw. die zustaendigen
Regionsmagier an, dass die Zauberer in Zukunft wieder echte Zauberer werden
und auch nicht uebertrieben stark und sie daher ihre NPC doch noch mal auf
Spelldefend ueberprufen sollen.

Dann gaebe es wieder "echte" Zauberer (hoffentlich mit etsprechendem flair).
Leider waren die Zauberer zu Anfang ja viel zu stark, weswegen dann ja an
vielen Stellen dann Spelldefend kam mit der Folge das die Zaubis das sind was
sie heute sind, traurig.

OrkT.

-----------------------------------------------------------------------------



Re^3: Neuer Gildenmagier (Vector, 10. Apr 2006, 10:42:49):
~#! rn=Orktoeter rt=1144654510 rg=gilden.zauberer
~#! tid=1144584004
sry orktoeter, wenn du schon in "deinen" rubriken wie
allgemein und gilden.kaempfer fuer lacher, kopfschuetteln
und schenkelklopfer sorgst, dann kannst du dir in etwa
ausmalen wie die reaktion auf solche posts ist, wo du
wirklich NOCH WENIGER als null ahnung von der materie
hast.
die ignore-liste von patryn war vielleicht lang, aber bist
(das sollte "bis" heissen nicht "bist") bis auf 3 leute
standen da alle zurecht drauf. es gab mehr als ertraeglich
viel inhaltslose jammerei. 
was man ueberlegen koennte: die rubrik b.z. wieder zu
reaktivieren mit einem sinnvollen topf aus lese- und 
schreibberechtigten.

-----------------------------------------------------------------------------



Re^4: Neuer Gildenmagier (Kerrier, 10. Apr 2006, 11:06:14):
~#! rn=Vector rt=1144658569 rg=gilden.zauberer
~#! tid=1144584004
Ja. b.z. waere vielleicht wirklich ganz sinnvoll.
Es gab auch mal einen Zaubererverteiler ausserhalb des Muds um derartige Dinge
zu diskutieren, der allerdings derzeit etwas eingeschlafen ist .... und auch
gelkoescht, glaube ich. Koennte man allerdings auch wieder reaktivieren.

EK

-----------------------------------------------------------------------------



Re^5: Neuer Gildenmagier (Vampire, 10. Apr 2006, 11:58:03):
~#! rn=Kerrier rt=1144659974 rg=gilden.zauberer
~#! tid=1144584004
Na dann viel Spass beim Schaffen :)

Einen wunsch habe ich, so wie es seit 1998 und ich glaube sogar noch frueher
in der ZFAQ drinn steht das Cronortal bald ein Sehertor bekommt, das aus
diesem bald wirklich mal das Tor auch mal erbaut wird :)

Vampire

-----------------------------------------------------------------------------



Re^6: Neuer Gildenmagier (Miril, 10. Apr 2006, 11:59:01):
~#! rn=Vampire rt=1144663083 rg=gilden.zauberer
~#! tid=1144584004
Du kannst ein Seherportal dorthin stellen. Es gibt eins zu finden, das man
selbst aufstellen kann.

Miril

-----------------------------------------------------------------------------



Re^3: Neuer Gildenmagier (Ark, 10. Apr 2006, 13:33:12):
~#! rn=Orktoeter rt=1144654510 rg=gilden.zauberer
~#! tid=1144584004
Das Anmailen kannst Du schon seit Jahren selbst machen ... einfach in ein
Postamt gehen und ... :-) Der GM ist fuer seine Gilde da und handelt nicht NPC
mit anderen Magiern aus, weil NPC xy soooo unfair ist. Mail an den RM und gut
ist. Diese Aktion wurde nebenbei schonmal gemacht, regionsuebergreifend.
Und ... warum disqualifizierst Du implizit die Zauberer als "unecht"?


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^4: Neuer Gildenmagier (Orktoeter, 10. Apr 2006, 13:50:23):
~#! rn=Ark rt=1144668792 rg=gilden.zauberer
~#! tid=1144584004
"Unecht", weil fuer mich jemand der mit (z.B. brennenden) Haenden auf einen
Gegner einschlaegt (und ander Kampfspells kaum bis gar nicht nutzt) nicht
wirklich ein Zauberer ist.
Ja, ich erinner mich, dass bereits einmal alle Magier aufgerufen wurden ihre
Spelldefennutzung zu ueberpruefen. Dabei ist damals aber meines wissens nach
nicht viel heraus gekommen. Wenn allerdings diesmal wirklich die Zauberer zu
"echten" Zauberern umgewandelt werden (und nicht wie die original-Gilde viel
zu stark ist, sondern von vorn herein von der Gilden-Balance abgenommen wird),
koennte ich mir Vorstellen, dass die zustaendigen Magier ihre NPC auch noch
mal gruendlich auf Spelldefend durchschauen.

OrkT.

-----------------------------------------------------------------------------



Re^5: Neuer Gildenmagier (Miril, 10. Apr 2006, 14:02:00):
~#! rn=Orktoeter rt=1144669823 rg=gilden.zauberer
~#! tid=1144584004
Orktoeter, spiel einfach mal wieder, dann kannst Du Dir vielleicht ein
qualifizierteres Urteil darueber erlauben, wo was bei raus kam. Der 
SpellDefend und insbesondere P_NOMAGIC wurde in einer ganzen Reihe von
Faellen komplett rausgeworfen, weil es voellig unbegruendet war.

Miril

-----------------------------------------------------------------------------



Re^5: Neuer Gildenmagier (Boing, 10. Apr 2006, 14:05:10):
~#! rn=Orktoeter rt=1144669823 rg=gilden.zauberer
~#! tid=1144584004
Dein Wissen truegt.
  Boing

-----------------------------------------------------------------------------



Re^6: Neuer Gildenmagier (Taranis, 10. Apr 2006, 14:06:20):
~#! rn=Miril rt=1144670520 rg=gilden.zauberer
~#! tid=1144584004
Ich antworte mal auf den letzten Artikel. Mal ganz davon abgesehen: glaubst
Du, dass es einer Gilde guttut, schlagartig komplett durch etwas anderes
ersetzt zu werden? Ich behaupte mal, dass im Falle einer massiven Aenderung
auf einmal viele Spieler einfach aufhoeren, in dieser Gilde zu spielen.
Entweder Du machst eine langsame kontinuierliche Serie von durchdachten
Aenderungen und kommst nach einiger Zeit zum gewuenschen Ergebnis oder Du
baust eine neue Gilde, die gleich so ist, wie man sich das vorstellt.
My 2 cents,
Taranis

-----------------------------------------------------------------------------



Re^7: Neuer Gildenmagier (Orktoeter, 10. Apr 2006, 14:14:52):
~#! rn=Taranis rt=1144670780 rg=gilden.zauberer
~#! tid=1144584004
Aeh... war letzteres nicht eh schon begonnen worden? (auf das Zauberer wieder
Zauberer sind und keine Schnellfuerkaratekas mehr)
Das Projekt ist dann aber wohl aehnlich friedlich entschlafen wie der Ort
Taranis...

Und meinst du nicht, dass "echte" Zauberer vielleicht auch neue Spieler
anziehen wuerden, die gerne das flair des Zauberer-sein haben und das es der
Gilde als ganzem eher gut tut wenn sie Leute veriert, die nur der Kampfkraft
wegen dort sind, aber keinerlei Wert auf den Gildenfeeling legen?

OrkT.

-----------------------------------------------------------------------------



Re^8: Neuer Gildenmagier (Humni, 10. Apr 2006, 14:15:20):
~#! rn=Orktoeter rt=1144671292 rg=gilden.zauberer
~#! tid=1144584004
Der arme Ort Taranis.

Humni

-----------------------------------------------------------------------------



Re^9: Neuer Gildenmagier (Vampire, 10. Apr 2006, 14:16:25):
~#! rn=Humni rt=1144671320 rg=gilden.zauberer
~#! tid=1144584004
Gruebel,

sorry aber was hat Taramis mit der Gilde der Zauberer zu tun ?

Vampire

-----------------------------------------------------------------------------



Re^10: Neuer Gildenmagier (Darklor, 10. Apr 2006, 14:20:10):
~#! rn=Vampire rt=1144671385 rg=gilden.zauberer
~#! tid=1144584004
Ja genau, bastel eine neue Gilde, die is, wie die echten Zauberer sein
sollten... 

Darklor

-----------------------------------------------------------------------------



Re^10: Neuer Gildenmagier (Humni, 10. Apr 2006, 14:20:14):
~#! rn=Vampire rt=1144671385 rg=gilden.zauberer
~#! tid=1144584004
Die Gilde der Zauberer heisst eigentlich und mit vollem Namen

Akademie der Geistigen Kraft zu Taramis

Nun ist es sehr unpraktisch, in der MPA immer rubrik
gilden.akaedmie.der.geistigen.kraft.zu.taramis zu schreiben, und auch im
Finger macht sich ein "Gilde: Akademie der geistigen Kraft zu Taramis" meist
eher schlecht, da es zu einem "Hae?" fuehrt, ein "Gilde:Zauberer" und ein
rubrik gilden.zauberer hingegen nicht.

Allerdings hast Du in einer Hinsicht recht: Chagalls Aufgabe ist nicht,
Taramis fertigzuschreiben. Und was Taranis damit zu tun hat weiss ich nicht.
Schliesslich ist der Teil, in dem die Gilde liegt, fertig (wenn das auch gar
nicht in Taramis City liegt). Also ist hier kein Handlungsbedarf.

Erklaerbaerverdiener Humni

-----------------------------------------------------------------------------



Re^11: Neuer Gildenmagier (Darklor, 10. Apr 2006, 14:30:01):
~#! rn=Humni rt=1144671614 rg=gilden.zauberer
~#! tid=1144584004
Ah, dann wuerde ja einer echten Zauberergilde nix im Wege stehen...

Darklor

-----------------------------------------------------------------------------



Re^11: Neuer Gildenmagier (Vampire, 10. Apr 2006, 14:31:19):
~#! rn=Humni rt=1144671614 rg=gilden.zauberer
~#! tid=1144584004
Ich hatte ja auch nur den Wunsch geaeussert das Sehertor im Cronortal zu bauen
weil es einfach seit Jahren in der ZFAQ steht, auch wenn man vielleicht heute
andere moeglichkeiten hat die damals nicht da waren :) MG entwickelt sich ja
gott sei dank weiter. 
Und selbst 1998 wo ich angefangen hatte war Sevana glaub ich auch nicht mehr
ganz so aktiv gewesen und da hatten ja einder der Ps die Gilde gepflegt und
auch die hatten ja nie was mit TaraNis zu tun gehabt :) 
Ich weiss nur als ich Zauberer wurde, wurden so manche Sachen veraendert und
die damaliegen zauberer waren an jammern. Es wurde immer hinsichtlich der
Balance und Gildenmagier was gemacht usw. Wie die Zauberer heute sind muss ich
ehrlich sagen keine Ahnung ich habe seit ueber 4 Jahren nicht mehr aktiv
gespielt. 
Ich wuensche einfach nur dem neuen GM viel Erfolg bei seiner Aufgabe :)

Vampire

-----------------------------------------------------------------------------



Re^12: Neuer Gildenmagier (Croft, 10. Apr 2006, 16:53:14):
~#! rn=Darklor rt=1144672201 rg=gilden.zauberer
~#! tid=1144584004
Tut es ja auch nicht.  Die Magus sind seit Jahren in der Planung ;-)

Croft

-----------------------------------------------------------------------------



Re^5: Neuer Gildenmagier (Ark, 10. Apr 2006, 19:50:27):
~#! rn=Orktoeter rt=1144669823 rg=gilden.zauberer
~#! tid=1144584004
Das glaube ich beim besten Willen nicht :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^6: Neuer Gildenmagier (Montanus, 14. Apr 2006, 22:36:04):
~#! rn=Ark rt=1144691427 rg=gilden.zauberer
~#! tid=1144584004
Vorher wird noch die Kampfgolfergilde fertig, oder Taranis angekettet, aeh
angeschlossen.

-----------------------------------------------------------------------------



Alles neu macht der Mai? (Chagall,  8. Mai 2006, 20:34:45):
Huhu Zaubis,

ich musste leider eure Staebe ersetzen, dabei kam es *huestel* zu
kleineren Komplikationen. Falls irgendwer keinen Zauberstab mehr
hat, so moege er doch bitte Llystrathe danach fragen.

MC

-----------------------------------------------------------------------------



Re: Alles neu macht der Mai? (Ark,  8. Mai 2006, 21:47:17):
~#! rn=Chagall rt=1147113285 rg=gilden.zauberer
~#! tid=1147113285
Gib ihnen Kampfstaebe, gibt gleich nen neuen Skill zum Ueben :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re: Re: Alles neu macht der Mai? (Chagall,  8. Mai 2006, 21:47:55):
~#! rn=Ark rt=1147117637 rg=gilden.zauberer
~#! tid=1147113285
Gib mir die noetige Zeit den einzbauen. 

MC

-----------------------------------------------------------------------------



Re^3: Alles neu macht der Mai? (Darklor,  8. Mai 2006, 22:26:15):
~#! rn=Chagall rt=1147117675 rg=gilden.zauberer
~#! tid=1147113285
Der Kampfstaebeskill kommt jetzt auch fuer Zaubis? - Toll!

Darklor

-----------------------------------------------------------------------------



Aktion Gildenfeeling (Chagall, 14. Mai 2006, 20:29:58):
Huhu Zaubis,

um das Lernen der Sprueche ein wenig interessanter zu machen,
suche ich ein paar Leute die gewillt sind Lernsequenzen zu
schreiben. Falls wer Lust, Laune und Zeit hat, soll er/sie
sich bei mir melden, damit ich die einzelnen Sprueche
verteilen und auch den Aufbau der einzelnen Files erklaeren
kann.

Gruss

MC

-----------------------------------------------------------------------------



Re: Aktion Gildenfeeling (Chagall, 14. Mai 2006, 20:33:12):
~#! rn=Chagall rt=1147631398 rg=gilden.zauberer
~#! tid=1147631398
Achja, Deadline zum melden nehm ich mal Freitag, den 26.5.

MC

-----------------------------------------------------------------------------



Lernen ist bloed (zumindestens momentan) (Chagall, 26. Jun 2006, 17:02:26):
Hallo Zauberer,

ich werde in den naechsten Tagen ein wenig an eurem Lerncache rumspielen.
Den genauen Termin werde ich noch kurzfristig ankuendigen, aber stellt
euch schonmal drauf ein, dass es im unguenstigsten Fall kurzfristig
zu Problemen mit dem Lernen kommen kann.

MC


-----------------------------------------------------------------------------



Re: Lernen ist bloed (zumindestens momentan) (Chagall, 26. Jun 2006, 19:15:50):
~#! rn=Chagall rt=1151334146 rg=gilden.zauberer
~#! tid=1151334146
Soderle, da ich schneller mit der Aenderung fertig geworden bin, verkuende
ich hiermit, dass ich Morgen am Nachmittag den geaenderte Lerncache
probehalber aktivieren werde.

MC

-----------------------------------------------------------------------------



Re: Re: Lernen ist bloed (zumindestens momentan) (Chagall, 27. Jun 2006, 16:26:53):
~#! rn=Chagall rt=1151342150 rg=gilden.zauberer
~#! tid=1151334146
Wie angekuendigt gab es eine kleine Aenderung im Verhalten des 
Lerncache. Sprueche die ihr auf euch selber sprecht, sollten
jetzt leicht anders gehandabt werden im Cache. Das ganze steht
allerdings momentan noch unter Beobachtung, kann sich also noch
aendern.

Wer irgendwelche unnatuerlichen Phaenomene beim Lernen findet,
sprich gar nicht lernen eines Spells oder der Spell geht zu
einfach zu lernen, der moege das bitte mitteilen.

MC

-----------------------------------------------------------------------------



Re: Aktion Gildenfeeling (Chagall, 27. Jul 2006, 18:56:44):
~#! rn=Chagall rt=1147631398 rg=gilden.zauberer
~#! tid=1147631398
Huhu Zaubis,

es hat laenger gedauert als ich eigentlich gedacht hatte, aber seid heute habt
ihr jetzt Lernsequenzen, d.h. wenn ihr einen neuen Spruch lernt, bekommt ihr
jetzt total unnuetzen Scroll.

Zauberer, welche schon alles gelernt haben, koennen einfach mit einem 
"lerne <spruch>" sich die Sequenz anschauen ohne Gefahr zu laufen, gleich 
wieder alles zu verlernen.

Falls einer meint: "Hey, das kann ich aber besser!", nur zu, ich nehme
gerne weitere Sequenzen entgegen.

Last but not least noch ein Dank an die fleissigen Sequenzschreiber, ohne
die haette es sicherlich doch noch ein wenig laenger gedauert.

MC, der jetzt Kaeferchen austreiben geht.

-----------------------------------------------------------------------------



Re: Re: Aktion Gildenfeeling (Chagall, 27. Jul 2006, 20:20:42):
~#! rn=Chagall rt=1154019404 rg=gilden.zauberer
~#! tid=1147631398
Zwei Dinge noch. Ich hab mir sagen lassen dass einige Sequenzen zu schnell
sind,
da kuemmer ich mich die Tage nochmal drum. Ich bin da erstmal von meiner Lese-
geschwindigkeit ausgegangen.

Typos etc. entweder in der Sequenz absetzten (ja, das geht), die landen
dann im Raumrepfile oder halt per Mail an mich.

-----------------------------------------------------------------------------



Vorahnung (Chagall, 15. Aug 2006, 17:15:04):
Huhu Zaubis,

auf Wunsch eines Sators verhaelt sich Vorahnung jetzt analog zu schutz/
schutzhuelle/zauberschild, d.h. Hellsichtmagister bekommen jetzt eine
Endemeldung und fuer die laufende Vorahnung einen kleinen Extralook.

MC

-----------------------------------------------------------------------------



Was ich schon lange sagen wollte... (Vincent, 24. Aug 2006, 23:35:32):
Schon seit laengerer Zeit will ich einige Kritikpunkte an der
Zauberergilde posten. Bei diesen Punkten handelt es sich um
grundsaetzliche Unstimmigkeiten - man koennte sogar sagen Fehler.
Nun, hier sind sie:

1. Wirkung von Alkohol:
Es ist voellig im Reich der Fiktion anzusiedeln, dass Zauberer unter
Einfluss von Alkohol schlechter oder gar nicht zaubern koennen.
Tatsache ist, dass die meisten Zauberer auch nach dem Konsum von
Alkohol vollkommen in der Lage sind, Zauberkunststuecke fehlerfrei
vorzufuehren. Auf dem letzten Zauberkongress habe ich sehr viele
Zauberer getroffen, die z. B. spaet abends und nach mehreren Glaesern
Bier problemlos ihre Magie nutzen und verbreiten konnten.
Ausserdem bin ich gerne bereit den Beweis hierfuer auch persoenlich
anzutreten. Es mag ja sein, dass z. B. Katzenkrieger unter dem
Einfluss von Alkohol nicht schleichen koennen - vielleicht weil sie
dann zwanghaft das Westerwaldlied absingen muessen. Allerdings ist 
die Behauptung, dass Zauberer unter Einfluss von Alkohol nicht
zaubern koennen oder zumindest viele Fehler dabei machen, so abwegig,
dass sie selbst fuer ein Fanatasy-Mud zu viel Fiktion beinhaltet.

2. Lichtspruch:
Ich haben noch nie irgendwo einen Zauberer gesehen, der in einer Ecke
steht und permanent "Licht" uebt. So etwas gibts nicht. Auch
Zauberer benutzen dafuer vorhandene Einrichtungen wie z. B.
Lichtschalter. Dessen Betaetigung braucht nicht geuebt zu werden.
Das einzig Magische daran ist, dass der Ort, wo man den
Lichtschalter betaetigt, nicht auch der Ort ist, wo das Licht angeht.
Hierbei handelt es sich aber mehr um einen Insider-Witz unter uns
Zauberern. Das unsaegliche Lichtspruch-Ueben hat jedenfalls nichts
in der Zauberergilde zu suchen.

3. Hand Feuer:
Der Spruch "Hand Feuer" sollte auch im Morgengrauen auf Grund der
Sicherheit als allgemein zugaenglicher Zauberspruch abgeschafft
werden. Dieser Spruch darf tatsaechlich nur Zauberern zur Verfuegung
stehen, die einen Pyrotechnikschein der Klasse drei vorweisen koennen.

4. Magiezweige:
Die im Mud vorhandenen Magiezweige existieren so nicht in der
Wirklichkeit. Die Zweige "Hellsicht" und "Beherrschung" gehoeren
vereint unter den Zweig "Mentalmagie". "Angriff" und "Schutz" sind
keine existierenden Magiezweige und koennen gestrichen werden. Keine
Ahnung, wie man auf so etwas kommen kann. "Verwandlung" ist kein
eigenstaendiger Zweig sondern ein Grundprinzip der Zauberei
und gehoert als solches in fast jeden Zweig. Einzig der Zweig
"Illusion" ist korrekt, hier fehlen aber elementare Sprueche wie z. B.
"schweben lassen", "erscheinen in Rauchwolke" und "erkennen von 
Jungfrauen". Unbedingt hinzuzufuegen sind die Magiezweige
"Kartenmagie" und "Comedy".

Meines Erachtens sollten die dargelegten inhaltlichen Fehler
der Zauberergilde in naher Zukunft behoben werden.

   Vincent
   
P.S.: Harry Potter ist reine Fiktion, damit das ein fuer alle Mal
klar sein wuerde.


-----------------------------------------------------------------------------



Re: Was ich schon lange sagen wollte... (Kessa, 25. Aug 2006, 01:17:39):
~#! rn=Vincent rt=1156455332 rg=gilden.zauberer
~#! tid=1156455332
Zu Punkt 4: Und "Tragedy". In diesem Zweig koennte der Jammerskill endlich zu
Recht und Wuerden kommen.

-----------------------------------------------------------------------------



Re: Re: Was ich schon lange sagen wollte... (Montanus, 25. Aug 2006, 08:55:17):
~#! rn=Kessa rt=1156461459 rg=gilden.zauberer
~#! tid=1156455332
Danke, Vincent. Endlich mal jemand, der das alte System schonungslos
analysiert hat undsich auch traut, Reiter und Ross zu nennen.
Aber wie ist das mit Wasserwandlung? Gehoert das nicht eigentlich in den
Bereich der Kleriker?

-----------------------------------------------------------------------------



Re: Re: Was ich schon lange sagen wollte... (Vincent, 25. Aug 2006, 10:45:05):
~#! rn=Kessa rt=1156461459 rg=gilden.zauberer
~#! tid=1156455332
Ich muss das mit dem Zweig "Comedy" wohl etwas ausfuehrlicher
erklaeren, um zukuenftigen Missverstaendnissen vorzubeugen:

Es ist richtig, dass der Zweig "Comedy" vor ca. drei Jahren abgeschafft
wurde mit der Begruendung, dass Comedy nur eine Darstellungsform oder
eine Auspraegung des Zauberns sei, und somit keine Berechtigung fuer
einen eigenstaendigen Zweig gegeben sei. Anders formuliert: Wenn es
komische Zauberei gibt, dann muesste es auch tragische oder traurige
Zauberei geben.

Nun inzwischen haben sich die Befuerworter der Comedy-Zauberei
durchsetzen koennen und Comedy wurde wieder zu einer eigenen Sparte
erklaert. Beim Weltkongress 2009 wird es also wieder Comedy-Zauberei im
Wettbewerb geben. Ursache fuer diesen Gesinnungswechsel war wohl die
Erkenntnis, das viele beruehmte Zauberer sich der Comedy hingezogen
fuehlten - u.a. The Great Nardini, Tooper Martin, Ali Bongo und auch
Merlin.
Hingegen sind nur ganz wenige Zauberer bekannt, die gerne tragische
Magie vorfuehren moechten. Tragisch wird es ausserdem immer dann
wenn ein Kunststueck schief geht.

Dies als ergaenzende Info.

   Vincent

-----------------------------------------------------------------------------



Re^3: Was ich schon lange sagen wollte... (Montanus, 25. Aug 2006, 11:07:18):
~#! rn=Vincent rt=1156495505 rg=gilden.zauberer
~#! tid=1156455332
Was musss man unter tragischer Magie verstehen? Jungfrauen zersaegen und nicht
wieder zusammensetzen?
Publikum Geld aus dem Ohr ziehen und nicht zurueckgeben?
Opfer hypnotisieren und sie auf derBuehne Seitenspruenge beichten lassen?

-----------------------------------------------------------------------------



Re^4: Was ich schon lange sagen wollte... (Muadib, 25. Aug 2006, 11:29:23):
~#! rn=Montanus rt=1156496838 rg=gilden.zauberer
~#! tid=1156455332
kaninchen aus dem indischen krug giessen
kartenmagie mit reisnaegeln
schweben in einem raum mit besonders niedriger decke
tauben aus dem hut zaubern vor dem verband der tontaubenschiessenden
jaegerinnung
jungfrau nicht zersaegen mit der bedauernden bemerkung keine jungfrau
ausmachen zu koennen
gedankenlesen bei einem politiker

es gibt so viele tragische elemente

-----------------------------------------------------------------------------



Re^5: Was ich schon lange sagen wollte... (Montanus, 25. Aug 2006, 11:31:35):
~#! rn=Muadib rt=1156498163 rg=gilden.zauberer
~#! tid=1156455332
Tauben zaubert man ja auch nicht herbei. Da gibt es eh schon vil zu viele von.
Vincent, ihr solltet euch darauf verlegen, Tiere aus dem Hut zu zaubern, die
kurz vor dem Aussterben sind. Damit wuerde ein Beitrag zur Artenerhaltung
geleistet, und der WWF wuerde euch wahrscheinlich viel Geld zahlen.
Wie waere es mit ... Pandabaeren?

-----------------------------------------------------------------------------



Re^6: Was ich schon lange sagen wollte... (Muadib, 25. Aug 2006, 11:32:47):
~#! rn=Montanus rt=1156498295 rg=gilden.zauberer
~#! tid=1156455332
oder halt zu zweit zaubern
der eine zieht tauben aus dem hut, der andere turmfalken

-----------------------------------------------------------------------------



Re^7: Was ich schon lange sagen wollte... (Montanus, 25. Aug 2006, 11:33:21):
~#! rn=Muadib rt=1156498367 rg=gilden.zauberer
~#! tid=1156455332
Zu dritt. Der dritte haelt den Staubsauger darunter, Die ganzen Federn auf der
Buehne waeren unhygienich.

-----------------------------------------------------------------------------



Re^6: Was ich schon lange sagen wollte... (Vincent, 25. Aug 2006, 12:04:07):
~#! rn=Montanus rt=1156498295 rg=gilden.zauberer
~#! tid=1156455332
Pandabaeren aus dem Hut finde ich grundsaetzlich eine gute Idee.
Allerdings ist dabei zu beruecksichtigen, dass der WWF dann kritisieren
wuerde, dass es den Baeren im Hut nicht gehe wuerde und das nicht
Art gerecht sei. Ausserdem kenne ich kein Monster im MG, das durch das
Hervorzaubern von Tieren aus einem Hut Schaden nehmen bzw. sich toeten
lassen wuerde.
Daran sieht man, wie eklatant notwendig Aenderungen in der Zauberergilde
sind.

   Vincent

-----------------------------------------------------------------------------



Re^7: Was ich schon lange sagen wollte... (Vincent, 25. Aug 2006, 12:07:42):
~#! rn=Vincent rt=1156500247 rg=gilden.zauberer
~#! tid=1156455332
Andererseits, wenn das WWF hier im MG gar nicht existiert, dann spricht
nichts dagegen, Tiere aus dem Hut zu zaubern und dies evt. sogar als
Kampfspruch zu etablieren.

   Vincent

-----------------------------------------------------------------------------



Re^8: Was ich schon lange sagen wollte... (Anoris, 25. Aug 2006, 12:09:16):
~#! rn=Vincent rt=1156500462 rg=gilden.zauberer
~#! tid=1156455332
MIr hat die Show gefallen, als der Zauberer den Hut aus dem Kaninchen
gezaubert hat. http://www.youtube.com/watch?v=GuMMfgWhm3g

 - Anoris

-----------------------------------------------------------------------------



Re^9: Was ich schon lange sagen wollte... (Janne, 25. Aug 2006, 12:10:22):
~#! rn=Anoris rt=1156500556 rg=gilden.zauberer
~#! tid=1156455332
Tolle Idee mit dem Kampfzauber. Das waer doch mal eine Abwechslung zum
Schattenkaempfer! ;)

Janne

-----------------------------------------------------------------------------



Re: Was ich schon lange sagen wollte... (Vincent, 25. Aug 2006, 12:15:01):
~#! rn=Vincent rt=1156455332 rg=gilden.zauberer
~#! tid=1156455332
Bezueglich des Magiezweigs "Kartenmagie" sieht man hier sehr anschaulich
wie Angriffszauber in diesem Zweig auszusehen haben.

http://www.youtube.com/watch?v=THyZ-ynSzDA

Man beachte insbesondere die zunehmende Groesse der Karten.

   Vincent

-----------------------------------------------------------------------------



Re^10: Was ich schon lange sagen wollte... (Orktoeter, 25. Aug 2006, 12:15:25):
~#! rn=Janne rt=1156500622 rg=gilden.zauberer
~#! tid=1156455332
In welche Ketegorie faellt denn folgende Zauberei:
http://tinyurl.com/pq8vh ?
(vorsicht, man beachte das ueber 18)

OrkT, neugierig.

-----------------------------------------------------------------------------



Re^11: Was ich schon lange sagen wollte... (Vincent, 25. Aug 2006, 12:19:31):
~#! rn=Orktoeter rt=1156500925 rg=gilden.zauberer
~#! tid=1156455332
Das gehiert in den Bereich der weiblichen Zauberer - sog. Zauberinnen.
Um gleich Geruechte zu vermeiden, das NAckt-Zaubern bei Frauen ist
keiensfalls eine der vielen Zauberregeln, auch wenn das u.U. gerne
gesehen wird. Insofern mag jeder selbst entscheiden, ob er oder sie
einen Nackt-Zauber-Zweig fuer sinnvoll haelt.

   Vincent

-----------------------------------------------------------------------------



Re^12: Was ich schon lange sagen wollte... (Boing, 25. Aug 2006, 13:39:28):
~#! rn=Vincent rt=1156501171 rg=gilden.zauberer
~#! tid=1156455332
Ich finde es erschreckend dass es noch kein offizielles Statement
der Gildenfuehrung zu diesen erheblichen Maengeln gibt!
  Boing

-----------------------------------------------------------------------------



Re^13: Was ich schon lange sagen wollte... (Chagall, 25. Aug 2006, 13:49:29):
~#! rn=Boing rt=1156505968 rg=gilden.zauberer
~#! tid=1156455332
Die Gildenfuehrung nimmt die Vorschlaege zur Kenntnis und wird diese
bei der naechsten gildeninternen Hauptversammlung beraten.

MC

-----------------------------------------------------------------------------



Re^14: Was ich schon lange sagen wollte... (Montanus, 25. Aug 2006, 14:06:32):
~#! rn=Chagall rt=1156506569 rg=gilden.zauberer
~#! tid=1156455332
Bei dem Tempo, das Silvana und ihre Nachfolger bei der Umsetzung von
Vorschlaegen bisher an den Tag gelegt haben, sollte man die Gilde doch lieber
in Zauderer umbenennen.

-----------------------------------------------------------------------------



Re^13: Was ich schon lange sagen wollte... (Vincent, 25. Aug 2006, 22:23:00):
~#! rn=Boing rt=1156505968 rg=gilden.zauberer
~#! tid=1156455332
Ich hoffe doch, dass die Gildenobrigkeit
diesen Thread gewissenhaft mitliest.

Ich hoffe weiterhin, dass endlich mit diesen von "Herr der Ringe", 
"Harry Potter" und Scheibenwelt stark romantisiertem
Zaubererbild aufgeraeumt wird.

Das Thema "Zauberergilde" ist zu ernst, als dass man es stark fiktional
orientierten Programmieren und Planern ueberlassen 
und auf die lange Bank aufschieben kann.

   Vincent

-----------------------------------------------------------------------------



Re^14: Was ich schon lange sagen wollte... (Darklor, 26. Aug 2006, 15:49:02):
~#! rn=Vincent rt=1156537380 rg=gilden.zauberer
~#! tid=1156455332
Pfff... - Das sind doch alles keine Zauberer, sondern alles nur Trickser. Wenn
Du das umgesetzt haben moechtest mach Deine eigene Tricksergilde auf.

Darklor

-----------------------------------------------------------------------------



Re^7: Was ich schon lange sagen wollte... (Seleven, 26. Aug 2006, 16:18:41):
~#! rn=Vincent rt=1156500247 rg=gilden.zauberer
~#! tid=1156455332
> Ausserdem kenne ich kein Monster im MG, das durch das
> Hervorzaubern von Tieren aus einem Hut Schaden nehmen bzw. sich 
> toeten lassen wuerde.

Och, wenn das Tier auf 'fass' hoert, einen gesunden Appetit auf betreffendes
Monster verspuert oder einfach von Grund auf boese, fies und gemein ist ...

-----------------------------------------------------------------------------



Re^8: Was ich schon lange sagen wollte... (Eljo, 26. Aug 2006, 18:48:51):
~#! rn=Seleven rt=1156601921 rg=gilden.zauberer
~#! tid=1156455332
Da in jedem von uns Spieler ein gewisses Monster steckt, hat jeder, der die
Quest Wolpertinger hat, bestimmt schon von einem 'herbeigezauberten' Wolpi den
einen oder anderen Treffer einstecken muessen. ;-)
Mann, sind wir schlechte Zauberer. 

-----------------------------------------------------------------------------



Re^9: Was ich schon lange sagen wollte... (Anatol, 27. Aug 2006, 21:54:57):
~#! rn=Eljo rt=1156610931 rg=gilden.zauberer
~#! tid=1156455332

Faszinierend, dass "Erkennen von Jungfrauen" dem Illusionszweig
zugeordnet wird. Aber... doch, denkbar.


-----------------------------------------------------------------------------



Re^10: Was ich schon lange sagen wollte... (Eljo, 27. Aug 2006, 21:58:08):
~#! rn=Anatol rt=1156708497 rg=gilden.zauberer
~#! tid=1156455332
Hm...ich glaube, ich reaktiviere den Zauberer doch noch, so dass der schnell
in den Zweig Illusion kommt. ;-)

-----------------------------------------------------------------------------



Re^11: Was ich schon lange sagen wollte... (Kessa, 27. Aug 2006, 22:00:54):
~#! rn=Eljo rt=1156708688 rg=gilden.zauberer
~#! tid=1156455332
Vermutlich bestehen dabei aber Leistung und Moeglichkeiten des Zauberers
lediglich im Durchschauen der Illusion. Wenn du gern mehr Jungfrauen haettest,
solltest du vielleicht ein paar Aenderungen im Zweig 'Verwandlung' beantragen?

-----------------------------------------------------------------------------



Re^12: Was ich schon lange sagen wollte... (Anatol, 27. Aug 2006, 22:01:48):
~#! rn=Kessa rt=1156708854 rg=gilden.zauberer
~#! tid=1156455332
Oder entsprechend junges Material rechtzeitig in den Abwehrzweig
stecken, damit der gewuenschte Status laenger erhalten bleibt... ;)


-----------------------------------------------------------------------------



Re^12: Was ich schon lange sagen wollte... (Eljo, 27. Aug 2006, 22:02:12):
~#! rn=Kessa rt=1156708854 rg=gilden.zauberer
~#! tid=1156455332
Sowas habe ich nie behauptet, dass ich mehr Jungfrauen will!
(Wieso eigentlich mehr, was ist das fuer eine infame Unterstellung?! ;-) )


-----------------------------------------------------------------------------



Re^13: Was ich schon lange sagen wollte... (Kessa, 27. Aug 2006, 22:03:02):
~#! rn=Eljo rt=1156708932 rg=gilden.zauberer
~#! tid=1156455332
Nun, weil die von dir wohl implizierten 'weniger Jungfrauen' ja auch irgendwo
herkommen muessen :)

-----------------------------------------------------------------------------



Re^14: Was ich schon lange sagen wollte... (Montanus, 28. Aug 2006, 18:55:28):
~#! rn=Kessa rt=1156708982 rg=gilden.zauberer
~#! tid=1156455332
Anatol, der Abwehrzweig wird abgeschafft.

-----------------------------------------------------------------------------



Re^15: Was ich schon lange sagen wollte... (Vincent, 30. Aug 2006, 20:29:19):
~#! rn=Montanus rt=1156784128 rg=gilden.zauberer
~#! tid=1156455332
Ganz genau. Lieber statt Abwehr- oder Angriffszweig
den Zweig Manipulation einfuehren. Eventuell waere ich
auch mit einem Zweig "Allgemein Magie" oder "Parlour Magic"
einverstanden.

Gruss Vincent

P.S.: 
Sollte es einen Zweig "Bauchreden" geben, trete ich sofort aus der ZG aus!

-----------------------------------------------------------------------------



Magisterpruefung (Chagall,  3. Okt 2006, 20:17:10):
Huhu Zaubis,

im Zuge der Vorbereitung auf die irgendwann anstehende Umstellung auf den
LD-Treiber, wurde die komplette Magisterpruefung ueberarbeitet. Sollte es
also wider erwarten bei der Magisterpruefung zu Problemem kommen, bin ich
Schuld. :)

MC

-----------------------------------------------------------------------------



Gildenladen (Chagall, 19. Okt 2006, 17:15:39):
Der Laden in der Gilde tut jetzt wieder, schuld war eine klitzekleine 
Aenderung von mir. *hust* Die ist jetzt rueckgaengig gemacht und 
ihr duerft wieder Geld verschwenden (oder gleich mir geben, damit
ich mir was schoenes von kaufen kann).

MC

-----------------------------------------------------------------------------



Re: Gildenladen (Chagall, 19. Okt 2006, 17:16:53):
~#! rn=Chagall rt=1161270939 rg=gilden.zauberer
~#! tid=1161270939
Der Alchemist im Vland tut uebrigens auch wieder.

MC

-----------------------------------------------------------------------------



Schmerzen (Chagall, 30. Nov 2006, 21:36:01):
Huhu Zaubis,

falls irgendwer in letzter Zeit Probleme damit hatte, den Spruch
'schmerzen' zu lernen (Sequenz lief, aber der Spruch wurde nicht
aktiviert), so moege er/sie es doch bitte erneut probieren. Der
Bug wurde behoben.

MC, schuettet ein wenig Asche auf sein Haupt

-----------------------------------------------------------------------------



Neue Gildenquest (Chagall,  3. Dez 2006, 20:28:50):
Huhu Zaubis,

Ark war so fleissig und hat euch eine neue Gildenquests spendiert.
Viel Spass beim sterben, oder so aehnlich.

MC

-----------------------------------------------------------------------------



Re: Neue Gildenquest (Ark,  3. Dez 2006, 20:30:36):
~#! rn=Chagall rt=1165174130 rg=gilden.zauberer
~#! tid=1165174130
Um einschlaegigen Geruechten gleich mal vorzubeugen, diese Gildenquest hat
absolut nichts mit Metzeln zu tun, mit Sterben noch weniger. Forschen ist hier
angesagt ... hasst mich dafuer oder nicht :-)


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Neues Stabgimmick (Chagall, 28. Jan 2007, 18:52:38):
Huhu Zaubis,

damit hier mal wieder etwas in der Rubrik steht. Es gibt ab sofort
ein neue Stabgimmick. Einfach 'gimmick aktualisieren' und dann
'gimmick anzeigen' sollte ausreichen, damit ihr in den Genuss
des Gimmicks kommt. Ansonsten einfach warten, bis das MG crasht bzw.
reboootet wird.

MC

-----------------------------------------------------------------------------



Re: Neues Stabgimmick (Liara,  2. Feb 2007, 00:39:43):
~#! rn=Chagall rt=1170006758 rg=gilden.zauberer
~#! tid=1170006758
Danke Chagall!

-----------------------------------------------------------------------------



Re: Neues Stabgimmick (Vincent,  3. Feb 2007, 13:36:20):
~#! rn=Chagall rt=1170006758 rg=gilden.zauberer
~#! tid=1170006758
Aus gegebenen Anlass moechte ich nochmals darauf hinweisen, dass die
Bedeutung des Zauberstabs fuer einen Zauberer stark ueberschaetzt wird.
Schuld daran sind mitunter solche nicht der Realitaet
entsprechenden Drstellungen wie z. B. "Harry Potter".
Leider folgt das Morgengrauen solchen Vorlagen. Um es nochmal klar zu sagen,
Zauberstaebe und ihre Funktionen fuer Zauberer sind reine Fantasieprodukte
und gehoeren in den Fantasy-Bereich.

So, das musste nochmal gesagt werden.

   Vincent

-----------------------------------------------------------------------------



Re: Re: Neues Stabgimmick (Maharet,  4. Feb 2007, 22:10:46):
~#! rn=Vincent rt=1170506180 rg=gilden.zauberer
~#! tid=1170006758
Aber wir sind doch hier im Fantasy-Bereich ...

-----------------------------------------------------------------------------



Re^3: Neues Stabgimmick (Darklor,  4. Feb 2007, 23:02:34):
~#! rn=Maharet rt=1170623446 rg=gilden.zauberer
~#! tid=1170006758
Trickbetrueger waeren eine andere Gilde, Vincent.


Darklor

-----------------------------------------------------------------------------



Re^3: Neues Stabgimmick (Vincent,  5. Feb 2007, 13:35:17):
~#! rn=Maharet rt=1170623446 rg=gilden.zauberer
~#! tid=1170006758
Zauberstaebe in der hier dargestellten Bedeutung gehoeren in den
Fantasy-Fantasy-Bereich.

   Vincent

-----------------------------------------------------------------------------



Re^4: Neues Stabgimmick (Maharet,  5. Feb 2007, 13:35:57):
~#! rn=Vincent rt=1170678917 rg=gilden.zauberer
~#! tid=1170006758
:singt: "A wizard's staff has a knob at the end."

-----------------------------------------------------------------------------



Dem Demengar sein Guertel... (Chagall,  5. Feb 2007, 21:16:23):
...hat eine kleine Aenderung bzgl. der Einstufung in die
Gildenquestliste erfahren.

MC

-----------------------------------------------------------------------------



Re^4: Neues Stabgimmick (Muadib,  6. Feb 2007, 18:26:58):
~#! rn=Vincent rt=1170678917 rg=gilden.zauberer
~#! tid=1170006758
vincent ist ein wenig zu streng
es ist durchaus so, dass zauberstaebe fuer zauberer voellig unerheblich sind
golfschlaeger dagegen sind fuer zauberer besonders wichtig
da ein zauberstab die form eines golfschlaegers annehmen kann ist hier wieder
ein wenig bedeutung zur ehrenrettung des zauberstabes da

-----------------------------------------------------------------------------



Re^5: Neues Stabgimmick (Montanus,  8. Feb 2007, 09:28:11):
~#! rn=Muadib rt=1170782818 rg=gilden.zauberer
~#! tid=1170006758
Vincent, wir sollten doch nochmal die Kampfgolfergilde in ANgriff nehmen.

-----------------------------------------------------------------------------



Re^6: Neues Stabgimmick (Gwen,  8. Feb 2007, 09:29:53):
~#! rn=Montanus rt=1170923291 rg=gilden.zauberer
~#! tid=1170006758
Besteht das Ziel dabei dann darin, einen Feuerball mit moeglichst wenigen
Schlaegen aus der Kapelle in die FE zu befoerdern?
Gwen.

-----------------------------------------------------------------------------



Re^7: Neues Stabgimmick (Muadib,  8. Feb 2007, 17:53:35):
~#! rn=Gwen rt=1170923393 rg=gilden.zauberer
~#! tid=1170006758
adler sind ziele
andere voegel auch
unter ist schon schwach

-----------------------------------------------------------------------------



Re^7: Neues Stabgimmick (Orktoeter,  8. Feb 2007, 17:54:59):
~#! rn=Gwen rt=1170923393 rg=gilden.zauberer
~#! tid=1170006758
Du willst einen Feuerball in die FE befoerdern? Das ist doch wie Eulen nach
Athen zu tragen..

OrkT.

-----------------------------------------------------------------------------



Re^5: Neues Stabgimmick (Vincent, 10. Feb 2007, 13:34:27):
~#! rn=Muadib rt=1170782818 rg=gilden.zauberer
~#! tid=1170006758
Ich muss Muadib recht geben. Tatsaechlich ist es so, dass Zauberer das
Golfspielen lieben. Ich moechte nicht so weit gehen und behaupten, dass
alle Zauberer gerne Golf spielen, aber immerhin kenne ich einen, bei dem
es so ist, naemlich mich, obwohl ihc gar nicht Golf spielen kann - aber
ich wuerde Golf spielen lieben, wenn ich es koennte.
Und da man dazu einen Golfschlaeger braucht, bietet sich dazu
tatsaechlich der Zauberstab in leicht modifizierter Form an. Hat er ein Mal
die Form eines Golfschlaegers angenommen, ist es ein Leichtes ihn auf die
verschiedenen "Eisen", "Holz", "Putter", "Wedges" etc. zu konfigurieren.

   Vincent

-----------------------------------------------------------------------------



Re^6: Neues Stabgimmick (Vincent, 10. Feb 2007, 13:37:16):
~#! rn=Montanus rt=1170923291 rg=gilden.zauberer
~#! tid=1170006758
Montanus, ich sage es mal so: Diesem Mud fehlt eine Kampfgolfergilde.

Nachdem -wie mehrfach dargelegt - die Zauberergilde im Morgengrauen nicht
der Realitaet entspricht, kann es auch ruhig eine Kampfgolfer geben. Diese
laesst sich sicherlich mit aehnlichen Argumenten, wie die aktuelle
Zauberergilde, fuer dieses Mud plausibilisieren. Da bin ich mir ganz sicher.

  vincent

-----------------------------------------------------------------------------



Re^7: Neues Stabgimmick (Ark, 10. Feb 2007, 13:44:33):
~#! rn=Vincent rt=1171111036 rg=gilden.zauberer
~#! tid=1170006758
Welcher "Realitaet"? "Plausibilisieren" ... ihr spinnt doch. Spielt Golf!


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



ewiger Guertel (Chagall, 17. Feb 2007, 22:14:52):
Huhu,

nur weil ich gerade darauf aufmerksam gemacht wurde, der ewige Guertel
ist momentan nur unter erschwerten Bedingungen zu bekommen. Ein
gewisser Paravogel verhaelt sich nicht so ganz, wie er soll. Also
am besten warten, bis der gefixt ist oder halt einige Kaempfer
verheizen.

MC

-----------------------------------------------------------------------------



Schutzzone und Daemonenfratze (Chagall,  4. Mar 2007, 21:04:17):
Huhu Zaubis,

da hier offenbar berechtigte Beschwerden bzgl. der Lerngeschwindigkeit
der Sprueche Schutzzone und Daemonenfratze aufkamen, wurde hier ein 
wenig am Check des Lerncaches geaendert. Das sollte dazu fuehren, dass
ihr jetzt nicht mehr wochenlang auf einen einzigen Lernerfolg warten
muesst. Die Werte sind zwar noch nicht absolut, aber ich habe die 
Hoffnung, dass es jetzt ein wenig besser sein sollte, falls nicht,
einfach nochmal laut jammern.

MC

-----------------------------------------------------------------------------



Re: Schutzzone und Daemonenfratze (Chagall,  4. Mar 2007, 21:04:49):
~#! rn=Chagall rt=1173038657 rg=gilden.zauberer
~#! tid=1173038657
Achja, noch ein Dank an den gefaehrlichen schwarzen Drachen, der so 
unkompliziert sein OK gegeben hat.

MC

-----------------------------------------------------------------------------



Teleport (Chagall, 24. Mar 2007, 11:57:34):
Huhu Zaubis,

ihr kennt doch sicherlich die tolle Zeile 'Ziel konnte nicht geladen werden.'
Diese Zeile gehoert nun erstmal wieder der Vergangenheit an, ihr koennt ab
sofort wieder wild durch die Gegend teleportieren.

MC

-----------------------------------------------------------------------------



Magisterposten (Chagall, 24. Mar 2007, 13:36:18):
Huhu Zaubis,

durch eine kleine Unachtsamkeit meinerseits, einige moegen es auch Willkuer
nennen, sind gerade saemtliche Magister zwangsweise zurueckgetreten (worden).

Der Grund ist ein etwas sehr restriktiver Check, ob auch alle Bedingungen fuer
einen Magisterposten vorliegen. Der Check ist jetzt erstmal wieder draussen,
kommt aber wieder wenn ich den Fehler gefunden habe, also fangt schonmal an
die Bedingungen zu erfuellen.

Die gute Nachricht ist allerdings, dass ihr keine Magistersperre habt, ihr
duerft also momentan direkt wieder eintreten.

MC

-----------------------------------------------------------------------------



Feuerwalze (Tofu, 29. Mar 2007, 18:39:42):
Huhu Angriffsmagister,

ab sofort koennt ihr wieder durch die Gegend ziehen und arme NPCs mit der
Feuerwalze maltraetieren. Jetzt explodiert sie auch wieder.

MC

PS: Die Mudlib war schuld.

MC

-----------------------------------------------------------------------------



Re: Feuerwalze (Zesstra, 29. Mar 2007, 18:41:52):
~#! rn=Tofu rt=1175186382 rg=gilden.zauberer
~#! tid=1175186382
Stimmt ja gar nicht. Ein unbekannter Gildenmagier ist schuld.
Zesstra

-----------------------------------------------------------------------------



Re: Magisterposten (Chagall,  6. Apr 2007, 13:36:38):
~#! rn=Chagall rt=1174739778 rg=gilden.zauberer
~#! tid=1174739778
Ein zwei Magister hat es beim testen noch mal erwischt. Tut mir leid, 
leider kann ich den Check im Homemud nur bedingt bzw. gar nicht
testen.

MC

-----------------------------------------------------------------------------



Magisteranforderungen (Chagall, 19. Apr 2007, 19:26:36):
Huhu Zaubis,

ich werde in den naechsten Tagen, vorraussichtlich am Sonntag (22.04), 
einen verschaerften Check der Magisterbedingungen aktivieren. Fuer
Zweigmagister heisst das, dass sie automatisch ihren Posten verlassen,
wenn sie nicht mehr alle Bedingungen fuer einen Posten erfuellen.
Alle die an ihrem Posten haengen, aber jetzt schon nicht mehr alle
Bedingungen erfuellen, sollten schleunigst anfangen die Gildenquests
zu loesen.

MC

-----------------------------------------------------------------------------



Re: Magisteranforderungen (Mesirii, 19. Apr 2007, 22:42:11):
~#! rn=Chagall rt=1177003596 rg=gilden.zauberer
~#! tid=1177003596
Ihr koennt auch zu den Chaoten kommen, wir haben nicht so irre Gildenmagier.

Mesi, Chaot

-----------------------------------------------------------------------------



Re: Re: Magisteranforderungen (Croft, 20. Apr 2007, 00:58:59):
~#! rn=Mesirii rt=1177015331 rg=gilden.zauberer
~#! tid=1177003596
Dafuer aber chaotische Gildenmagier.  Ob das besser ist?

Croft

-----------------------------------------------------------------------------



Re: Magisteranforderungen (Chagall, 22. Apr 2007, 11:49:58):
~#! rn=Chagall rt=1177003596 rg=gilden.zauberer
~#! tid=1177003596
Huhu Zaubis,

der Check ist jetzt aktiviert. Ich habe das ganze ueber mehrere Tage im
Homemud getestet. Sollte es dennoch zu Problemen geben, sagt mir einfach
Bescheid.

MC

PS: Wer zwangsweise zuruecktritt, hat keine Sperrzeit von vier Tagen. Also
einfach die Bedingungen wieder erfuellen und man kann direkt wieder in den
Zweig eintreten.

-----------------------------------------------------------------------------



Zauberer und Waffen (Chagall, 11. Aug 2007, 22:06:29):
Falls einigen von Euch ploetzlich auffallen sollte, dass sie als
Zauberer ploetzlich keine Vollstrecker oder Superduperruestungen
mehr tragen koennen, das war von Anfang an so gewollt. Warum das
die letzten Monate nicht mehr ging, weiss ich nicht, ist jetzt aber
auch egal, denn der Bug ist raus. Ab jetzt duerft ihr Euch wieder auf
Euer magisches Geschick als auf nutzlose Waffen verlassen.

MC

-----------------------------------------------------------------------------



Sun-Para (Chagall,  5. Nov 2007, 18:19:17):
Sun-Para hatte sich einen kurzen Urlaub gegoennt, ist jetzt aber wie 
gewohnt zu erreichen.

MC

-----------------------------------------------------------------------------



stabhilfe lerncache (Chagall, 20. Nov 2007, 20:52:39):
Da ich immer wieder gefragt werde, warum man ploetzlich nichts mehr lernt, den
werde ich ab sofort auf 'stabhilfe lerncache' verweisen.

MC

-----------------------------------------------------------------------------



Kuratorenstupse (Chagall, 21. Nov 2007, 21:17:04):
Die Stupse fuer die einzelnen Kuratoren wurden vorerst deaktiviert, auch wenn
das Kerbholz euch was anderes vorgaukelt. Ob die EKs endgueltig deaktiviert
werden, ob sie in der jetzigen Form bleiben oder ob sie (eines Tages) neu
geholt werden muessen, steht momentan noch nicht fest. Meine Tendenz neigt ja
zum neu holen, wobei das dann sicherlich nicht mehr ganz so einfach sein wird.

MC

-----------------------------------------------------------------------------



Frohe Weihnachten (Chagall, 24. Dez 2007, 11:15:02):
Fuenf grosse, magische Spiegel bedecken die Waende dieses fuenfeckigangelegten
Raumes und bieten Dir einen grossartigen Ausblick - jeder der Spiegel naemlich
zeigt Dir einen anderen Ort des Morgengrauens. Auf dem praechtigen mit Marmor
ausgelegten Boden kannst Du ein Muster erkennen.

Ploetzlich steht eine Gestalt im Raum, gekleidet in eine schwarze Robe, die
Kapuze tief in das Gesicht gezogen. Magische Beschwoerungen murmelnd hebt er
seine Haende und aus seinen Fingerspitzen zucken gleissende Blitze. Jeder
Spiegel leuchtet kurz auf, als er vom Blitz getroffen wird, dann ist der Spuk
auch schon vorbei.

Die Gestalt schaut noch pruefend in einen der Spiegel, nickt kurz und
verschwindet wieder.

-----------------------------------------------------------------------------



Hellsichtzweig (Chagall, 10. Feb 2008, 18:30:45):
Huhu Zaubis,

ich habe einige interne Umstellungen im Hellsichtbereich vorgenommen. Sollte
also bei schaetz, werte, identifziere etc. ein anderes Verhalten urploetzlich
auftauchen, so moegt ihr das entweder akzeptieren oder mir mitteilen, damit
ich noch einmal nachschauen kann.

Des weiteren hat der Spruch wahrsagen eine kleine Aenderung erfahren. Kuenftig
wird der Hellsichtmagister nicht mehr sein ganzes Inventar zu sehen bekommen,
wenn er den Spruch ohne Argument castet. Wer trotzdem Wert darauf legt, sein
Inventar wahrzusagen, der moege Bitte die Hilfeseite des Spruchs noch einmal
lesen.
MC


-----------------------------------------------------------------------------



kleine Aenderung in zemote (Chagall, 14. Feb 2008, 20:58:31):
Huhu Zaubis,

ich habe einen kleinen Bug in zemote repariert. Dies hat allerdings einen
kleinen Nachteil fuer Euch, bzw. ihr muesst Euch jetzt ein wenig umstellen.

Bisher konnte mit dem Parameter + der Text 'alle Zauberer' irgendwo in das
zemote gepackt werden. Dummerweise tat das nicht mehr so wie es sollte, sprich
es buggte. Deshalb wurde jetzt der Parameter '+' durch den Paramter '/'
ersetzt. Wenn ihr also zukuenftig in einem zemote den Text 'alle Zauberer'
nutzen wollt, muesst ihr jetzt halt das '/' nehmen.

Die entsprechende Hilfeseite werde ich in Kuerze aktualisieren.

MC

-----------------------------------------------------------------------------



Nachtsicht (Chagall, 17. Feb 2008, 22:56:45):
Huhu Zaubis,

der Spruch 'nachtsicht' funktioniert momentan nicht so, wie er es eigentlich
soll. Selbst mit geglueckter Nachtsicht koennt ihr nichts in einem dunklen
Raum sehen. OK, betrifft eh kaum einen, da nahezu alles hier im Mud leuchtet,
ich wollte es trotzdem nur erwaehnen, falls sich wer wundert.

MC

-----------------------------------------------------------------------------



Re: Nachtsicht (Vardion, 20. Feb 2008, 21:44:14):
~#! rn=Chagall rt=1203285405 rg=gilden.zauberer
~#! tid=1203285405
Den Spruch benutzt eh keiner, lass Dir Zeit ;)

Vardion

-----------------------------------------------------------------------------



Re: Re: Nachtsicht (Chagall, 20. Feb 2008, 22:07:14):
~#! rn=Vardion rt=1203540254 rg=gilden.zauberer
~#! tid=1203285405
Ich muss mir Zeit lassen, da das Spellmapping betroffen ist. Und das kann ich
nicht so ohne weiteres aendern.

Mc

-----------------------------------------------------------------------------



Schutz und Schutzhuelle (Chagall,  8. Mar 2008, 16:16:30):
Huhu Zaubis,

es gibt einige Aenderungen im Abwehrzweig. Magistern ist es ab sofort
moeglich, ein ganzes Team mittels Schutz oder Schutzhuelle zu schuetzen.
Hierbei gibt es aber einige Einschraenkungen:

 - man kann nur das Team schuetzen, in dem man sich befindet
 - die Kosten erhoehen natuerlich auch
 - um sein Team im Kampf zu schuetzen, darf man nicht in Teamreihe 1 stehen
 - wenn man den Spruch Schutzhuelle auf das gesamte Team sprechen moechte, so
   benoetigt man zwingend ewigen Schiefer

Eine weitere Einschraenkung betrifft das casten von Schutz/Schutzhuelle auf
andere. Ihr solltet jetzt tunlichst in der Naehe, sprich im selben Raum
bleiben, damit Schutz/Schutzhuelle die volle Wirkung entfalten kann.

Bugmeldungen, Flames etc. an mich.

-----------------------------------------------------------------------------



Re: Schutz und Schutzhuelle (Zesstra, 12. Mar 2008, 23:00:02):
~#! rn=Chagall rt=1204989390 rg=gilden.zauberer
~#! tid=1204989390
Tolle Sache. :-)

Zesstra

-----------------------------------------------------------------------------



Aenderung in Befriede (Chagall, 24. Mai 2008, 12:46:59):
Huhu Zaubis,

auf Anweisung der Gildenbalance verhaelt sich der Spruch 'befriede' nun ein
wenig anders. Konnte man frueher einen befriedbaren NPC auf Dauer ruhig
stellen, indem man ihn staendig (neu) befriedet hat, so ist dies nun nicht
mehr moeglich. Fuer Spieler, welche Ahnung von der Mudlib haben, das Stichwort
heisst hier QueryPacifiy.

MC

-----------------------------------------------------------------------------



Re: Aenderung in Befriede (Chagall, 24. Mai 2008, 13:05:13):
~#! rn=Chagall rt=1211626019 rg=gilden.zauberer
~#! tid=1211626019
Da ich gerade erst erfahren habe, dass die Funktion QueryPacify erst ab reboot
das gewuenschte Verhalten zeigt (die jetzige Implementation ist wohl
suboptimal), ist das ganze erstmal wieder rueckgaengig gemacht. Kommt mit dem
naechsten Reboot aber wieder, keine Sorge.

MC

-----------------------------------------------------------------------------



Schutz/Huelle auf Teams (Chagall, 14. Jul 2008, 21:36:29):
Huhu Zaubis,

da ich heute erstmal wieder eine alte Spellbookversion eingespielt habe, damit
das Gejammer ueber fehlende Endemeldungen und sich angeblich in Nichts
aufloesende Zauberschilde ein hat, ist damit auch vorruebergehend der Schutz
auf ganze Teams deaktiviert. Wenn ich Zeit, Lust und Laune habe, bau ich das
wieder ein.

MC

-----------------------------------------------------------------------------



Re: Schutz/Huelle auf Teams (Gnome, 14. Jul 2008, 21:43:55):
~#! rn=Chagall rt=1216064189 rg=gilden.zauberer
~#! tid=1216064189
kleine korrektur: die loesen sich tatsaechlich auf, nicht nur angeblich.
sonst waere das alles halb so wild.
und die endemeldungen kommen wohl, aber nicht zum richtigen zeitpunkt.

gnOme

-----------------------------------------------------------------------------



Re: Re: Schutz/Huelle auf Teams (Chagall, 14. Jul 2008, 21:45:03):
~#! rn=Gnome rt=1216064635 rg=gilden.zauberer
~#! tid=1216064189
Ich hab es schon auf zrufe gesagt: keinen der Bugs kann ich im Homemud
nachstellen. 

-----------------------------------------------------------------------------



Re^3: Schutz/Huelle auf Teams (Maharet, 15. Jul 2008, 08:16:56):
~#! rn=Chagall rt=1216064703 rg=gilden.zauberer
~#! tid=1216064189
Dann lassen wir doch die Zaubis in Zukunft in deinem Homemud spielen, das
senkt den MG-Jammerlevel gleich dramatisch ;)

-----------------------------------------------------------------------------



Re^4: Schutz/Huelle auf Teams (Vector, 15. Jul 2008, 11:10:17):
~#! rn=Maharet rt=1216102616 rg=gilden.zauberer
~#! tid=1216064189
in punkto jammern wurden die zaubis laengt von chaoten
und trves ueberholt. laengt. so richtig lange laengst.
die trves jammern immerhin zurecht.

-----------------------------------------------------------------------------



Re^5: Schutz/Huelle auf Teams (Amaryllis, 15. Jul 2008, 20:43:42):
~#! rn=Vector rt=1216113017 rg=gilden.zauberer
~#! tid=1216064189
Du verwechselst da was. Die Chaoten jammern nicht, sondern die anderen
jammern, wie ungerecht stark doch die Chaoten sind.
Im Eifer des "ich bin zu schwach"-Geheules verwechselt man gerne mal den
Blickwinkel...

Ama*

-----------------------------------------------------------------------------



Re^6: Schutz/Huelle auf Teams (Vector, 15. Jul 2008, 20:47:11):
~#! rn=Amaryllis rt=1216147422 rg=gilden.zauberer
~#! tid=1216064189
und was es mit jammern zu tun hat wenn man nach monaten buggender
ende-meldung bei schutzspruechen mal dem gildenchef sagt dass da
immer noch was nicht rund laeuft lass ich mir dann bei gelegenheit
nochmal erklaeren
(man stelle sich chaoten vor die seit monaten nimmer mitkriegen
wenn die chaosruestung rebelliert oder schutz ausgeht, kleris die
nen fehlenden heiligenschein nicht mitbekommen, und dunkelelfen
die dank fehlender auslauf-meldung ohne aura/sonnenschutz rumlaufen
die dank fehlender auslauf-meldung ohne aura/sonnenschutz rumlaufen
duerfen)
keine ahnung warum da einige wieder das thema jammern auspacken,
vielleicht macht der gewohnheit, und alte esel kann man nicht
an neues futter gewoehnen
(antwort auf letzten artikel usw usw)

-----------------------------------------------------------------------------



Re^5: Schutz/Huelle auf Teams (Amaryllis, 15. Jul 2008, 20:51:24):
~#! rn=Vector rt=1216113017 rg=gilden.zauberer
~#! tid=1216064189
V. schrub:
> keine ahnung warum da einige wieder das thema jammern auspacken

Weil Du Dich anscheinend nicht an Deinen letzten Artikel erinnern kannst.
Ich darf mal Dein Gedaechtnis auffrischen.

Zitat:
"in punkto jammern wurden die zaubis laengt von chaoten
und trves ueberholt. laengt. so richtig lange laengst.
"

Danke fuers Zuhoeren.

Ama*

-----------------------------------------------------------------------------



Re^6: Schutz/Huelle auf Teams (Vector, 15. Jul 2008, 20:54:03):
~#! rn=Amaryllis rt=1216147884 rg=gilden.zauberer
~#! tid=1216064189
das "jammern" wurde von chagall und maharet ausgepackt, auf
ein wie ich finde legitimes hinweisen (oder nenne es noergeln)
von gwendula, dass seit monaten die callouts nicht syncron mit
dem spell laufen.

-----------------------------------------------------------------------------



Re^7: Schutz/Huelle auf Teams (Gloinson, 15. Jul 2008, 20:59:42):
~#! rn=Vector rt=1216148043 rg=gilden.zauberer
~#! tid=1216064189
Warum koennen sich nicht alle liebhaben?


Nachdem ihr in den Klerus eingetreten seid, selbstverfrelich.

PS: Jetzt mit noch mehr WTF/m.


-----------------------------------------------------------------------------



Re^8: Schutz/Huelle auf Teams (Chagall, 15. Jul 2008, 21:47:41):
~#! rn=Gloinson rt=1216148382 rg=gilden.zauberer
~#! tid=1216064189
Bevor die ganze Diskussion 'wer jammert besser und wer am meisten' sollten
wir diese Diskussion besser beenden. Sie fuehrt eh zu nichts. Weiterhin
moechte
ich mich fuer meinen etwas harschen Ton von gestern (sowohl MPA als auch auf
zrufe) entschuldigen.
Mich hat gestern eine Meldung ereilt, die nur sehr schwer zu verdauen ist und
an der ich sicherlich noch einige Zeit zu knabbern
habe.

Teamschutz kommt wieder, genauso wie die Aenderung, dass man anwesend sein
muss, wenn der Schutz wirken soll. Nicht naechste Woche, nicht uebernaechste,
momentan brauch ich mehr Zerstreuung. Und nein, programmieren lenkt mich in
dem Fall nicht ab.

MC


-----------------------------------------------------------------------------



Re^7: Schutz/Huelle auf Teams (Maharet, 15. Jul 2008, 22:29:33):
~#! rn=Vector rt=1216147631 rg=gilden.zauberer
~#! tid=1216064189
Stimmt, wenn ich deinen Beitrag lese, weiss ich auch gar nicht, wie man Zaubis
und Jammern in Verbindung bringen kann. Sorry, mein Fehler.

-----------------------------------------------------------------------------



Re^8: Schutz/Huelle auf Teams (Vector, 16. Jul 2008, 02:41:37):
~#! rn=Maharet rt=1216153773 rg=gilden.zauberer
~#! tid=1216064189
boah was fuer sarkasmus und ironie und das von der
diplom-jammertante die bei jeder noch so kleinen
aenderung von den trves ein geheule macht als waers
nun die groesste abwertung seit beginn der gilde
echt krasse wurst.
oh moment man darf dich ja nicht kritisieren
sonst sparen sich wieder leute die neuspielerwerbung
ganz grosses tennis....

-----------------------------------------------------------------------------



Re^9: Schutz/Huelle auf Teams (Nibel, 16. Jul 2008, 08:52:09):
~#! rn=Vector rt=1216168897 rg=gilden.zauberer
~#! tid=1216064189
Paper is fine, nerf rock.

Sincerely, Scissors.
  - N
-----------------------------------------------------------------------------



Aenderungen in Befriede (II) (Chagall, 10. Aug 2008, 19:47:13):
So, mit Reboot wird/wurde die Aenderung im Befrieden aktiv. Kurz
zusammengefasst, man kann einen NPC nun nicht mehr ewig hintereinander
befrieden. Bitte testet das ausgiebig und gibt auch ein wenig Feedback dazu
ab.

MC

-----------------------------------------------------------------------------



Re^5: Idee Kaempferfaehigkeit (Zesstra,  6. Sep 2008, 00:01:09):
~#! rn=Gloinson rt=1220651717 rg=gilden.klerus
~#! tid=1220646566
Machen wir jetzt einmal die Tour durch die Gilden? ;-)
Ich finde ja, ein hoher Zaubi kann sein Team durch die Kraft seines Geistes
motivieren und zu groesseren Leistungen bringen. ;-))

Zesstra

-----------------------------------------------------------------------------



Re^6: Idee Kaempferfaehigkeit (Gloinson,  6. Sep 2008, 00:02:03):
~#! rn=Zesstra rt=1220652069 rg=gilden.zauberer
~#! tid=1220646566
Kraft seines Geizes?


-----------------------------------------------------------------------------



Re^7: Idee Kaempferfaehigkeit (Ark,  6. Sep 2008, 00:04:23):
~#! rn=Gloinson rt=1220652123 rg=gilden.zauberer
~#! tid=1220646566
Kraft seines Greises.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^8: Idee Kaempferfaehigkeit (Gloinson,  6. Sep 2008, 00:05:53):
~#! rn=Ark rt=1220652263 rg=gilden.zauberer
~#! tid=1220646566
Zauberer haben einen Privatark?


-----------------------------------------------------------------------------



Re^9: Idee Kaempferfaehigkeit (Darklor, 14. Sep 2008, 06:01:21):
~#! rn=Gloinson rt=1220652353 rg=gilden.zauberer
~#! tid=1220646566
Zaubis jammern der Gruppe was vor, so dass sie ermutigt wird sich todesmutig
ins Kampfgetuemmel zu stuerzen (denn wer will bei dem Gejammer schn ewig leben
;))

Darklor

-----------------------------------------------------------------------------



Re: Schutz/Huelle auf Teams (Chagall, 28. Sep 2008, 10:15:38):
~#! rn=Chagall rt=1216064189 rg=gilden.zauberer
~#! tid=1216064189
Huhu Zaubis,

Schutz bzw. Schutzhuelle auf Teams ist jetzt erstmal (testweise) wieder da.
Bitte testet das ausgiebig, insbesonders mit Begleitnpcs im Team und all den
anderen Kram, den sich so ein krankes Spielerhirn einfallen lassen kann.

Feedback und Kritik geht an mich, wenn ihr jammern wollt, geht zu Brieseltrim.

MC

-----------------------------------------------------------------------------



entsorge (Chagall,  3. Okt 2008, 18:31:00):
Huhu Zaubis,

entsorgen sollte jetzt wieder so funktionieren, wie es einmal war. Falls
nicht, laut jammern und Fehlermeldungen an mich weitergeben.

MC

-----------------------------------------------------------------------------



Re: entsorge (Amaryllis,  3. Okt 2008, 18:34:43):
~#! rn=Chagall rt=1223051460 rg=gilden.zauberer
~#! tid=1223051460
"Laut jammern" sollte ja fuer nen Zaubi kein Problem sein...

scnr,
Ama*

-----------------------------------------------------------------------------



Re: Re: entsorge (Danu,  3. Okt 2008, 18:41:22):
~#! rn=Amaryllis rt=1223051683 rg=gilden.zauberer
~#! tid=1223051460
entsorge Ama*
Wie bitte?
entsorge Amaryllis
Nichts passiert.

hmpf. 

Chagahall! Dat funzt nich!

-----------------------------------------------------------------------------



Re^3: entsorge (Chagall,  3. Okt 2008, 18:49:57):
~#! rn=Danu rt=1223052082 rg=gilden.zauberer
~#! tid=1223051460
Unken sind generell nicht entsorgbar. Um sie loszuwerden, muss man aber
einfach nur den Tuempel in die Wueste verfrachten.

MC

-----------------------------------------------------------------------------



zaubersprueche bei lars lernen macht spass! (Bijou, 28. Jan 2009, 20:22:52):
in meinem wahn griff ich llystrathe an und landete bei lars, waehrend sie mir
gerade den werte-zauber beibrachte... hier ein kleiner logausschnitt...
Du fragst mitfuehlend: Zook?

Lars nickt.

Du starrst Llystrathe an.

Lars sagt: Er hat verfuegt, dass jeder, der wiedergeboren werden will,
Lars sagt: einen Antrag stellen muss.

Du durchschaust Llystrathe.

Llystrathe ist frech.

Lars sagt: Der wird dann per Mail an die Erzmagier geschickt.

Llystrathe sagt: Genau so, gut gemacht.

Lars sagt: Und die befinden dann darueber.

Llystrathe sagt: Achja, noch etwas. Anfangs wirst Du noch nicht alles ueber
Llystrathe sagt: Dein Ziel in Erfahrung bringen. Erst mit steigendem Koennen
Llystrathe sagt: hier in der Gilde wird es Dir gelingen alle Informationen
Llystrathe sagt: zu bekommen.

Lars seufzt.

Lars sagt: Wenn die alle nur ideln dann kann das dauern.

Du schluchzt. Wie lange wirst Du hier nur festhaengen?

Lars sagt: OK, dann fangen wir mal an. Hier ist Formular TOD-A-13.

Llystrathe wendet sich wieder Randar Tobis zu, welcher immer noch missmutig
gelaunt aussieht.

Lars gibt Dir einen Wisch.

Du schaust auf das Papier und liest.

Llystrathe sagt: So, Randar. Wo waren wir noch einmal stehen geblieben?

-------------------------------------------------------------
|                                                           |
|                     TOD-A-13                              |
|                                                           |
|                                                           |
|-----------------------------------------------------------|
| Ich bin gestorben und beantrage Wiederbelebung mit dem    |
| alten Namen und den alten Attributen, des weiteren mit    |
| denselben Quests.                                         |
|                                                           |
| Name:                                                     |
| Todesursache:                                             |
|                                                           |
|                                                           |
| Ich versichere, meine Angaben richtig gemacht zu haben.   |
| Wenn nicht, stimme ich zu, als NPC in einer minderwertigen|
| Quest wiedergeboren zu werden, wo mich alsbald Spieler    |
| umhauen werden.                                           |
|                                                           |
| Unterschrift:                                             |
-------------------------------------------------------------

Llystrathe sagt: Achja, meine Entscheidung bleibt, Du kannst Dir nicht einfach
Llystrathe sagt: so einige Tage frei nehmen.

Randar grummelt und murmelt irgendetwas vor sich hin.

Du lernst einen neuen Zauberspruch.
Seufzend fuellst Du das Formular aus.

Du gibst Lars das Formular.

Lars nickt und liest das Formular.

Dann beginnt er wild zu kichern.

Lars sagt: Coole Todesursache.

Du seufzt.

Lars sagt: He, mach Dir nix draus. Da sind schon andere dran gestorben.

Du nickst seufzend.

Lars sagt: OK, dann mal ab damit...

[Beileid:Kanyahon] so ists recht, wenn die zaubis sich gegenseitig umlegen ;-)
Lars macht eine magische Handbewegung und das Papier fliegt gen einem
grossen Briefkasten, auf dem ERZMAGIER steht.

Du fragst: Und jetzt?

Lars sagt: Nun beraten die Erzmagier darueber.

Du sagst: Und wenn die ideln? Oder nicht da sind?

Lars sagt: Naja das kann schonmal ne Woche oder zwei dauern bis die
Lars sagt: sich melden.

Du schluckst.

Du fragst: Echt?

Lars nickt.

Lars sagt: Macht ja nix. Solange koennen wir ja Volleyball spielen.

Du sagst: Eigentlich wollte ich lieber metzeln...

Lars grinst.

Lars sagt: Koennen wir auch machen. Komm, wir gehen zum Weghier!

Du freust Dich.

Lars schnippst mit den Fingern, und ihr steht beim Weghier.

Du befindest Dich am Ende eines Waldweges durch den
Grimmswald. Im Westen kannst Du eine Lichtung erkennen.
Es gibt viele sichtbare Ausgaenge: hilfe, raus, westen, notausgang, argh,
egalwohin, ichwillhierraus, nichtswieweg, maaamiiiiii, ichwillhierweg und
weitweg.
Der Weghier.



-----------------------------------------------------------------------------



Mehrere Angriffsspells pro Runde (Chagall, 11. Apr 2010, 11:21:28):
Huhu Zaubis,

es ist nun nicht mehr moeglich, zwei verletze/feuerball/etc. pro Runde zu
casten. Danke an all die, welche den Bug schon vor geraumer Zeit gemeldet
haben.

MC

-----------------------------------------------------------------------------



ewiger Guertel (Chagall,  6. Sep 2010, 20:12:54):
Huhu Zaubis,

es gibt eine kleine Aenderung am ewigen Guertel. Da ich aber zu faul/feige bin
mal eben saemtliche Guertel inkl. Komponenten auszutauschen, habt ihr erstmal
den alten behalten. Wer unbedingt einen neuen will, der moege doch bitte Ende
machen.

Chagall

-----------------------------------------------------------------------------



Vorahnung (Chagall, 17. Okt 2010, 12:23:14):
Huhu Zaubis,

Hellsichtmagister duerfen sich heute einmal freuen, denn es gab einen kleinen
Bugfix im Spruch Vorahnung. Ab jetzt duerft ihr wieder mehr als nur ein
einziges Mal pro Uptime in die Zukunft schauen.

MC

-----------------------------------------------------------------------------



Schutzzone (Chagall, 16. Nov 2010, 21:39:48):
Huhu,

die Schutzzone sollte ab sofort nicht mehr so einen massives Auf- und Ab beim
Abfangen von eingehendem Schaden zeigen und sich damit auch wieder lohnen,
wenn Kaempfer oder Karateka beim Kampf helfen.

Sobald der FTP wieder funktioniert, gibt es auch eine Aktualisierung am
Gildenbrett dafuer, mit noch einigen Details. Und dann kriegt die Schutzzone
auch endlich Meldungen, was sie da so treibt. Bis dahin muesst ihr halt noch
ausharren.

MC

-----------------------------------------------------------------------------



Drachenblut vs. Drachenblut (Chagall, 25. Aug 2011, 21:00:34):
Huhu Zaubis,

ich habe vorhin etwas bei Paracelsus debuggt, was zur Folge hat, dass es nun
eine
weitere Art von Drachenblutflaeschchen gibt (ja, die fuer die Tanjianquest um
genau 
zu sein). Diese Art von Drachenblut ist aber nicht fuer hand saeure
vorgesehen, sondern fuer einen anderen Spruch. Um welchen Spruch es sich
handelt, duerft ihr gerne selbst herausfinden.

MC

PS: Formatierung saugt, bin aber zu faul die jetzt zu aendern :)

-----------------------------------------------------------------------------



Spells zu schwach? (Chagall,  9. Jan 2012, 22:46:31):
Huhu Zaubis,

lobt, preisigt und huldigt Zesstra, die vorhin in muehsamer Kleinsarbeit in
die Abgruende des Zaubererspellbooks geschaut und den Bug gefunden hat, der
ploetzlich eure Spells bedeutend schwaecher hat werden lassen.

MC

PS: Ich war unschuldig daran, wirklich. :)

-----------------------------------------------------------------------------



Re: Re: Spells zu schwach? (Zesstra,  9. Jan 2012, 22:49:28):
~#! rn=Zesstra rt=1326145703 rg=gilden.zauberer
~#! tid=1326145591
Das PS: stimmt, Chagall ist wirklich unschuldig. Das eigentliche Problem geht
bestimmt 15 jahre zurueck. Dass es solange funktioniert hat, war eher Zufall
koennte noch ein paar andere Inkonsistenzen mit sich gebracht haben -
insofern: schoen, dass es auffiel und von euch angemeckert wurde. :-)

Zesstra

-----------------------------------------------------------------------------



Von Froeschen, Identifizieren, Schaetzen und Zauberstaeben (Chagall,  2. Feb 2012, 20:54:34):
Huhu Zaubis,

einige haben ja festgestellt, dass froschen nicht mehr funktionierte ohne
FiRZG zu werfen, genauso wie das Schaetzen/Identifizieren von Objekten in
anderen Raeumen. Die gute Nachricht ist, dass der Bug nun draussen ist. Die
schlechte Nachricht ist allerdings, dass ihr ab sofort ein Stabgimmick weniger
habt.

Frosche ist ab sofort kein Stabgimmick mehr, sondern ein eigener Spell im
Standardspellbook. Er wird weiterhin bei Level 7 gelernt (automatisch) und
muss auch nicht geuebt werden und taucht auch nicht bei 'teile llystrathe mit
faehigkeiten' auf.

Die Zauberer, welche den Spell frueher als Stabgimmick hatten, werden bei
erneutem einloggen ins mud automatisch von der Gilde um den neuen Spell
bereichert.

Eure Zauberstaebe wurden auch erneuert, da dort jetzt das Kommando fuer das
Gimmick entfernt wurde, falls ihr keinen mehr habt, Llystrathe gibt euch gerne
einen neuen, damit ihr damit weiterhin Kaempfer knueppeln koennt.

MC

-----------------------------------------------------------------------------



Entsorgen von Netztoten (Arathorn, 16. Aug 2012, 22:35:54):
Moin zusammen,

das im Subject beschriebene Verhalten, das Entsorgen von netztoten Spielern,
die (aus welchem Grund auch immer) nicht im Netztotenraum rumstehen, sollte
nun nicht mehr moeglich sein.

Dank an Vector fuers Ausprobieren und an Moonshine fuers Bescheidsagen. *g*

Gruss, Arathorn.

-----------------------------------------------------------------------------



Re: Entsorgen von Netztoten (Vector, 16. Aug 2012, 22:43:12):
~#! rn=Arathorn rt=1345149354 rg=gilden.zauberer
~#! tid=1345149354
netztote spieler konnte man nie entsorgen. nie :)
problem ist wenn netztote spieler dann stundenlang nicht mehr 
ausgeloggt sind und nicht mehr als living gelten kennt
der zaubistab keine gnade.
wenn das oefters vorkommen wuerde haette ich bereits zig
feenringe und mehrere elfenbeinbloecke von xties ausgeliehen:)

-----------------------------------------------------------------------------



Re: Re: Entsorgen von Netztoten (Arathorn, 16. Aug 2012, 22:46:38):
~#! rn=Vector rt=1345149792 rg=gilden.zauberer
~#! tid=1345149354
Bin da jetzt grad nicht 100pro im Bilde, muesste ich nachschauen, ob es da
eine Art "grace time" gibt, und wie lange die ist, aber bei Netztoten, die
schon laenger im Netztotenraum rumstehen, ist es definitiv so, dass sie
_nicht_ mehr als Lebewesen gelten und damit ohne weiteres entsorgbar 
waren. 

Arathorn.

-----------------------------------------------------------------------------



Re^3: Entsorgen von Netztoten (Vector, 16. Aug 2012, 22:47:26):
~#! rn=Arathorn rt=1345149998 rg=gilden.zauberer
~#! tid=1345149354
eben, er war netztot, stundenlang nimmer eingeloggt, damit kein
living mehr und dann hab ich mit meinem stab in moonshine
rumgespielt :)

-----------------------------------------------------------------------------



Re^4: Entsorgen von Netztoten (Ark, 16. Aug 2012, 22:50:18):
~#! rn=Vector rt=1345150046 rg=gilden.zauberer
~#! tid=1345149354
Buaeh, Nekrotismus.


              *** ARK * the * Magnificent ***


-----------------------------------------------------------------------------



Re^5: Entsorgen von Netztoten (Vector, 16. Aug 2012, 22:51:27):
~#! rn=Ark rt=1345150218 rg=gilden.zauberer
~#! tid=1345149354
bin mir uebrigens recht sicher, dass moonshine
nichtmal n stabmagiepunkt wert war :)

-----------------------------------------------------------------------------



Re^6: Entsorgen von Netztoten (Chagall, 17. Aug 2012, 08:26:38):
~#! rn=Vector rt=1345150287 rg=gilden.zauberer
~#! tid=1345149354
Moonshine ist noch nicht mal ins entsorge-Log gewandert. Und er hat viel zu
viel Muell im Inventar. :)

MC

-----------------------------------------------------------------------------



Frosche (Chagall, 31. Aug 2012, 08:48:34):
Huhu,

das froschen sollte jetzt wieder funktionieren, wenn nicht, bitte kurz an mich
wenden.

MC

-----------------------------------------------------------------------------



Beschwerde (Zesstra,  3. Nov 2012, 15:31:56):
Sauerei! Skandal! Amtsanmassung!

Ich musste soeben feststellen, dass die sog. Kuraoren der Gilde offenbar
allesamt Betrueger sind!
Keiner von diesen hat ueberhaupt einen Gildenrang vorzuweisen. Damit haben sie
sich offenbar an Pruefungen unrechtmaessig vorbeigemogelt, an denen die
normalen Gildenmitglieder regelmaessig verzweifeln.
Ausserdem scheint mir die Qualitaet der Ausbildung der Gildenmitglieder auf
diese Weise hochgradig gefaehrdet zu sein.

Werte Erzmagistra Llystrathe, ich bitte doch sehr darum, zu pruefen, wie es zu
dieser Situation kommen konnte und geeignete Massnahmen zu treffen, dass in
Zukunft nur ordentlich ausgebildete Gildenmitglieder das Amt eines Kurators
bekleiden koennen.

Zesstra

-----------------------------------------------------------------------------



Re: Beschwerde (Zook, 10. Nov 2012, 11:52:30):
~#! rn=Zesstra rt=1351953116 rg=gilden.zauberer
~#! tid=1351953116
Das faellt ja frueh auf. 
Ich habe diese Spitzhuete ja schon immer verdaechtig gefunden.
Zook

-----------------------------------------------------------------------------



Lernen von 'frosche' (Chagall, 15. Dez 2012, 19:39:08):

Huhu Zaubis,

frosche sollte nun wieder automatisch gelernt werden, sobald man die
entsprechenden Bedingungen erfuellt. Fuer diejenigen, denen der Spruch
momentan noch fehlt, obwohl sie schon alle Bedingungen dafuer erfuellt haben,
denen empfehle ich kurz das aus- und wieder einloggen.

Gruss
MC

-----------------------------------------------------------------------------



Llystrathe (Chagall, 15. Dez 2012, 20:59:06):

Huhu Zaubis,

Llystrathe verschluckt sich nun nicht mehr bei einem 'teile llystrathe mit
faehigkeiten' an der Formatierung des Textes.

MC

-----------------------------------------------------------------------------



Von Saphire und Rubinen (Chagall, 19. Dez 2012, 21:58:01):
Huhu Zaubis,

durch ein kleines Missgeschick meinerseits haben sich gerade alle ewigen
Rubine in Nichts aufgeloest. Bitte also neu holen. Dafuer duerft ihr die jetzt
ohne Skrupel einsetzen, so schnell gehen die nicht mehr kaputt.

Fuer die Saphire gilt das ebenfalls, allerdings haben die das Update
ueberlebt.

MC

-----------------------------------------------------------------------------



Entsorgen von Dingen (Arathorn, 19. Apr 2014, 19:42:40):
Hallo Zauberer,

beim Entsorgen grosser Mengen von Gegenstaenden gibt es jetzt eine 
Begrenzung: pro Durchgang werden nur noch max. 100 Gegenstaende entsorgt.

Diese Aenderung ist erforderlich, um Bugs beim Entsorgen zu vermeiden.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Llystrathe (Chagall, 21. Jun 2015, 21:08:24):
Huhu,

damit hier auch mal wieder ein Artikel steht.

Ich hab ein wenig mit und an Llystrathe rumgespielt. Sollte sie sich also
ploetzlich nicht mehr so verhalten wie vorher, einfach kurz Bescheid geben.

Und damit Elendil zu jammern aufhoert, darf er sich nun ueber eine erweiterte
Ausgabe bei teile 'llystrathe mit hilfestatus'. Kann allerdings sein, dass in
dem Ausgabetext die Umbrueche leicht falsch sind, Llys war da ein wenig
zickig.

MC

-----------------------------------------------------------------------------



1 (Elendil, 21. Jun 2015, 23:25:30):
~#! rn=Chagall rt=1434913704 rg=gilden.zauberer
~#! tid=1434913704
Danke :)

Wobei ich mich nicht entsinnen kann, gejammert zu haben :)

Schliesst die Erzmagister wieder ohne Vorteile fuer den Zauberer an, damit die
Gilde vollstaendig ist. Diesbezueglich wuerde ich gerne jammern, aber dafuer
bin ich zu zuversichtlich, dass das passiert ;) - glaube ich ;)

-----------------------------------------------------------------------------



Re: 1 (Rhoakka, 23. Jun 2015, 17:38:56):
~#! rn=Elendil rt=1434921930 rg=gilden.zauberer
~#! tid=1434913704
jammer nicht!

-----------------------------------------------------------------------------



Re: Re: 1 (Huraxprax, 23. Jun 2015, 20:33:44):
~#! rn=Rhoakka rt=1435073936 rg=gilden.zauberer
~#! tid=1434913704
Jammern ist doch bei Zaubis ein Skill. Fast wie bei Werwoelfen, nur die nennen
es Heulen.

-----------------------------------------------------------------------------



Schmuggel in Moron? (Arathorn, 11. Mai 2016, 18:53:04):
Hallo Zauberer und Zauberinen,

ich sah in den letzten Tagen immer wieder einmal Abenteurer aus Moron
herausschleichen, die auffaellige Buendel in der Hand trugen. Stellt euch
mein Erstaunen vor, als ich einem von ihnen heimlich folgte und sah, dass
er seine Beute zu einem Mitglied eurer Gilde trug. Als er sie vor ihm
ausrollte, konnte ich erkennen, dass es sich um Schlangenhaeute handelte.
Warum einer der Euren diese Haeute so dringend benoetigte, dass er sie
dem Abenteurer gar abkaufte, habe ich nicht mehr herausgefunden, da er von
dem heimlichen Treffpunkt, an dem die beiden ihren Handel geschlossen hatten,
sogleich die Drachenhorter Landstrasse entlang eilte, und ich mich dort
nicht gut verborgen halten konnte.

Vielleicht gelingt euch ja, mehr herauszufinden.

Gruss, Arathorn

-----------------------------------------------------------------------------



Hilfeseite zu Zaubererlaeden (Chagall, 17. Mai 2016, 18:02:43):
Huhu Zaubis,

Elendil war so freundlich und hat eine kleine Hilfeseite ueber die
verschiedenen Zaubererlaeden verfasst. Zu lesen gibt es das ganze mit einem
'stabhilfe zaubererlaeden'. 

MC

-----------------------------------------------------------------------------



Von Wandlerhandschuhen, ewigen Guerteln und komischen Ringen (Chagall, 19. Jun 2016, 22:33:11):
Huhu Zaubis,

durch eine kleine Unachtsamkeit meinerseits war es nicht mehr moeglich,
Llystrathe die Wandlerhandschuhe, den ewigen Guertel und Vesrays Ring zu
zeigen, um die dazugehoerigen Gildenquests zu bestehen. Das ist jetzt wieder
moeglich, danke an Starlight fuers melden.

MC

-----------------------------------------------------------------------------



Die aktuelle Mode (Arathorn, 11. Feb 2018, 00:51:11):
Hallo zusammen,

auch eine altehrwuerdige Institution wie die Akademie der geistigen Kraft 
zu Taramis kann sich dem Wandel der Zeit nicht voellig entziehen, und so
ist nun allen Mitgliedern der Akademie gestattet, was bis vor einer Weile
noch als eines Zauberers unziemlich angesehen wurde, naemlich den zur
Aufbewahrung der Zaubermaterialien verwendeten Guertel statt um die Huefte
ueber der Schulter zu tragen, das heisst, in der Art eines Koechers.

Dies gilt fuer alle Guertel, die die Akademie zur Verfuegung stellt, d.h.
wenn beispielsweise gewisse Vampire lieber Guertel verwenden, so ist 
ihnen das natuerlich weiterhin freigestellt.

Ich hoffe, dass die Akademiemitglieder dadurch weniger Schwierigkeiten
haben werden, bestimmte Gildenquests zu absolvieren, die mit der Verwendung
von anderen Guerteln einhergehen.

Gruss, Arathorn.

P.S.: Bereits im Spiel befindliche Guertel wurden umgestellt. Eventuell 
muesst ihr sie einmal aus- und wieder anziehen.
P.P.S.: Dank an Humni fuer die schnelle Zustimmung.

-----------------------------------------------------------------------------



Gildenquests ... (Humni, 14. Feb 2018, 21:31:15):
Liebes Jammervolk,

mir kam zu Ohren, dass ihr zufriden zu werden drohtet, zufrieden mit der Welt,
zufrieden mit Zaubern, und, viel schlimmer, zufrieden mit den Gildenquests.

Dies habe ich nun geaendert, weil ich gemein, fies und boese bin. So boese,
dass ich eine Schreckenstat begangen habe. Da ihr derzeit keinen Gildenmagier
habt, bin ich als Gilden-Erzmagier der Meister der Gildenquestlichen Willkuer.
Und diese ist darum grossgeschrieben, da ich sie hiermit zum Eigennnamen und
meinem Konzept erklaere.

Bisher war das Studium an der Akademie der geistigen Kraft freundlich, nett
und harmlos: Man wusste, was einen erwartete. Man musste auf jedem Level
Aufgaben erfuellen, und wenn man die nicht schaffte, verzweifelte man und
wechselte die Gilde.

Der Sammlerguertel von Demengar war eine dieser Aufgaben, an denen einige von
euch sich massen und, wenn sie sie schafften, fit waren fuer den naechsten
Level, der dann der Level 7 war.

Nun ist der Sammlerguertel nicht mehr fuer Level 6. Er ist fuer Level 7. Ihr
waehnt euch also in Sicherheit, und werdet nun auf Level 7 (also nicht mehr
als Adepten, sondern als Scholare!) damit konfrontiert. Und war dies eine
angemessene Aufgabe fuer die Adepten, ist sie nun eine fuer die Scholare, die
solcherlei Taetigkeit ja nicht mehr gewohnt sind!

HAHAHAHAHAHA!

Ich freue mich sehr darueber, wie effektiv ich euch gerade bestraft habe.

Der schreckliste aller Drachen
Humni

-----------------------------------------------------------------------------



Re: Gildenquests ... (Chagall, 15. Feb 2018, 13:48:47):
~#! rn=Humni rt=1518640275 rg=gilden.zauberer
~#! tid=1518640275
He, der Sammlerguertel war urspruenglich mal eine GL 4 Quest gewesen :)

MC

-----------------------------------------------------------------------------



spruchstaerke feuerball (Zesstra, 26. Jun 2019, 23:14:04):
Die Spruchstaerke des feuerballs kann man jetzt auch ab Gildenlevel 8 auf
"mittel" voreinstellen.

Zesstra

-----------------------------------------------------------------------------



Zaubi-Liste von Llystrathe (Zesstra, 22. Jan 2020, 20:20:54):
Llystrathe hat ueber Kopfweh und Schwierigkeiten, den Blick zu fokussieren
geklagt. Wir haben was grusliges gefunden, was ich entfernt hab. Ich musste
vergessen, was es genau war. Aber hatte wohl mit der Anzeige der Zaubererliste
zu tun. Vielleicht gibts da jetzt nen leicht anderes Verhalten.
Achja: wer hat eigentlich meinen Whisky leer getrunken?

Zesstra

-----------------------------------------------------------------------------



anstelle bugreport (Taker,  9. Aug 2020, 16:15:30):
kaufe 20 zitteraalherz
Da Du 20 Zitteraalherzen nicht mehr tragen kannst, legt Phlyaken sie auf den
Boden.
> kaufe 20 zitteraalherz
Da Du 40 Zitteraalherzen nicht mehr tragen kannst, legt Phlyaken sie auf den
Boden.
> Cakey kommt hereingebroeckelt.
Cakey verkruemelt sich nach Suedosten.
kaufe 20 zitteraalherz
Da Du 60 Zitteraalherzen nicht mehr tragen kannst, legt Phlyaken sie auf den
Boden.

Da lagen insgesamt natuerlich 60 statt 120.

-----------------------------------------------------------------------------



Re: anstelle bugreport (Zesstra, 10. Aug 2020, 09:23:34):
~#! rn=Taker rt=1596982530 rg=gilden.zauberer
~#! tid=1596982530
Das duerfte daran liegen, dass diese Art von Objekten sich mit anderen
vereinigen, die in der gleichen Umgebung schon sind und Phlyaken scheint sie
erst in den Raum zu bewegen und dann die Meldung auszugeben.

Zesstra

-----------------------------------------------------------------------------



Der Zauber "finde" (Arathorn, 26. Feb 2021, 21:25:34):
Hallo zusammen,

ich habe gerade ein paar Kleinigkeiten am Zauber "finde" repariert, die dazu
fuehren, dass ihr bei "finde jede(n) <npc>" eine unter Umstaenden deutlich
andere Liste ausgegeben bekommt. Das liegt daran, dass die Liste jetzt korrekt
gefiltert wird, je nachdem ob ihr Seher seid oder nicht.

Ausserdem gehen jetzt andere Dinge nicht mehr unerwartet kaputt. 
Danke an Quyi fuers Entdecken des Problems, und danke an Bugfix und Quyi fuers
Suchen und Finden des tatsaechlichen Fehlers. :-)

Gruss, Arathorn.

-----------------------------------------------------------------------------



Pruefungen und andere News (Arathorn, 21. Mar 2021, 13:26:51):
Hallo Zauberers,

ich habe gerade eine Aenderung bei den Lehrlings- und Magisterpruefungen
eingebaut, die dafuer sorgt, dass man seine Ausruestung nicht nur bei
bestandenen Pruefungen zurueckbekommt, sondern sie sich immer zurueckholen
kann.

Ausserdem habe ich bei der Gelegenheit das schwarze Brett aktualisiert und
die wesentlichen Aenderungen der letzten Jahre nachgetragen, soweit ich sie
rekonstruieren konnte.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Nachrichten aus dem Maschinenraum (Arathorn, 27. Mar 2021, 16:09:47):
Moin Zauberers,

ich habe gerade ein Pack Aenderungen an einigen Kernfunktionen der Gilde
eingespielt; es handelt sich dabei nur um eine Formsache, die vor allem dazu
dient, die spaetere Wartung der Funktionen zu erleichtern. Ihr solltet von den
Aenderungen nichts merken, aber ich wollte euch dennoch darauf aufmerksam
machen, damit ihr wisst, woher es kommt, falls sich wider Erwarten doch etwas
merkwuerdig verhaelt. Wie ueblich, in dem Fall bitte einfach Bescheid sagen,
ausser es sind Fehler im Raum-Zeit-Gefuege. Die werden uns automatisch
gemeldet.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Re: Nachrichten aus dem Maschinenraum (Arathorn,  8. Apr 2021, 01:18:26):
~#! rn=Arathorn rt=1616857787 rg=gilden.zauberer
~#! tid=1616857787
Hallo Zauberers,

mit dem Reboot am 8.4. wird (wurde) eine groessere Ueberarbeitung der
Gildenzauber aktiv. Ich habe den Code aller Zauber modernisiert und einige
Altlasten entsorgt. Ich habe die Aenderungen so gut es mir moeglich war
getestet, aber es kann durchaus sein, dass sich Fehler eingeschlichen haben.
Wenn sich also etwas ungewohnt oder anders als zuvor verhaelt, sagt bitte
Bescheid. Ausnahme: Fehler im Raum-Zeit-Gefuege, diese werden den Magiern
automatisch gemeldet.

Im Zuge der Ueberarbeitung ist allerdings auch ein Fehler aufgefallen, der den
Zauber "Schutz" betrifft. Dieser Fehler wurde vor diversen Jahren eingebaut
und fuehrte dazu, dass der Schutz weniger stark war als beabsichtigt (und
genehmigt). Die Aenderung ist in einer Groessenordnung, dass sie durchaus
wahrnehmbar sein koennte. Ihr muesst also nicht Bescheid sagen, wenn sich euer
Schutz etwas staerker anfuehlen sollte als bisher. ;-)

Gruss, Arathorn.

-----------------------------------------------------------------------------



Ein Update bei der Stabhilfe (Arathorn,  2. Okt 2021, 21:26:23):
Moinsen Zauberers und Zauberinen,

ich habe heute Nachmittag ein paar Kleinigkeiten an der Stabhilfe geaendert.
Holt euch einfach einen neuen Zauberstab (tm llystrathe zauberstab). Wie
ueblich steht auch was am schwarzen Brett.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Fehlschlaege bei Schutzhuelle (Arathorn, 26. Dez 2021, 22:39:04):
Hallo Zauberers,

bei der Schutzhuelle gab es seit einiger Zeit einen Fehler, der dazu fuehrte,
dass bei Fehlschlaegen gerne mal nur die Meldung beim Zaubern ausgegeben wurde
und sonst nichts. Man hat zwar trotzdem was gelernt, aber es gab eben keine
Info darueber. Dieser Fehler ist nun behoben. Probiert es bitte mal aus
(sofern ihr noch in der Phase seid, wo ihr aus Fehlschlaegen was lernt) und
sagt Bescheid, wenn noch irgendwas nicht wie erwartet funktioniert.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Lernen von Zaubern (Arathorn,  7. Jan 2022, 22:58:05):
Hallo Zauberers und Zauberinen,

preiset den Drachen! :-)

Ich habe im Laufe der vergangenen Woche ein paarmal gemeinsam mit Humni auf
das Lernen der Zauberer geschaut bzw. insbesondere auf diverse Effekte, die
dazu gedacht sind, das Lernen erschweren, und Humni war einverstanden, die
vorgeschlagenen Erleichterungen umzusetzen.

An vorderster Stelle ist dabei der sogenannte Lerncache zu nennen (siehe
Stabhilfe, auch wenn die eher kryptisch ist), der nun merklich spaeter und
weniger restriktiv eingreifen sollte. Zudem gibt es eine weitere Stelle, die
wir etwas entschaerft haben und die konzeptionell auch nicht so super war,
sich aber beim taeglichen Spielen eher selten auswirken duerfte.

Die ueblichen Empfehlungen zum Ueben von Zaubern bleiben meines Erachtens
erst einmal bestehen. Ich will aber zur Vermeidung von Missverstaendnissen
eins anmerken: es ist ja vermutlich allgemein bekannt, dass es eine manchmal
recht laestige Durststrecke gibt, die um Llystrathes Einschaetzung
"ausreichend" herum liegt. Die beiden erwaehnten Aenderungen zielen nicht
unmittelbar auf diese Durststrecke ab. Ich kann nicht einmal genau sagen, ob
sie einen Einfluss darauf haben oder nicht. Aber falls das dennoch so sein
sollte, freuen wir uns einfach, OK? :-)

Gruss, Arathorn.

-----------------------------------------------------------------------------



Ewige Kompos im ewigen Guertel (Arathorn, 12. Jan 2022, 23:20:19):
Moin Zauberers,

es sollten sich jetzt alle ewigen Kompos wie gewohnt unter "ewige Komponenten"
in der ginhalt-Liste des ewigen Guertels einreihen. Dies gilt fuer _alle_
ewigen Kompos, d.h. ab jetzt neu beschaffte ebenso wie bereits im Umlauf
befindliche, insbesondere die Lupen, an denen das konkret in letzter Zeit
auffiel. Sollte ich eine uebersehen haben oder das Problem dennoch weiter
bestehen, meldet euch bitte.

Arathorn.

P.S. Damit keine Missverstaendnisse aufkommen: die ewigen Kompos sind aber
weiterhin einzelne Gegenstaende, und dies wird auch so bleiben, d.h. sie
werden anders als gewoehnliche Komponenten ggf. mehrfach im Inventar
aufgelistet.

-----------------------------------------------------------------------------



Update von Verwaltungsobjekten (Arathorn,  2. Feb 2022, 20:29:46):
Hallo Zauberers und Zauberinen,

ich habe gerade ein groesseres Update an diversen Verwaltungsobjekten in der
Gilde eingespielt.

Diese sind technisch gleich geblieben, lediglich innerlich modernisiert, so
dass ihr von deren Aenderungen nichts merken solltet. Dieser Post soll nur
dazu dienen, euch darauf hinzuweisen, so dass ihr bei unerwarteten
Auffaelligkeiten Bescheid sagen koennt.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Zauber-Vorbereitungszeit (Arathorn,  2. Feb 2022, 20:30:36):
Hallo Zauberers und Zauberinen,

In grauer Vorzeit[*] wurde eine Mudlib-Aenderung vorgenommen, die dazu
gefuehrt hat, dass die Vorbereitungszeit fuer Zauber (insbesondere Feuerball
mittel und gross) nicht mehr korrekt berechnet wurde. Dies hatte zur Folge,
dass man jede Runde einen Feuerball mit entsprechendem Flaecheneffekt werfen
konnte, was aber so nicht beabsichtigt war. Ich habe heute eine weitere
Aenderung in der Gilde aktiviert, die die Auswirkungen der Mudlib-Aenderung
rueckgaengig macht, so dass ab sofort wieder die geplanten (und genehmigten)
Zauber-Vorbereitungszeiten wirken.

Wie immer gilt: sollte euch hierbei irgendwas komisch vorkommen oder sich
seltsam verhalten, meldet euch. (Vermutlich werden das nur "alte Hasen"
feststellen koennen, die sich noch erinnern, wie die Zauber vor der Mudlib-
Aenderung funktionierten.)

Gruss, Arathorn.


[*] lies: 2010.

-----------------------------------------------------------------------------



Upgrade fuer Giftpfeil und Blitz (Arathorn,  2. Feb 2022, 20:31:26):
Hallo Zauberers und Zauberinen,

zusaetzlich zu den gerade angekuendigten, technischen Aenderungen gibt es
auch Erweiterungen an zwei altbekannten Zaubern, die euch vermutlich mehr
interessieren: Blitz und Giftpfeil (preiset den Drachen!). 

Schon vor einer halben Ewigkeit wurden die Voraussetzungen dafuer geschaffen,
und in Ruecksprache mit Humni als dem fuer die Gilden zustaendigen EM habe
ich nun die bestehenden Vorarbeiten finalisiert: ihr koennt ab sofort, sofern
ihr die Stufenanforderungen erfuellt, die genannten Zauber aehnlich dem
Feuerball auch als Flaechenzauber einsetzen.

Die Spruchhilfe der Zauber wurde aktualisiert, ihr koennt also dort
nachlesen, wie das funktioniert und welche Voraussetzungen ggf. gelten.

Das Stabgimmick "spruchstaerke" habe ich erweitert, so dass ihr auch fuer
Giftpfeil und Blitz eine entsprechende Voreinstellung setzen koennt.
Weiterhin findet sich am schwarzen Brett der Gilde eine entsprechende Notiz
zu der Aenderung.
Die Kostensteigerung fuer die Flaechenversionen des Giftpfeils faellt dabei
geringer aus als bei Blitz und Feuerball. Auch hier Dank an den Drachen. :-)

Bei Blitz kommt noch eine kleine Neuerung hinzu: ein sehr gut gelungener
Zauber kann gelegentlich den Zusatzeffekt haben, dass dem Gegner noch etwas
"zustoesst". Ihr werdet sicher bald rausfinden, was das genau bewirkt. ;-)

Wichtiger Hinweis in eigener Sache
----------------------------------

Der Zusatzeffekt beim Blitz ist aktuell unter Vorbehalt eingebaut. Das
bedeutet, dass sich die Wirkungsweise, d.h. insbesondere die Haeufigkeit des
Effekts und dessen Dauer, in Zukunft nochmal aendern kann (der Effekt wird
aber aller Voraussicht nach nicht wieder vollstaendig verschwinden). Dies
liegt daran, dass wir zwar grundsaetzlich die Funktionsfaehigkeit testen
konnten, aber nicht die Kapazitaet fuer lange Testsitzungen einschliesslich
realer Metzeltests in groesserem Umfang haben.

Daher spiele ich diese Aenderung jetzt fuer alle ein und bitte euch auch im
Namen von Humni um Feedback dazu, was ihr von diesem Effekt haltet, wie er
sich auswirkt, ob die Haeufigkeit passt, oder was euch sonst dazu einfaellt.
Sagt bitte auch Bescheid, wenn die Doku irgendwo unklar oder fehlerhaft sein
sollte. :-)

Viel Spass damit!

Gruss, Arathorn.

-----------------------------------------------------------------------------



Verfuegbarkeit von Komponenten in Zaubererlaeden (Arathorn, 27. Feb 2022, 15:42:46):
Hallo zusammen,

ich habe gerade eine Aenderung eingespielt, die die Verfuegbarkeit von
Komponenten in den bekannten Kompo-Laeden fuer Spieler erhoeht, die nicht 24
Stunden am Tag online sind. Die bisherige Verfuegbarkeit hing von eurer
Onlinezeit ab, dies wurde in Abstimmung mit Humni als Gilden-EM auf RL-Zeit
geaendert. Zudem wurde den Laeden zu etwas mehr Nachschub verholfen.

Die Komponentenanzeige in den Laeden beruecksichtigt jetzt ausserdem auch
"grafik aus".

Gruss, Arathorn

-----------------------------------------------------------------------------



Hydraguertel (Arathorn, 27. Feb 2022, 15:44:58):
Hallo zusammen,

der Hydraguertel beruecksichtigt jetzt ebenfalls "grafik aus" bei der Ausgabe
des Befehls "ginhalt". Dies gilt fuer neue Guertel sowie nach Ende und Reboot.

Gruss, Arathorn.

P.S.: Das schwarze Brett in der Gilde wurde entsprechend aktualisiert.

-----------------------------------------------------------------------------



Ewige Komponenten (Arathorn, 26. Jun 2022, 17:04:39):
Hallo Zauberers,

aus gewissen Gruenden war eine rein technische Aenderung bei den ewigen
Komponenten erforderlich, die ich gerade eingespielt habe.
Die im Umlauf befindlichen ewigen Kompos habe ich bereits ausgetauscht.

Bei der Nutzung von ewigen Komponenten zum Zaubern werdet ihr keinen
Unterschied bemerken, und auch die Auflistung im ewigen Guertel sollte sich
nicht veraendert haben. Allerdings kann es sein, dass sich die Aenderung an
einigen Stellen ausserhalb der Gilde bemerkbar macht, z.B. dass irgendeine
Aktion nicht mehr funktioniert, die frueher mit ewigen Komponenten mal
geklappt hat. Sollte euch sowas auffallen, sagt einfach Bescheid, dann schaue
ich mir das gerne einmal an.

Gegenstaende, die eine ewige Komponente integriert haben, wie z.B. der ewige
Guertel, funktionieren ebenfalls unveraendert bei der Nutzung der zur
Komponente gehoerigen Zauber.

Gruss, Arathorn.

-----------------------------------------------------------------------------



abgeschalteter Stabreport (Arathorn,  8. Aug 2022, 22:28:41):
Hallo zusammen,

bisher war es so, dass ein Ausschalten des Stabreports nur die Reaktion auf
LP- und KP-Aenderungen ausgeschaltet hat. Bei Aenderungen an den
Stabmagiepunkten (SMP) wurde er trotzdem ausgegeben. Das habe ich gerade
gaendert, so dass ein ausgeschalteter Stabreport auch von SMP-Aenderungen
nicht mehr ausgeloest wird.

Arathorn.

-----------------------------------------------------------------------------



Re: abgeschalteter Stabreport (Arathorn,  8. Aug 2022, 22:31:07):
~#! rn=Arathorn rt=1659990521 rg=gilden.zauberer
~#! tid=1659990521
Ergaenzung dazu: mit "stabinfo" koennt ihr den Stabreport nach wie vor manuell
ausloesen.

Arathorn.

-----------------------------------------------------------------------------



Re: Re: abgeschalteter Stabreport (Arathorn, 11. Aug 2022, 00:33:25):
~#! rn=Arathorn rt=1659990667 rg=gilden.zauberer
~#! tid=1659990521
Und noch etwas. Genauer gesagt zwei Etwasse.

Zum einen habe ich beim Ersetzen der im Umlauf befindlichen Zauberstaebe einen
Fehler gemacht und sie stattdessen zerstoert. Holt euch bei Llystrathe einfach
einen neuen (tm llystrathe zauberstab), sie hat einen unerschoepflichen Vorrat
von den Dingern. :-)

Ausserdem hat die juengste Aenderung am Stabreport aufgrund eines aelteren
Fehlers dazu gefuehrt, dass die Stabmagiepunkte unter Umstaenden gar nicht
mehr regenerierten. Auch dieser Fehler ist jetzt behoben. Existierende
Zauberstaebe habe ich entsprechend ersetzt (diesmal wirklich), d.h. es muss
nur einen neuen holen, wer aktuell keinen hat.

Gruss, Arathorn.

-----------------------------------------------------------------------------



Das Lernen mal wieder (Arathorn, 17. Aug 2023, 00:45:45):
Hallo zusammen,

ich habe gerade eine Aenderung aktiviert, die das Lernen etwas beschleunigen
duerfte, eine kurze Notiz dazu findet sich auch am schwarzen Brett. Besten
Dank an Humni fuer die schnelle Genehmigung.

Gruss, Arathorn.

-----------------------------------------------------------------------------



