Bibliothek (Paracelsus, 18. Feb 1998, 21:09:58):
So, in der Bibliothek von Katzmandu gibt es jetzt auch einige Informationen
ueber die Gilde der Katzenkrieger (unter G wie Gilden).

Paracelsus.

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



Beruf oder Skill der Katzenkrieger (Felpur,  9. Mar 1998, 12:28:24):
Hi Leute1
 Ich haette eine Idee fuer die Gilde, was man als Skill oder vielleicht auch
als Beruf fuer spaeter auslegen koennte. Wir leben im Dschungel und muessen
uns mit im auseinandersetzen, warum  sollte es dann nicht moeglich sein, dass
sichjeder von uns ein Haustier oder Kampfbegleiter selber faengt und aufzieht
wenn es ein Junges waere.Wollte immer schonmal Felpur der Falkner oder Felpur
der Loewenbaendiger sein.
 Ciao FP.

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



Re: Beruf oder Skill der Katzenkrieger (Bendeigid,  9. Mar 1998, 12:38:25):
~#! rn=Felpur rt=889442904 rg=gilden.katzenkrieger
~#! tid=889442904
ist in Mache, Felpur....

Z4par Servu,
          Bendeigid, , zwar nicht fuer die Katzenkrieger zustaendig, aber da
eine gewisse Idee habend und dabei seiend, diese umzusetzen :)

P.S.: Die 4 da oben ist ein ' 

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



Re: Re: Beruf oder Skill der Katzenkrieger (Felpur,  9. Mar 1998, 15:18:11):
~#! rn=Bendeigid rt=889443505 rg=gilden.katzenkrieger
~#! tid=889442904
Hi Mitzen.-)
Habe ich das richtig  verstanden, dass mein Vorschlag schon in Arbeit ist? Ist
ja Spitze, ich muss mal ueber die Magier staunen. Grosses Lob an Euch.

iao.
FP.

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



Re: Re: Beruf oder Skill der Katzenkrieger (Grimmborn,  9. Mar 1998, 23:12:40):
~#! rn=Bendeigid rt=889443505 rg=gilden.katzenkrieger
~#! tid=889442904
Nein, Du irrst. Die 4 in Deinem Artikel ist tatsaechlich eine 4 und kein '.

Grimmborn der Atheist

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



Re: Re: Beruf oder Skill der Katzenkrieger (Therin, 10. Mar 1998, 01:00:50):
~#! rn=Bendeigid rt=889443505 rg=gilden.katzenkrieger
~#! tid=889442904

ist in Mache, Felpur....;Z4par Servu,
Bendeigid, , zwar nicht fuer die Katzenkrieger zustaendig, aber da
eine gewisse Idee habend und dabei seiend, diese umzusetzen :)

Mal sehen, wann die ersten mit einem zahmen Weghier rumlaufen ;)

T.

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



Re^3: Beruf oder Skill der Katzenkrieger (Bendeigid, 10. Mar 1998, 09:19:25):
~#! rn=Therin rt=889488050 rg=gilden.katzenkrieger
~#! tid=889442904
Genau so etwas in der Art, Therin. Aber ich denke, der Weghier ist ein wenig
zu gut drauf, um sich zaehmen zu lassen... Falls nicht... ROCHUUUUUUS!!!!

Z'par servu,
            Bendeigid

P.S. Grimmi, das ' ist diesmal ein echtes ' und keine 4, denn die 4 da oben
ist nur  ein ', wenn auch getarnt, und keine echte 4.... aeh... ja

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



Re^4: Beruf oder Skill der Katzenkrieger (Felpur, 10. Mar 1998, 12:04:46):
~#! rn=Bendeigid rt=889517965 rg=gilden.katzenkrieger
~#! tid=889442904
Nunja ich wuerde die Haustierrassen beschraenken. Genauer gesagt nur Tiere und
Monster im speziellen Sinne. Ausgenommen als Haustier sollten hUMANOIDE Rassen
wie Zwerge, Orks, Dunkelelfen und aehnliches sein. (Ein Zwerg als Haustier hat
allerdings was:-)). Aber Drachen, Bienen, Loewen, Baeren und andere Tiere und
Monster koennte man schon nehmen (wollte schon immer mal einen Drachen als
Haustier:-)). Ich denke mal man muesste das von Wesen zu Wesen differenzieren.

Ciao.
FP.

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



Re^5: Beruf oder Skill der Katzenkrieger (Key, 10. Mar 1998, 12:07:43):
~#! rn=Felpur rt=889527886 rg=gilden.katzenkrieger
~#! tid=889442904
Wieso erinnert mich das blos an die Zauberer?

Key

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



Re^6: Beruf oder Skill der Katzenkrieger (Felpur, 10. Mar 1998, 12:18:59):
~#! rn=Key rt=889528063 rg=gilden.katzenkrieger
~#! tid=889442904
Ja  wieso erinnert Dich das an die Zauberer? Kenne mich bei denen nicht aus.
Ciao.
FP.

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



Re^5: Beruf oder Skill der Katzenkrieger (Neb, 10. Mar 1998, 12:34:05):
~#! rn=Felpur rt=889527886 rg=gilden.katzenkrieger
~#! tid=889442904
Klar, ein Drache oder Baer als Haustier, was ganz normales halt, nicht wahr,
Felpur ? (/ironie off)

Neb, schuettelt den Kopf

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



Re^6: Beruf oder Skill der Katzenkrieger (Gloinson, 10. Mar 1998, 12:35:04):
~#! rn=Neb rt=889529645 rg=gilden.katzenkrieger
~#! tid=889442904
Katzen duerften sich nur Hunde als Haustiere halten.

Gloin ... sieht schon, wie Ranti im Akkord Gassi gefuehrt wird.

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



Re^6: Beruf oder Skill der Katzenkrieger (Zillus, 10. Mar 1998, 12:56:20):
~#! rn=Neb rt=889529645 rg=gilden.katzenkrieger
~#! tid=889442904
Haustiere sind schon gut. Die kann man toeten. Wie Wolpies :)
Zillus.

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



Re^7: Beruf oder Skill der Katzenkrieger (Felpur, 10. Mar 1998, 13:24:46):
~#! rn=Zillus rt=889530980 rg=gilden.katzenkrieger
~#! tid=889442904
Wieso toeten, die sollen Einen begleiten und eventuell mitkaempfen, allerdings
muss man erst mit einem Netz und doppelten Boden, aehSeil in den Wald und sich
eines fangen. Wenn man dann das Glueck hat irgendein Tier oder Monster
erwischt zu haben, muss man es erst noch unter einigen Zeitaufwand und
Gefahren zaehmen oder  wenn es ein Jungtierist grossziehen und erziehen. So
einfach sollte es schon nicht sein an einen Begleiter zu kommen und ihn zu
behalten (die wollen ja auch ihre Freiheit).

Ciao.
FP.

PS.: Das waeren meine Vorschlaege dazu und ich denke die sind nicht zu heftig.

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



Re^8: Beruf oder Skill der Katzenkrieger (Ark, 10. Mar 1998, 13:46:44):
~#! rn=Felpur rt=889532686 rg=gilden.katzenkrieger
~#! tid=889442904
Mitkaempfen? Hm, kann mich dunkel an den Satz von jemandem erinnern,
es wird hier keine mitkaempfenden Begleiter von Spielern geben (keine
Zweitis). Sll das jetzt auch wegfallen? Bitte nicht ...


              *** ARK * the * Magnificent ***


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



Re^9: Beruf oder Skill der Katzenkrieger (Orktoeter, 10. Mar 1998, 14:04:56):
~#! rn=Ark rt=889534004 rg=gilden.katzenkrieger
~#! tid=889442904
Wird es nicht geben ?
Was sind denn die Daemonen, die die Chaoten beschwoeren koennen, oder die
Viecher, die die Kleriker rufen koennen (und evtl weiteres) sonst ?

OrkT.

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



Re^10: Beruf oder Skill der Katzenkrieger (Ark, 10. Mar 1998, 14:11:16):
~#! rn=Orktoeter rt=889535096 rg=gilden.katzenkrieger
~#! tid=889442904
War auch schon etwas laenger her. Bei diesen Dingern sind das
ja Gildensprueche, wird das hier aehnlich sein? Hab ja nix dagegen,
bin aber mehr fuer sowas wie Durians Tiere, vielleicht weniger nervend
und mit anderen Eigenschaften vielleicht, aber net mitkaempfen.


              *** ARK * the * Magnificent ***


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



Re^11: Beruf oder Skill der Katzenkrieger (Gloinson, 10. Mar 1998, 14:22:26):
~#! rn=Ark rt=889535476 rg=gilden.katzenkrieger
~#! tid=889442904
An mitkaempfenden Begleitern gibt es m.E. genug. Werd Seher und hol Dir
'n Tamahorni, Felpur. Das ist oberknuddelig, sagt man.

Gloin

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



Re^11: Beruf oder Skill der Katzenkrieger (Key, 10. Mar 1998, 14:23:55):
~#! rn=Ark rt=889535476 rg=gilden.katzenkrieger
~#! tid=889442904
Yep bin Deiner Meinung Ark ...

Was willste denn sonst noch Felpur? Neben Npcs die einen im Kampf helfen ...
Wie waere es mit dem Schutz der Kleriker und der Zauberer? Ohne Waffe schaden
machen wie karateka? verschiedene schadensarten wie chaoten?

Sorry aber wieso zum Teufel soll die Katzenkriegergilde auch noch
Kampfgefaehrten bekommen??
Gegen ein paar Tiere die mit einem rumirren und von mir aus irgendwelche funcs
haben sacht keiner was. Aber Kampfgefaehrten geht meiner Meinung nach zu weit.

Key hat langsam die Nase voll davon das jede Gilde alles koennen will

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



Re^12: Beruf oder Skill der Katzenkrieger (Gloinson, 10. Mar 1998, 14:28:03):
~#! rn=Key rt=889536235 rg=gilden.katzenkrieger
~#! tid=889442904
Ich will ein Feature, dass die Katzenkrieger so oft sterben koennen wie Key.

Gloin

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



Re^10: Beruf oder Skill der Katzenkrieger (Teddy, 10. Mar 1998, 14:29:56):
~#! rn=Orktoeter rt=889535096 rg=gilden.katzenkrieger
~#! tid=889442904
Daemonen sind keine Begleiter sondern gute Frteunde und mit Freunden darf man
ja wohl metzeln gehen. ;)

Teddy -> schmarrn

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



Re^12: Beruf oder Skill der Katzenkrieger (Felpur, 10. Mar 1998, 16:21:46):
~#! rn=Key rt=889536235 rg=gilden.katzenkrieger
~#! tid=889442904
Ich muss Dich berichtigen Key, die Katzenkrieger haben schon Kampfbegleiter,
den Pflanzenkrieger. Ich  habe das ganze ja unter anderem auch als Beruf
vorgeschlagen, so das auch andere Gilden diese Moeglichkeit nutzen
koennen.(Wenn es je dazu kommt, dass Berufe im Morgengrauen erstellt werden.)
Ausserdem soll das kein Spell sein sondern eine Faehigkeit die man nutzen
kann. So ein Tierchen wuerde dann bis zum naechsten Reboot mit einem mitziehen
oder so.Das ganze soll ja auch Fun bringen wenn man sein Loewenbaby grosszieht
und mit ihm umherirrt. Es hat ja niemand gesagt, dass man mit einem Rudel
Bienen von etwa 1000 an der Zahl das Weghierueberfaellt und in Nullkommanichts
getoetet hat. Wie gesagt, das sind Vorschlaege von mir und ich sehe auch ein
wenn mir ein Magier sagt das geht nicht wegen Gleichgewicht oder wegen "wer
soll das proggen" oder wegen sonstwas, aber nachdenken darueber schadet ja
nichts und Spass bringt das bestimmt.

PS.:Ich bin offen fuer jede Kritik!

Ciao.
FP.

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



Re^13: Beruf oder Skill der Katzenkrieger (Lug, 10. Mar 1998, 19:02:27):
~#! rn=Gloinson rt=889536483 rg=gilden.katzenkrieger
~#! tid=889442904

Nee Gloin,


das sie so oft sterben muessen, wie Key!
Katzen sind Einzelgaenger warum sollten die von haustieren gemocht werden?

Grins fies
Lug

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



Re^9: Beruf oder Skill der Katzenkrieger (Jasper, 11. Mar 1998, 00:08:20):
~#! rn=Ark rt=889534004 rg=gilden.katzenkrieger
~#! tid=889442904
hmmm kaempfende begleiter gibts doch schon in 2 (3?) gilden.

Jasper bevorzugt da die haustiere der warlocks im zombiemud 

ps: hast du schon scrren installiert, felagund? :)

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



Re^14: Beruf oder Skill der Katzenkrieger (Felpur, 11. Mar 1998, 12:23:33):
~#! rn=Lug rt=889549347 rg=gilden.katzenkrieger
~#! tid=889442904
Hi Lug!
Wer hat Dir das denn erzaehlt, dass Katzen Einzelgaenger sind? Loewen zaehlen
ja auch zu dedn Katzen und die leben in der Gruppe. Ausserdem gibt es Studien
ueber die gemeine Hauskatze, welche sich in Grosstaedten zu Gruppen
zusammenschliessen um zu ueberleben, dort wird auch eine ArtAufgabenverteilung
gemacht, speziell Kindergarten, Jagd etc.(gemeint sind hier verwildertete
Hauskatzen, nicht die, welche immer in der Stube hocken undnicht rauskommen,
weil die Menschen sie ja sooooo moegen und ihrer Freiheit berauben. Dieses
Argument, sprich:"Katzen sind Einzelgaenger" trifft also nicht zu. 

Cioa.
FP.

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



Re^15: Beruf oder Skill der Katzenkrieger (Ark, 11. Mar 1998, 12:44:20):
~#! rn=Felpur rt=889611813 rg=gilden.katzenkrieger
~#! tid=889442904
Katzen um Dschungel SIND Einzelgaenger!


              *** ARK * the * Magnificent ***


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



Re^16: Beruf oder Skill der Katzenkrieger (Felpur, 11. Mar 1998, 16:06:28):
~#! rn=Ark rt=889613060 rg=gilden.katzenkrieger
~#! tid=889442904
Hi Ark!
Mitder Behauptung Katzen im Dschungel sind Einzelgaenger magst Du recht haben,
zumindest habe ich kein Gegenbeispiel. Ich sprach allerdings von Katzen
allgemein und da trifft diese Behauptung nicht unbedingt zu.  Ausserdem sind
Katzen anpassungsfaehig.Was solls, ein Magier hat sich ja schon mit dem Thema
auseinandergesetzt. Mal sehen was dabei herauskommt. Dann koennen wir ja immer
noch meckern;-).Bis dahin aber koennen wir im ja konstruktive Vorschlaege
machen und kreative.

Ciao.
FP.


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



Re^15: Beruf oder Skill der Katzenkrieger (Lug, 11. Mar 1998, 17:57:28):
~#! rn=Felpur rt=889611813 rg=gilden.katzenkrieger
~#! tid=889442904
Pfffft,

die Studien kennen unsere Katze nicht ;)

-> Grimmborn anschiel
Lug

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



nichtfelinen (Overlord, 11. Mar 1998, 22:45:28):
Hallo Leute!

Ich finde es schade, dass nur Felinen den 'Krallenschlag' lernen koennen
(ausserdem, dass Felinen keine Kleriker werden duerfen, aber das ist ein
anderes Thema).

Wie waere es deshalb mit einem Krallengimmick fuer Nichtfelinen? So etwa ein
Krallenhandschuh oder son Freddie-Krueger-Toolkit :).
Ich koennte mir sowas als Questbelohnung vorstellen. Natuerlich sind die
Felinen klar im Vorteil, deswegen ist bei allen anderen der Skill entsprechend
schwerer zu lernen oder die Trefferquote geringer.
Vielleicht geht der Krallenhandschuh oefters mal kaputt und man muss ihn
reparieren lassen...
Oder ein Zauberspruch, der einen Daemon beschwoert, der einen in ein
krallenbewehrtes Etwas verwandelt, fuer eine mehr oder weniger kurze Zeit.
Vielleicht hat der Daemon auch ein zickiges Eigenleben, solange er den Koerper
besetzt haelt?
Der Phantasie sind da keine Grenzen gesetzt.

Ich faende es bei der allgemeinen Diskussion nach dem Motto: 'Meine Gilde ist
schwaecher als Deine...RABAEEEEEH' wenigstens gut, wenn dann die Rassen
bezueglich einer Gilde etwas austariert waeren.

Ovi, heute mal kreativ

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



Re: nichtfelinen (Wurzel, 11. Mar 1998, 22:53:54):
~#! rn=Overlord rt=889652728 rg=gilden.katzenkrieger
~#! tid=889652728
hm, "austariert" ist eigentlich genau das, was vermieden werden sollte. vor
der reform (und dem anschluss der felinen) gab es genau betrachtet keine
echten rassenunterschiede ausser in der kaempfergilde. ein ziel war, etwas
mehr differenzierung zu schaffen.
warum sollen manche rassen, in deinem beispiel die felinen, nicht etwas
anderes koennen als andere rassen? die entwicklung wird nicht stehenbleiben,
andere koennen anderes (vielleicht auch erst spaeter). nur kein neid :)

wenn du so sehr gesteigerten wert auf den krallenschlag legst, geh doch zu
dr. frankenstein :)

wurzel

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



Re: Re: nichtfelinen (Grimmborn, 12. Mar 1998, 11:41:22):
~#! rn=Wurzel rt=889653234 rg=gilden.katzenkrieger
~#! tid=889652728
Versuchs doch gar nicht erst. Die Erfahrung hat gezeigt, dass es immer eine
nicht unerhebliche Anzahl von Leuten gibt, die der Meinung sind, damit das
"gerecht" ist muessten alle alles gleich gut koennen. Da kannst Du noch so
sehr mit Engelszungen reden, das bringt nichts.
Wo sind eigentlich die Leute, die die gilden/rassenspezifischen Nachteile auch
haben wollen?

Grimmborn der Atheist

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



Re^3: nichtfelinen (Wurzel, 12. Mar 1998, 20:38:05):
~#! rn=Grimmborn rt=889699282 rg=gilden.katzenkrieger
~#! tid=889652728
vielleicht gehoeren sie zur mpa-schweigenden mehrheit hier, grimmi. auf den
verschiedensten feten/stammtischen hab ich jedenfalls immer wieder gehoert,
dass eine staerkere unterscheidung zwischen den rassen nicht schlecht waere.
so wie es bisher war, haette eine einzige rasse ausgereicht. drueck jedem
spieler ein tool in die hand, mit dem er sich seine stat-offsets und seinen
prayroom einstellen kann, mehr haette es eigentlich nicht gebraucht. im
uebrigen sollte dir vielleicht aufgefallen sein, dass es sich nicht auf
rassenspezifische nachteile beschraenkt, sondern auch vorteile mit sich
bringt... aber noergeln ist ja immer einfach *seufz*

wurzel

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



Re^3: nichtfelinen (Maso, 12. Mar 1998, 23:28:52):
~#! rn=Grimmborn rt=889699282 rg=gilden.katzenkrieger
~#! tid=889652728
Hier.

              Maso.


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



Re^4: nichtfelinen (Rantanplan, 13. Mar 1998, 11:33:53):
~#! rn=Maso rt=889741732 rg=gilden.katzenkrieger
~#! tid=889652728
Jajajaja  !!!!!

Los kommt ihr Miezekaetzchen und versucht mich an die Leine zu legen...

*klaeff*

Ran*

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



Re^5: nichtfelinen (Mieze, 13. Mar 1998, 14:14:25):
~#! rn=Rantanplan rt=889785233 rg=gilden.katzenkrieger
~#! tid=889652728

Du hast gerufen, Rantanplan????

Ich eile :)))

Die Mieze - das Original.

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



Re^4: nichtfelinen (Smurf, 13. Mar 1998, 17:36:32):
~#! rn=Wurzel rt=889731485 rg=gilden.katzenkrieger
~#! tid=889652728
Also ich bin fuer Unterschiede zwischen den Rassen.

Smurf, der Unterschiede mag

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



Re: nichtfelinen (Key, 15. Mar 1998, 01:21:29):
~#! rn=Overlord rt=889652728 rg=gilden.katzenkrieger
~#! tid=889652728
Also das was mir an den Katzenkaempfern gerade mal gefaellt ist das eben nicht
jede Rasse das gleiche kann.
Und das die Felinen in der Gilde bevorzugt sind finde ich positiv und logisch.

Key

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



Re: Nichtfelinen (Overlord, 16. Mar 1998, 20:43:55):
Bezug:Artikel 31 von Grimmborn und Art. 32 von Wurzel

Hmmmm seit wann hat das Vorschlagen von Ideen (najaaa und eine vielleicht
nicht ganz konforme Meinung) was mit Noergelei zu tun???

Ovi, sich fragend, ob er zum ersten und letzten Mal versucht hat, kreativ zu
sein

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



PS (Overlord, 16. Mar 1998, 20:46:30):
Wenn ich noergele sieht das in der MPA ganz anders aus, jede Wette.

Ovi

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



vorschlag... (Siouxie, 28. Mar 1998, 06:49:05):
saluet ich hoffe mal das ich hier niX bringe das schon 1000 malgesagt wurde...
habe alle artikel kurz ueberflogen (nicht gelesen)...
als verbesserung wuerde ich blutwandlung aendern
warum soll man in einer gilde (es sei den man ist kleriker) einen spruch
lernen den man als questgimmick vermutlich sowieso schon frueher bekommt...
oki ich kenne die ganzen faehigkeiten von blutwandlung noch nicht... aber mehr
als entgiften scheint es nicht zu sein eie ich hoere ...
deshalb wuerde ich vorschlagen den spruch zu aendern das man eine bestimmte
menge points einer art in eine andere umwandeln kann (zu entsprechenden
kosten) das ist immer noch passend zur blutwandlung und es gibt nicht noch
eine gilde die einen vollkommend sinnlosen spruch besitzt...
denkt siouXie halt mal so...

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



Re: vorschlag... (Key, 30. Mar 1998, 08:05:28):
~#! rn=Siouxie rt=891064145 rg=gilden.katzenkrieger
~#! tid=891064145
Einen Spruch lernen den mal als Questgimmick sowieso schon frueher lernt ....

Aeh ... wenn ich mich recht erinnere meinst Du Duesterwald ...
Und wenn Du die frueher spielst als das Du Blutwandlung lernst machste meiner
Meinung nach was falsch :)

Key

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



Und Silvana sprach ... (Paracelsus, 28. Jul 1998, 21:20:34):
Und Silvana sprach:
  Ich habe nun alle Gilden in Augenschein genommen. So auch die Deinige,
  'Katzenkrieger' genannt. Beruhigt stellte ich fest, dass es dort nur
  weniges zu aendern gilt. Doch dies aender bitte bald...

Nun, da ich ja ein braver Sohn bin *HUESTEL* hab ich getan, was Mami gesagt
hat. Ihr werdet wahrscheinlich nicht einmal allzuviel von den Aenderungen
bemerken.
Nur ein kleiner Hinweis am Rande: wer sich mit 10 Raeumen/Sekunde fortbewegt
sollte nicht erwarten, dass er dabei in irgendeiner Form schleicht...

Paracelsus.

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



Re: Und Silvana sprach ... (Key, 29. Jul 1998, 12:55:39):
~#! rn=Paracelsus rt=901653634 rg=gilden.katzenkrieger
~#! tid=901653634
*hust*
Du bist Silvanas Sohn???
Oh mein Gott!!
Silvana ist meine Fake-Mammi ... heisst das Du bist mein Fakebruder? :)

Key ordnet Familienverhaeltnisse und schmarrnt ;)

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



Re: Re: Und Silvana sprach ... (Zarniya, 30. Jul 1998, 10:12:13):
~#! rn=Key rt=901709739 rg=gilden.katzenkrieger
~#! tid=901653634
Ja, Key.. und Yantro Dein Fakestiefpapa :)

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



Re^3: Und Silvana sprach ... (Taz, 30. Jul 1998, 10:16:34):
~#! rn=Zarniya rt=901786333 rg=gilden.katzenkrieger
~#! tid=901653634

Wer ist Yantro?

Anakin.

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



Re^3: Und Silvana sprach ... (Key, 31. Jul 1998, 09:56:59):
~#! rn=Zarniya rt=901786333 rg=gilden.katzenkrieger
~#! tid=901653634
AHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH!!!!

Key

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



Treffermeldungen (Paracelsus,  2. Sep 1998, 21:20:56):
Hi.

Die Treffermeldungen fuer 'blitz' und 'wasserstrahl' haben sich etwas
geaendert.

Para*.

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



Neues (Paracelsus,  7. Sep 1998, 22:51:51):
Fuer Spieler mit Level>24 hat sich ein wenig geaendert, es lohnt sich also,
sich nochmal in die Bibliothek von Katzmandu zu begeben und sich so einiges
durchzulesen.

Para.

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



Pflanzenkrieger (Paracelsus, 11. Sep 1998, 21:22:53):
Kleine Aenderung am Pflanzenkrieger:
Wenn man ihn mit 'pflanzenkrieger leise' herbeiruft, folgt er einem, ohne
dass dabei Meldungen ausgegeben werden.
Weitere Informationen wie immer in der Bibliothek.

Para.

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



felinenclans (Rardian,  3. Feb 1999, 17:38:57):
Hallo Katzenkrieger,
Ich denke, es ist zeit, dass wir mal was fuer uns felinen tun.
Letztens wurde ein eventuelles Clansystem diskutiert. Was meint ihr dazu?
Ich habe mir bereits einige gedanken gemacht und wer interesse hat, mit-
zuhelfen, der soll sich bei mir per post oder persoenlich melden.

auf rege antwort gespannt,
Rardian Smaragdpardel,
angehender Katzenkrieger-Seher.

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



Re: felinenclans (Key,  3. Feb 1999, 17:39:44):
~#! rn=Rardian rt=918063537 rg=gilden.katzenkrieger
~#! tid=918063537
Wie waere es mit Vorschlaege in die MPA setzen?

Key

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



Re: Re: felinenclans (Rardian,  3. Feb 1999, 17:41:58):
~#! rn=Key rt=918063584 rg=gilden.katzenkrieger
~#! tid=918063537
ja key,
das ist natuerlich auch sinnvoll, mir ging es aber auch darum, dass meine
recht umfangreichen ausfuehrungen zu dem thema von interessenten geordert
werden koennten... das wuerde den rahmen hier naemlich sprengen...

Rardian.

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



Re^3: felinenclans (Anatol,  3. Feb 1999, 17:44:34):
~#! rn=Rardian rt=918063718 rg=gilden.katzenkrieger
~#! tid=918063537
Ausserdem neigt die MPA dazu, alles niederzumaehen. Gelegentlich 
auftauchende SINNVOLLE Vorschlaege inclusive. Mach es via Mail, 
wie Du vorgeschlagen hast.

Anatol


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



Re^3: felinenclans (Zwocklhuber,  3. Feb 1999, 17:53:55):
~#! rn=Rardian rt=918063718 rg=gilden.katzenkrieger
~#! tid=918063537
Hilfe, es koennten sich Felinen dafuer interessieren, deswegen kommts nicht in
die MPA...

Oder hab ich da jetzt was falsch verstanden? 

Zwocki -> Schmarrn ... :)

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



Re: felinenclans (Jesko,  3. Feb 1999, 20:11:17):
~#! rn=Rardian rt=918063537 rg=gilden.katzenkrieger
~#! tid=918063537
Peace!

Koenntest Du eventuell etwas ausfuehren, was du dir unter einem Clan-
system vorstellst? So eine Gilde in der Gilde?

Jesko, hat noch keine Feline

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



Re^4: felinenclans (Shannara,  3. Feb 1999, 20:14:35):
~#! rn=Zwocklhuber rt=918064435 rg=gilden.katzenkrieger
~#! tid=918063537
Tja, da kommt ein nett gemeinter Vorschlag in die MPA rein, und nur weil es
ein eher nicht gerade eine 'Persoenlichkeit' ist wird schon mal fleissig
bekrittelt und geflamet.

Rardians Vorschlag ist ganz nett, nur hat er leider vergessen, einen Hinweis
zu geben, wo man seinen gesamten Vorschlag lesen kann, zb WWW (hat er auch,
die URL hab ich grad nicht auswendig hier).

Sandkatze Shannara.

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



Re^5: felinenclans (Rardian,  3. Feb 1999, 20:25:27):
~#! rn=Shannara rt=918072875 rg=gilden.katzenkrieger
~#! tid=918063537
Um missverstaendnisse aufzuklaeren:
auf www.tfh-berlin.de/~s681603/ kann man mehr ueber die felinen lesen.
aber ich schicke auch eine vollstaendige version an interessierte...

rardian.

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



Re^5: felinenclans (Zwocklhuber,  3. Feb 1999, 21:52:27):
~#! rn=Shannara rt=918072875 rg=gilden.katzenkrieger
~#! tid=918063537
wo hab ich denn gekrittelt? Ich fand nur die Formulierung etwas lustig

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



felinenclans, 2. versuch... (Rardian,  4. Feb 1999, 15:25:05):
also, alle, die sich sinnvoll am aufbau eines clansystems beteiligen
wollen: schaut auf meiner homepage unter: http://www.tfh-berlin.de
/~s681603/RSP/mg.html ...

rardian.

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



Re: felinenclans, 2. versuch... (Key,  4. Feb 1999, 15:30:05):
~#! rn=Rardian rt=918141905 rg=gilden.katzenkrieger
~#! tid=918141905
Permisson denieded .... nett ;)

Key

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



Re: Re: felinenclans, 2. versuch... (Teddy,  4. Feb 1999, 16:33:21):
~#! rn=Key rt=918142205 rg=gilden.katzenkrieger
~#! tid=918141905
Du wolltest bestimmt nicht sinnvoll mitmachen ;)

Teddy
->schmarrn

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



felinenclans (Lena,  9. Feb 1999, 16:14:05):
Hm.
Ich hab mir mal Rardians Homepage angesehen und das mit den Clans gelesen.
Es ist zwar nett (und rollenspieltechnisch nicht unwichtig), wenn eine
"Geschichte"
besteht, jedoch hab ich (leider) nicht rausfinden koennen, was das
spieltechnisch
bringen soll/kann.
Werden vielleicht die Stats geaendert oder so?
Lena, ExFelinin.

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



Re: felinenclans (Rardian,  9. Feb 1999, 21:43:52):
~#! rn=Lena rt=918576845 rg=gilden.katzenkrieger
~#! tid=918576845
Muessen denn immer die stats veraendert werden?

ansonsten ist ja massig los hier in der mpa in bezug auf die clans.
schade, scheint wohl doch kaum jemanden zu interessieren.

rardian.

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



Gildenseiten (Shannara, 24. Jun 1999, 18:04:29):
Fuer die Katzenkrieger gibts auch (noch immer) die Gildenseiten der
Katzenkrieger auf http://members.magnet.at/pulaski/mg/kkrieger/

Mh nur als Hinweis fuer die kleinen Kaetzchen, von denen in der letzten Zeit
wieder es eine Schwemme gab (da waren wohl einige Leute fleissig :)

Shannara

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



Re: Gildenseiten (Mindblade, 27. Jun 1999, 12:02:51):
~#! rn=Shannara rt=930240269 rg=gilden.katzenkrieger
~#! tid=930240269
Also, um mal ein wenig konstruktive Kritik zu ueben...
Eigentlich schade, dass alle 2 Saetze einmal gesagt wird, wie schwach die
Gilde doch ist. Saetze wie "Die Katzenkrieger stellen leider nicht die Elite
der Knigin Koana dar, eher ihr schwchliches Fussvolk..." finde ich auf einer
Gildenseite nicht gerade gelungen. Ich habe recht wenig gefunden, was Du als
positiv empfunden hast. Auch aus Katzenkriegern laesst sich ne Menge
rausholen, also verpass Deiner Seite mal ein wenig mehr Optimismus!

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



Re: Re: Gildenseiten (Trug, 27. Jun 1999, 12:06:53):
~#! rn=Mindblade rt=930477771 rg=gilden.katzenkrieger
~#! tid=930240269
Ich bin gerade dabei, sie zu ueberarbeiten.

Es ist mir bewusst, dass man aus der Gilde etwas rausholen kann, aber
irgendwann ist halt der Plafond erreicht. In gut geschriebenen Gebieten wie
(Para)Drakonien kann man - wenn man die Moeglichkeiten ausnutzt - sehr gut
spielen. Leider gibts auch mehr als genug Gegenden, wo die Katzenkrieger durch
den Fleischwolf getrieben werden, weil die dort einfach keine Chance haben
(VLand Katas zb).

Wie das mit der Eismine aussieht weiss ich net.

Trug

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



Re^3: Gildenseiten (Sting, 27. Jun 1999, 12:09:01):
~#! rn=Trug rt=930478013 rg=gilden.katzenkrieger
~#! tid=930240269
Bloedsinn. In JEDER Gilde kann man gut metzeln. Die Katzenkrieger sind eine
etwas schwaechere Gilde, aber so waren sie auch geplant. Dafuer haben sie eine
sehr schoene Atmosphaere! Ich gehe jede Wette ein, das jemand der sich
_richtig_ mit der Gilde beschaeftigt auch als Katzenkrieger _fast_ alle
Monster im MG alleine umhauen kann, wenn auch sicherlich mit mehr Aufwand.
Aber mir hat es immer Spass gemacht, fuer die richtig harten Monster Taktiken
zu ueberlegen oder mit spezial-items zu arbeiten die kaum einer kennt. Darin
liegt fuer mich ein grosser Reiz des Metzelns, das auskennen im MG und das
nutzen dessen.

Sting

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



Re^3: Gildenseiten (Lena, 28. Jun 1999, 11:00:21):
~#! rn=Trug rt=930478013 rg=gilden.katzenkrieger
~#! tid=930240269
VLand? Katas?
Wer wird da nicht mal platt gemacht, so ganz alleine unterwegs?
jaja, es gibt bestimmt so leute. Es gibt ja auch leute, die die hydra alleine
stehen koennen wollen ;),
aber das ist ja nicht der Duchschnitts-charakter. Ausserdem, wenn Dir die
Felinen zu schwach sind,
dann werd doch Gildenmagier und verbesser sie.

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



Re^4: Gildenseiten (Dieder, 28. Jun 1999, 11:02:01):
~#! rn=Lena rt=930560421 rg=gilden.katzenkrieger
~#! tid=930240269
>... dann werd doch Gildenmagier und verbesser sie.

Das geht zum Glueck nicht so einfach, sonst wuerde sich hier die
Ruestungsspirale noch schneller drehn...

Dieder

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



Re^4: Gildenseiten (Trug, 28. Jun 1999, 11:36:27):
~#! rn=Lena rt=930560421 rg=gilden.katzenkrieger
~#! tid=930240269
Lena,

spiel mal eine erfahrene Katzenkriegerin und geh mal da unten mit ihr rein und
guck mal
wie weit du kommst und wie dir das dann langsam am Selbstwertgefuehl kratzt,
wie du
zusehen musst dass du auseinandergenommen wirst (alleine) oder kaum Schaden
anrichtest
(team).

Du kannst es ja mal probieren, als Klerikern OHNE Schutzsprueche und
absichtlich mit
einen Schwert zu metzeln (nein das ist kein Heul-Doch-Aufruf). Ah ja,
verzichte auch 
auf alles, was heiligen Schaden macht. Viel Spass. 

Trug


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



Re^5: Gildenseiten (Lena, 28. Jun 1999, 12:10:58):
~#! rn=Trug rt=930562587 rg=gilden.katzenkrieger
~#! tid=930240269
ich wollt hier weder flamen noch dich angreifen oder sonstwas.
(wenn jemand als "erfahrener" Spieler ohne hl. Sachen in die Katas geht... was
soll ich davon halten?)
Jede Gilde hat nun mal Vor- und Nachteile. Wenn ich seh, was Kaempfer in einer
Runde an einem Gegner Schaden machen...
Dafuer mach ich halt auf viele Gegner mehr Schaden etc. etc.
Soweit ich das richtig verstanden habe, sollen die Katzenkrieger ne
Anfaengergilde sein.
Und ueberhaupt. Wenn ich seh, dass meine Level-24-Abenteurerin Brei macht, wo
ich mit Lev. 48 mit viel Glueck mal zerschmetter, ...
ausserdem zwingt niemanden jemanden, bei den Katzenkriegern zu bleiben. Man
sollte zwischen der Rasse und der Gilde unterscheiden, etc. etc.
Ausserdem hab ich (und war mal selbst) Feline und Spass hats trotzdem gemacht.
(Da war ich noch stolz, den Panther im Uebdschungel geschafft zu haben.
Ich hab daran zwei oder drei Tage rumgemacht, ehe der tot war. :) )
(Ich koennt ewig weiterschwallen...)

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



Re^5: Gildenseiten (Mieze, 28. Jun 1999, 12:13:26):
~#! rn=Trug rt=930562587 rg=gilden.katzenkrieger
~#! tid=930240269

Jetzt reichts!

Wenn Ihr die Philosophie der KKrieger nicht kapiert, wechselt doch einfach
Gilde und/oder Rasse. Keiner zwingt Euch hier zu sein.

Mieze - KKriegerin aus Ueberzeugung!

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



Re^5: Gildenseiten (Jamalski, 28. Jun 1999, 15:00:18):
~#! rn=Trug rt=930562587 rg=gilden.katzenkrieger
~#! tid=930240269
Also, das hat aber alle Charakterzuege eines Heul-Doch!-Aufrufs!  Gut
gelungene Tarnung! };>
Jamal

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



Re^6: Gildenseiten (Rardian, 28. Jun 1999, 16:38:58):
~#! rn=Mieze rt=930564806 rg=gilden.katzenkrieger
~#! tid=930240269
Ich geb jetzt auch mal meinen Senf dazu... Achtung!!

Ich persoenlich halte die Felinen fuer eine Rasse, die fuer Atmosphaerisches
praedestiniert ist. Vielleicht auch oder gerade weil man in anderen
Rollenspielsystemen selten katzenartige Wesen findet.  
Die Katzenkrieger als Gilde sind in der Tat recht wenig ausgearbeitet, wenn
man sich zum Beispiel mal die Kaempfer anschaut. Es steckt noch eine Menge
Potential in den Katzenkriegern und ich bin mir sicher, dass Paracelsus, wenn
er wieder mehr Zeit hat, neue Optionen und Moeglichkeiten einfuehrt, bzw.
jemanden beauftragt, dies in seinem Sinne zu tun.
Es hilft aber nicht, einfach nur zu sagen, dass alles so wie es ist, sch&%$%
ist, weil das erstens nicht stimmt und zweitens die Arbeit, die der Schoepfer
der Gilde investiert hat, nicht wuerdigt.
Es hilft aber nicht, einfach nur zu sagen, dass alles so wie es ist, sch&%$%
ist, weil das erstens nicht stimmt und zweitens die Arbeit, die der Schoepfer
der Gilde investiert hat, nicht wuerdigt. Macht doch lieber mal konstruktive
Vorschlaege, was man veraendern/-bessern koennte. Ich bin mir sicher, der
zustaendige wird sich vor solchen nicht verschliessen.
Ich erinner nur an die Neuerung, dass Stufenanstiege seit einiger Zeit auf
-katz ausgegeben werden.

Ein konstruktiver Rardian.

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



Re^5: Gildenseiten (Darkwing, 28. Jun 1999, 16:57:01):
~#! rn=Trug rt=930562587 rg=gilden.katzenkrieger
~#! tid=930240269
ach Trug, mache Leute sterben ueberall, da kommts auf die Gilde nicht weiter
an.

Nix fuer ungut, Darkwing

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



Re^6: Gildenseiten (Trug, 28. Jun 1999, 16:58:15):
~#! rn=Darkwing rt=930581821 rg=gilden.katzenkrieger
~#! tid=930240269
Mh sicher, vielleicht hab ichs wohl etwas falsch formuliert. 

Der Tod lauert halt in vielen Gegenden :)

Trug.

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



Re^7: Gildenseiten (Mahatmu, 28. Jun 1999, 22:07:03):
~#! rn=Trug rt=930581895 rg=gilden.katzenkrieger
~#! tid=930240269
Poeh. Metzeln. Metzeln ist immer nur eine Frage der Ausruestung. Und die
eine des Suchens und Findens (und der Freunde). Und natuerlich, nicht zu
vergessen eine der Phantasie bezueglich der Anwendung seiner eigenen
Faehigkeiten. Insbesondere der Gildenfaehigkeiten.
Schwierig wird es doch erst in einer Quest, wenn es ans Eingemachte geht
und nur noch Grips/Cheats/KLs/Magier/Rumheulerei :) helfen.

Gloin

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



Fein, fein... (Lug, 29. Jun 1999, 03:24:11):

Ich hab die ganze rubrik soeben mit grossem Vergnuegen gelesen. Das sollte
Euch zu denken geben...

Haemisch grinsend
Lug

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



Re^7: Gildenseiten (Boing, 29. Jun 1999, 09:29:54):
~#! rn=Rardian rt=930580738 rg=gilden.katzenkrieger
~#! tid=930240269
Wenn Du mit Potential Kampfkraftpotential meinst, muss ich Dir leider
widersprechen. Die Katzenkrieger sollen von der Kampfstaerke vergleichbar
mit den Abenteurern sein, das ist Teil des Konzepts und Absicht.
  Boing, heute mal informierend

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



Re^8: Gildenseiten (Rardian, 30. Jun 1999, 11:55:15):
~#! rn=Boing rt=930641394 rg=gilden.katzenkrieger
~#! tid=930240269

Nein, ich meinte nicht das Kampfkraftpotential der Katzenkrieger.
Ich meinte eher das felinenbezogene Potential. Da kann man viel
machen. Hm... also vielleicht sollte man sich bei Aenderungen
eher auf die Rasse konzentrieren, als auf die Gilde. Vielleicht
koennte man ja auch eine Gilde einfuehren (irgendwann einmal),
die die Katzenkriegergilde erweitert und die dann keine Anfaenger-
gilde mehr ist?

Rardian, jetzt eher gruebelnd.

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



Aenderung (Paracelsus,  9. Aug 1999, 09:12:31):
Hi.

Fuer die, die den Spruch "pflanzenkrieger" beherrschen, koennte es evtl.
interessant sein, sich die Hilfeseite in der Bibliothek nochmal durchzulesen.

Para*.

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



Topliste (Paracelsus,  2. Mar 2000, 17:24:16):
Hi.

Die Topliste im Gildenraum zeigt jetzt auf mehrfachen Wunsch nur noch
die Top 100 an.

Paracelsus.

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



Mitgliedsliste (Paracelsus, 27. Mar 2000, 18:18:58):
Nachdem ich aus der Liste der Gildenmitglieder mal die Karteileichen
(=geloeschte Spieler) entfernt habe, kann man die Mitgliederliste
auch wieder lesen.

Paracelsus

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



Der grosse Flug (Paracelsus,  7. Feb 2001, 17:09:17):
Tach.

Emsigen Portalbenutzern sei verkuendet, dass der Sprung zu unserm
ehrenwerten Xelo* nun nicht mehr mit einem Freiflug belohnt wird.
Stattdessen erhaelt man nur noch die Moeglichkeit, sich fuer ein
Minuetchen der Musse hinzugeben.

Paracelsus.

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



Neuer Gildenmagier (Humni,  5. Jan 2003, 19:22:39):
Liebe Katzen und solche die immer gerne welche werden wollten,

ein gewisses Reh hat sich bereiterklaert, ein paar Aenderungen und Ideen in
Eure Gilde einzubauen. Wenn Ihr also Ideen habt dann duerft Ihr Euch ab sofort
an Bambi wenden, der wie ich hoffe, jetzt ueberall die Macht hat, Eure Gilde
Euren Wuenschen entsprechend anzupassen - wenn er sie denn fuer geeignet
haelt.

In wie weit er das ganze nur fuer ein paar Aenderungen machen will und diese
Aufgabe sonst eher komissarisch sieht oder ob er das auf Dauer machen will mag
er selbst aeussern.

Ich selbst wuensche ihm viel Spass und Geduld mit mir, sollte er irgendwann
wirklich was einbauen wollen, und auch sonst bei der Kommunikation mit Euch.

Genug des Pathos, Miau,

Humni

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



Re: Neuer Gildenmagier (Sou,  5. Jan 2003, 19:23:43):
~#! rn=Humni rt=1041790959 rg=gilden.katzenkrieger
~#! tid=1041790959
Katzen lassen sich von Rehen veraendern?

Sou will nicht sehen, wie das aussieht.

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



Re: Re: Neuer Gildenmagier (Mupfel,  5. Jan 2003, 21:09:11):
~#! rn=Sou rt=1041791023 rg=gilden.katzenkrieger
~#! tid=1041790959
Rehkaetzchen? ;)

-mupfel-

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



Re^3: Neuer Gildenmagier (Sou,  5. Jan 2003, 21:11:43):
~#! rn=Mupfel rt=1041797351 rg=gilden.katzenkrieger
~#! tid=1041790959
Ich meinte damit nicht, was das Ergebnis (auch wiederlich, aber ertraeglich)
aussieht. Mich interresiert eher der Vorgang des Veraenderns (aus rein
biologischen und _nicht_ sadistischen oder sonst. Gruenden).

Sou grinst sich ein Rehkaetzchen zusammen.

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



Neue Version. (Bambi,  6. Jan 2003, 13:02:03):
Hi alle.
Ich habe einige technische Veraenderungen am spellbook vorgenommen. Die
Aenderungen beziehen sich konkret auf die Spells "giftdolch" (patch) und auf
"pflanzenkrieger" (erweiterung). Die spells sollten bis auf die
Syntax-Erweiterung bei "pflanzenkrieger" genauso tun, wie bisher auch. Sollten
Bugs auftreten oder sich die Spells anders verhalten als bisher, moechte man
mir dies bitte melden.


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



Re: Neuer Gildenmagier (Bambi,  6. Jan 2003, 13:18:16):
~#! rn=Humni rt=1041790959 rg=gilden.katzenkrieger
~#! tid=1041790959
Kurze Verlaufsschilderung.

Da ich ab und zu die Zeit finde, mich zum Stati (Karlsruhe) zu begeben, habe
ich des oefteren Kontakt mit Spielern, darunter auch Katzenkriegern. Dabei
kamen verschiedene Ideen auf, wie man die Katzenkrieger verbessern (nicht
unbedingt aufwerten) koenne.
Da ich auch ab und zu zum Stati in Stuttgart komme und ich dort Humni
getroffen habe, habe ich mich mal mit ihm ueber diese und jene Idee
unterhalten.
Da Paracelsus im MG eher als inaktiv bezeichnet werden kann und auch sonst
verschiedene Leute meinten, ich sei der einzige, der sich um die Gilde
kuemmern wuerde, wurde ich zum komissarischen Gildenmagier ernannt.

Die Arbeit an der Gilde bezieht sich hierbei zunaechst auf folgende Gebiete.
Wartung des Quellcodes (bugfixes etc). - Dies ist bisher kaum notwendig, da
Paracelsus einen sehr gut strukturierten Code hinterlassen hat. (Jaja, mal
abgesehen von den zigtausend h-files.)
Pruefung und Umsetzung von Ideen bezueglich des Spellbooks. - Dies ist zum
Beispiel eine Erweiterung des Pflanzenkriegerspells. Aufwertungen auf niederen
Leveln sind eher nicht zu erwarten, immerhin sind wir eine Anfaengergilde.
Hilfe fuer Magier. Dies bezieht sich zum Beispiel auf die Erschaffung von
Gildentesties oder von Gilden-NPCs, also NPCs, die der Katzenkriegergilde
angehoeren. Inwieweit es schon Gilden-NPCs gibt, weiss ich noch nicht, werde
mir aber Paracelsus' Sachen in der Gilde noch anschauen, soweit dies noch
nicht geschehen ist.

Was erwarte ich selbst?
Es gibt verschiedene Konzepte fuer die Katzenkriegergilde, die mehr oder
weniger bekannt sind.
Dies sind beispielsweise die sogenannten Clans. Moeglich sind aber auch
Gildenquests ab mittleren Levels, beispielsweise um diverse Neuerungen nutzen
zu koennen.
Sollte jemand Ideen, Vorschlaege oder Mithilfeangebote in petto haben, waere
ich sehr dankbar darueber.

Meine Stellung.
Ich habe Paracelsus eine Mail geschrieben, in der ich die bisher angedachten
Aenderungen beschrieben habe. Da es seine Gilde ist, werde ich nur mit seinem
Segen groessere Veraenderungen vornehmen. Ausserdem bin ich noch anderweitig
beschaeftigt (RM, Gebiet proggen, real life...), so dass ich -abgesehen von
den schon angedachten spellbookaenderungen- vorerst nur auf Anfrage aktiv
werde.

Sollten weitere Mitteilungsbeduerfnisse meinerseits bezueglich der
Katzenkriegergilde bestehen, werde ich sie in dieser Rubrik ausleben.

MfG, Bambi.

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



Re: Re: Neuer Gildenmagier (Elizabeth,  6. Jan 2003, 18:00:51):
~#! rn=Sou rt=1041791023 rg=gilden.katzenkrieger
~#! tid=1041790959
katzen != katzenkrieger

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



TKKG-Update (Bambi, 25. Feb 2003, 01:59:25):
Hallo werte Katzenkrieger und Freunde selbiger.
Seit jetzt gibt es ein TKKG-Beta-Update (TKKG: Tolle Katzenkriegergilde).
Die Aenderung bezieht sich auf den "winterhauch"-Spell.
Es gibt einige provisorische Schadensmeldungen, die sich wahrscheinlich noch
aendern werden.
Diesbezueglich habe ich zwei Bitten.
Erstens: setzt den Spell einigermassen haeufig ein, damit ich ein paar
brauchbare Daten bekomme, was der Spell im Schnitt so an Schaden verursacht.
Zweitens: Schickt mir ein paar sinnvolle Schadensmeldungen, die ich
zusaetzlich oder anstatt der derzeit eingebauten Meldungen einbauen kann.

Viel Spass beim Testen.

Bambi. TKKG-GM ;)

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



Winterhauch. (Bambi,  4. Mar 2003, 17:27:29):
Trotz mangelhafter Beteiligung der Gildenmitglieder wurde der Spell
Winterhauch neu konzipiert und -implementiert.
Im Wesentlichen gibt es nun Meldungen, welcher Feind wieviel Schaden
abbekommen hat.
Ausserdem ist der Spell nun etwas staerker, trifft aber nur noch eine
begrenzte Zahl an Gegnern.
Sollte es Anregungen, Kritik oder Bugerscheinungen geben, dann moechte man
mich bitte darueber informieren.

MfG, Bambi.

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



Xelonir... (Bambi, 14. Mar 2003, 00:49:47):
reagiert nun auch auf teile mit-Anfragen zu Faehigkeiten, Zauber, etc.
Sollte jemand etwas elementares vermissen, das per fragen geht, per teile mit
aber nicht, dann moege er/sie/es mich das wissen lassen.
Auf Wuensche, wie "remote Level erhoehen" oder "remote lernen" bitte ich zu
verzichten.

MfG, Bambi.

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



Krallenschlag... (Bambi, 14. Mar 2003, 14:18:46):
kann jetzt auch mit nur einer freien Krallen gemacht werden.
Ausser den Kosten (8 anstatt 5 Konzentrationspunkten) aendert sich nichts.

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



Re: Krallenschlag... (Foobar, 14. Mar 2003, 16:23:35):
~#! rn=Bambi rt=1047647926 rg=gilden.katzenkrieger
~#! tid=1047647926
Auch der Schaden nicht?

Foobar

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



Re: Re: Krallenschlag... (Bambi, 14. Mar 2003, 16:29:57):
~#! rn=Foobar rt=1047655415 rg=gilden.katzenkrieger
~#! tid=1047647926
Nochmal ausfuehrlich:
Frueher: Krallenschlag nur 2-Hand, Kosten 5 KP.
Heute a. Krallenschlag 2-Hand, Kosten 5 KP.
Heute b. Krallenschlag 1-Hand, Kosten 8 KP.

Schaden frueher wie heute identisch.

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



Pflanzenfessel (Bambi, 15. Mar 2003, 13:28:52):
Die Pflanzenfessel sollte sich nun etwas anders verhalten als bisher.
Wenn schon eine Pflanzenfessel (oder eine andere Art der Verlangsamung) auf
den Gegner wirkt, dann sollte es nicht mehr moeglich sein, eine neue
Pflanzenfessel auf diesen Gegner zu sprechen. Der Spell sollte dann aber auch
keine KP-Kosten und keine Wartezeit bis zum naechsten Spell verursachen.
Wenn jemand ein anderes Verhalten beobachtet, dann ist dies moeglicherweise
ein Bug und mir bitte zu melden.

Es wird gegebenenfalls weitere Aenderungen an diesem Spell geben. Diese werden
dann jedoch bekanntgegeben.

MfG, Bambi.

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



Renovierung und Erweiterung (Simtur, 27. Sep 2003, 23:16:30):
Hallo,
In den letzten Tagen kam auf der Ebene Katzenkrieger seitens des Magiers Bambi
als auch von den Spielern der Wunsch und die Idee, die Katzenkriegergilde ein
wenig zu "renovieren". Nein, damit ist keine kaempferische Aufwertung gemeint
) Viel mehr wollen wir ein paar Gildenraeume und ein paar Kleinigkeiten
hinzufuegen, die dann speziell den Katzenkriegern zur Verfuegung stehen. Als
Beispiel sei hier eine Handschuhumschneiderei genannt (copyright by Bambi ;)),
in welcher man sich in seine Handschuhe so Loecher reinschneidern (lassen)
kann, dass man diese beim Krallenschlag/Todeskralle nicht mehr ausziehen muss.
Um das ganze nicht auf Bambis Schultern abzuladen, haben wir uns darauf
geeinigt, dass ich einmal alle Ideen einsammle, die der gesammelten
Felinenwelt (speziell den Katzenkriegern) so einfallen und diese dann sortiert
an Bambi weitergebe (dann bekommt er auch nicht alles doppelt ;)).
Ich bin mir sicher, dass ihr alle Lust auf weitere Gildenraeume und vielleicht
das ein oder andere Feature habt, also helft fleissig mit (vielleicht duerfen
wir uns dann irgendwo ein Ehrentaefelchen aufhaengen *g*) und mailt mir eure
Ideen! Mein Postfach ist leer und darf somit gerne befuellt werden (aber nicht
mit Spam *Krallenausfahr*).
Mein Dank an alle fleissigen Katzenkrieger schon mal im Voraus,
Gruss Simtur,
der jetzt wieder fleissig die Ebene mit Meldungen zupflastern geht ;)

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



Ideen fuer die Gildenraeume... (Bambi, 14. Nov 2003, 00:22:58):
Hallo Katzenkrieger.
<Titel des Artikels> koennen jetzt als Notiz an einem Brett in der
Katzenkriegergilde verewigt werden.
Macht Gebrauch davon.

MfG, Euer Gildenmagier.

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



Motivation... (Bambi, 20. Nov 2003, 13:51:41):
XXX denkt   . o O (kaempfer kaempfen, zauberer zaubern, katzenkrieger kriegen
katzen...)


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



Re: Motivation... (Simtur, 20. Nov 2003, 18:49:59):
~#! rn=Bambi rt=1069332701 rg=gilden.katzenkrieger
~#! tid=1069332701
*MaldasRehmuster* was wollte uns dieser Artiel sagen?

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



Re: Re: Motivation... (Montanus, 20. Nov 2003, 19:22:51):
~#! rn=Simtur rt=1069350599 rg=gilden.katzenkrieger
~#! tid=1069332701
Das beduetet, dass Bambi mir mal zugehoert hat, oder jemand meinen Spruch
geklaut hat.

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



Re^3: Motivation... (Whitetiger, 20. Nov 2003, 19:25:43):
~#! rn=Montanus rt=1069352571 rg=gilden.katzenkrieger
~#! tid=1069332701
Und Chaoskrieger kriegen Chaos oder was ? ;)

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



Re^4: Motivation... (Anatol, 20. Nov 2003, 19:27:40):
~#! rn=Whitetiger rt=1069352743 rg=gilden.katzenkrieger
~#! tid=1069332701
Chaoskrieger bekriegen das Chaos.


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



Re^5: Motivation... (Whitetiger, 20. Nov 2003, 19:29:06):
~#! rn=Anatol rt=1069352860 rg=gilden.katzenkrieger
~#! tid=1069332701
Neee das waren die Kleriker, IIRC.
Als Chaot hab ich eher mit Chaosbaellen um mich geworfen...

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



Gildentopliste (Bambi, 10. Dez 2003, 19:02:53):
Die Gildentopliste wird nun mit einer neuen Formel berechnet. Ausserdem gabs
in der Berechnung einen Bug, der nun behoben ist. Die alte Topliste wurde fuer
nichtig erklaert. Die neue Topliste ist ab sofort gueltig.
In der Topliste sollten nur Katzenkrieger erscheinen, die ab jetzt mindestens
einmal bei Xelonir vorbeigeschaut haben.

MfG, Bambi.

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



Aenderung in Katzenauge (Turbo, 18. Dez 2003, 10:02:00):
In der Anzeige des Kommandos Katzenauge ist ein Bug behoben 
worden (inkorrekter Zeilenumbruch). Das scheint auch gut
zu funktionieren (danke, Bambi). 
Leider gibt es einen dummen Seiteneffekt: die Anzeigen des
Tools reduce.tf von Thufhir sind auf die alte Anzeige 
eingestellt, wodurch sie nicht mehr funktionieren.
Hat einer der tf-cracks nen Tip?

Turbo (Kater)

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



Re: Aenderung in Katzenauge (Thufhir, 18. Dez 2003, 10:27:24):
~#! rn=Turbo rt=1071738120 rg=gilden.katzenkrieger
~#! tid=1071738120
kurz huhu,

ich will nur ganz kurz was allgemeines dazu sagen:
1. das gehoert hier eigentlich nicht in die mpa, zuerst bitte den
entsprechenden author des paket ansprechen, der steht immer oben im header,
wenn der nicht zu erreichen sein sollte, dann kann man auf -tf mal nachfragen,
ob evtl. wer anderes zustaendig ist.
2. wenn es probleme mit paketen gibt und ihr euch entschliesst, diese dem
autor zu mailen, waere es hilfreich, wenn ihr die versionsnummer dazuschreibt.
3. aktuelle programmpakete gibt es unter:
http://cvs.sourceforge.net/viewcvs.py/tf-macros/Version/
4. die pakete in der aktuellen release sind alles andere als aktuell, also
bitte vorher checken, ob ihr wirklich das aktuelle paket von der webseite
benutzt.

vielen dank,
s'Zauberzwerch

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



Anregungen? (Morgoth, 14. Jan 2004, 21:16:32):
http://www.obliquity.com/cats/diction.html

M*

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



Spellkomponenten (Bambi, 22. Mar 2004, 13:40:42):
Ohne aktuellen Anlass weise ich darauf hin, dass es nicht sonderlich nett ist,
begrenzte Komponentenstellen automatisiert (z.B. in einem Wegescript)
abzugrasen. Ich weise darauf hin, dass bei zukuenftig eingehenden Beschwerden
ggf. ohne weitere Information geeignet erscheinende Massnahmen (*) ergriffen
werden, um dieses Verhalten abzustellen.

MfG, Bambi.

Zu (*): Todesfallen, Skills senken, im Nest der Hydra erwachen, ...

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



Re: Spellkomponenten (Padreic, 22. Mar 2004, 14:24:00):
~#! rn=Bambi rt=1079959242 rg=gilden.katzenkrieger
~#! tid=1079959242
Vielleicht sollte man einfach ueber den Sinn von erscriptbaren Komponenten
nachdenken? Wenn ein bestimmtes Verhalten nicht gewuenscht ist, dann
unterbinde es mit Konzept und nicht mit wilden Drohungen Bambi.

Pad*

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



Re: Re: Spellkomponenten (Turbo, 22. Mar 2004, 15:06:26):
~#! rn=Padreic rt=1079961840 rg=gilden.katzenkrieger
~#! tid=1079959242
Mich wuerde mal interessieren, welche Komponenten das waren - 
es gibt ja immer hin zwei *eg* und eine davon an exakt einer 
Stelle, und noch mehr, wer sich beschwert hat und ueber wen. 

Bislang reichte es, wenn die Handvoll KK, die eine, und die 
drei bzw. jetzt 4, die die andere Komponente benutzen koennen, 
untereinander bzw. auf der Ebene gefragt haben, wenn ihnen 
- meist zum Skilltraining - was fehlte. Da wurde gleich
ausgeholfen.
 
Ich habe nie gescriptet gesammelt, habe aber so viele Blaetter
bzw. Kirschen im Vorrat, dass ich praktisch nicht mehr sammle.
Und dabei bin ich eher einer der aktiveren KK.
 
Wenn da jemand ne Hamsterneurose hat, muesste eine einmalige
freundliche Zurechtweisung reichen. Mir ist noch nicht aufgefallen,
dass keine Blaetter mehr rumliegen.
 
Turbo (Kater)

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



Re^3: Spellkomponenten (Simtur, 23. Mar 2004, 09:28:24):
~#! rn=Turbo rt=1079964386 rg=gilden.katzenkrieger
~#! tid=1079959242
Morgen!
Also, aktuell kann das ja eigentlich nicht der Fall sein oder? Da es nur 7 KK
gibt, die Kirschen ueberhaupt nutzen koennen (jetzt mal wieder ohne Shaeena
gerechnet) und davon 4 recht inaktiv sind. Im Prinzip *mabehaupt* nutzen eh
nur Turbo, Tassram und ich die oder irr ich mich da?
Ich hatte bisher zumindest nie Probleme an Kirschen und auch an Blaetter
ranzukommen.
Simtur (ebenfalls Kater ;))

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



Ostergeschenke... (Bambi, 10. Apr 2004, 11:36:56):
gibt es auf dem Ideenbrett.

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



Re: Ostergeschenke... (Darklor, 10. Apr 2004, 20:09:23):
~#! rn=Bambi rt=1081589816 rg=gilden.katzenkrieger
~#! tid=1081589816
Oh, das is aber nett! - Biste jetzt ein Osterreh? - Und wo haste die anderen
versteckt? ;) 

Darklor

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



Winterhauch (Bambi, 30. Apr 2004, 16:57:09):
Der Spell "Winterhauch" wurde etwas ...oehm... aufgewertet. Geht testen. Wenn
er euch immer noch zu schwach oder wenn er euch zu stark vorkommt, meldet euch
bitte bei mir. Ich lass (wie schon vorher) nen log mitlaufen, um den alten und
den neuen durchschnittlichen schaden miteinander vergleichen zu koennen.

Viel Spass beim Metzeln.

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



Re: Winterhauch (Darklor, 30. Apr 2004, 19:24:19):
~#! rn=Bambi rt=1083337029 rg=gilden.katzenkrieger
~#! tid=1083337029
Und? Is ein Loblied auf Bambi angebracht???

Darklor ;)

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



Owen Braddon (Arathorn,  3. Mai 2004, 00:37:12):
Tag zusammen,

ich habe heute mal ein ernstes Wort mit o.g. Herrn Braddon gesprochen, und
ihm beigebracht, dass es kein feiner Zug ist, Eure Gilde immer so
geflissentlich zu uebergehen, wenn Ihr ihn nach Euren Faehigkeiten fragt.

Das Problem bestand ja augenscheinlich schon laenger, und da man alte
Gewohnheiten nicht gerne ablegt, hat es etwas gedauert. Aber schlussendlich
hat Owen eingesehen, dass es so nicht weitergeht, und gibt jetzt auch
Katzenkriegern bereitwillig Auskunft. :-)

Falls es in Zukunft nochmal Schwierigkeiten geben sollte, sagt Bescheid. ;-)
Gruss,
Arathorn

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



Re: Owen Braddon (Darklor,  3. Mai 2004, 10:02:10):
~#! rn=Arathorn rt=1083537432 rg=gilden.katzenkrieger
~#! tid=1083537432
Ah, endlich kennt er die Gilde... ;)

Darklor

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



Re: Re: Owen Braddon (Zook,  3. Mai 2004, 10:03:10):
~#! rn=Darklor rt=1083571330 rg=gilden.katzenkrieger
~#! tid=1083537432
Wieso eigentlich "endlich"?

Zook.

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



Re^3: Owen Braddon (Darklor,  3. Mai 2004, 10:09:43):
~#! rn=Zook rt=1083571390 rg=gilden.katzenkrieger
~#! tid=1083537432
Ich glaub vorher fragte er Welche Gilde?

Darklor

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



Re^4: Owen Braddon (Brotnael,  4. Mai 2004, 20:04:02):
~#! rn=Darklor rt=1083571783 rg=gilden.katzenkrieger
~#! tid=1083537432
Duerfen Katzen dann auch bald Kleri werden? :o)
Broti fuer heilige Katzen

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



Handfreie Handschuhe (Bambi, 18. Mai 2004, 11:16:28):
Die Tanjian koennen Handschuhe verwenden, die "handfrei" sind. Wir konnten
bisher nur "fingerfreie" Handschuhe verwenden. Humni und ich sind
uebereingekommen, dass handfreie Handschuhe immer auch fingerfrei sind. Das
heisst, dass Ihr mal ein paar Tanjian nach Handschuhen fragen koennt, die sie
benutzen koennen, ihr bisher aber nicht. Vielleicht sind da einige
interessante dabei.

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



Schleichen (Bambi, 11. Jun 2004, 18:20:13):
koennt ihr nicht besser oder schlechter, aber es gab trotzdem eine Aenderung
an diesem Spell. Die Bibliothek in Katzmandu beinhaltet aktuelle Infos dazu.
Wenn ihr einen Bug beim Spell bemerkt, lasst es mich wissen. Mit dieser
Aenderung sollten Unklarheiten bei gewissen NPC-Ballungen verschwinden.

Bambi.

PS.
Schenkt Humni ein paar Breckies, gebt ihm ein Bier aus oder lasst euch von ihm
fuer seine Freundlichkeit fressen.

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



Felinen in Applikationen (Bambi, 24. Jul 2004, 12:07:02):
Folgenden Satz habe ich in der Beschreibung eines Persistenzframeworks
gefunden:
Most Java applications require a persistent class representing felines.


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



Spellbookupdate (Bambi,  7. Aug 2004, 10:43:40):
Es hat wesentliche Aenderungen in den Spells "Krallenschlag", "Schaetz" und
"Ausweichen" gegeben.

Krallenschlag:
Aufgrund eines Bugs konnte man Krallenschlag (im Gegensatz zu Todeskralle)
nicht mehr mit dafuer vorgesehenen Handschuhen einsetzen. Das war ein Bug, der
nun behoben sein sollte.

Schaetz:
Schaetz wurde so angepasst, dass alle dafuer vorgesehenen Handschuhe auch als
krallenschlagfaehige Items erkannt werden. Schaetz sollte nun  auch Koecher
als solche erkennen. Der Spell wurde um eine Spezialfunktion erweitert, die
bei der Neufassung von "Ausweichen" von Interesse ist.

Ausweichen:
Ausweichen wird seit einigen Tagen von den Katzenkriegern getestet. Einen
"Betatest"-Hinweis hierfuer gab es ueber die KK-Ebene. Ich habe ausser "nett,
aber ich meld mich nochmal" noch keine Rueckmeldungen dazu bekommen. Die
haette ich aber gerne noch, damit ich zusammen mit Humni endgueltig
entscheiden kann, ob wir die de facto-Aufwertung dieses Spells so lassen, wie
sie ist oder nicht. Die Dokumentation zu diesem Spell (in der Bibliothek in
Katzmandu) ist auf dem aktuellen Stand.

MfG, Bambi.

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



Blutwandlung und so Zeugs. (Bambi,  8. Jan 2005, 01:29:53):
Hallo Katzenkrieger, hallo Rest.

Wie den meisten bekannt sein duerfte, haben die Kleriker einen Spell, mit dem
sie sich und andere entgiften koennen. Die Katzenkrieger haben ihrerseits den
Blutwandlungsspruch, der natuerlich bei weitem nicht so effektiv ist, wie der
Spruch der Saphinaanhaenger.
Aus Sicht der Katzenkriegergilde waere das auch voellig in Ordnung, wenn nicht
der Rest der Welt diesen Spruch praktisch umsonst lernen darf. Daher haben
Humni und ich uns ein paar Ideen durch den Kopf gehen lassen.

Das Endergebnis war, dass der "Entgiftespruch fuer alle" nicht als
Questbelohnung gestrichen, sondern der Blutwandlungsspruch etwas modifiziert
wird. Er ist zwar in seiner urspruenglichen Bedeutung nicht besser geworden,
denn das effektivere Entgiften sollte ein Spezialgebiet der Kleriker bleiben,
aber dafuer kann man ihn nun auch auf andere Weise verwenden.
Was er einem bringt, kann man in der Bibliothek von Katzmandu und mit etwas
logischem Denken leicht herausfinden.

MfG, Bambi.

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



Re: Blutwandlung und so Zeugs. (Turbo,  8. Jan 2005, 22:48:56):
~#! rn=Bambi rt=1105144193 rg=gilden.katzenkrieger
~#! tid=1105144193
Zunaechst einmal bin ich mit der Loesung zwar nicht restlos gluecklich,
da die Diskriminierung der auch sonst nicht eben ueberpowerten 
Katzenkrieger bestehen bleibt, sehe sie aber als einen akzeptablen
Kompromiss an und auf jeden Fall als eine bessere Loesung im Vergleich
zu der von bestimmter Seite vorgeschlagenen Entgifte-Entziehung fuer alle
anderen.

Der neue Offensivspell ist gewiss attraktiv und interessant und insofern
kein Gemecker oder Katzenjammer :). Allerdings ist mir bei Tests mit der
neuen Faehigkeit aufgefallen, dass eine alte Schwaeche des Giftdolchspruchs
fortbesteht: Der Giftdolchspruch ist kein Elementarschaden, sondern an eine
Waffe gebunden. Wenn das angegriffene Monster auch nur leicht resistent
gegen mechanische Schaeden ist, wie Glaaki, Yibb-Tsstl, Shodagoi, die 
Kobolde, der Drakonieroberpriester und viele andere, von Silvanas
Viehzeug (wo das wohl gewollt ist) noch garnicht zu reden, kommt 
null Vergiftung durch, auch wenn man das Viech mit Blutwandlung
anfaellig gemacht hat. Man verballert bloss 30 kp mehr.

In dem Zusammenhang: Wo unsere Spells schon nicht die staerksten sind,
muessen sie die teuersten sein? Keine andere Gilde pulvert so schnell
kp weg wie Katzenkrieger, und das fuer auesserst maessigen Effekt.

Nur mal angemerkt. 

Turbo (Kater)

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



Der Nusstaschen-PK (Bambi,  3. Apr 2005, 00:49:27):
Der Nusstaschen-PK hatte einen kleinen Bug, den ich nun hoffentlich behoben
habe. Wenn euch der PK bisher nutzlos vorkam: testet ihn nochmal.

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



Blutwandlung (Bambi,  1. Aug 2005, 22:19:09):
Mal wieder wurde etwas an der Blutwandlung gefumm...veraendert. Naehere
Informationen findet man in der Bibliothek. Etwaige Bugs oder Ungereimtheiten
duerfen mir angezeigt werden. (Weitere) Aufwertungsgesuche zu dem Spell stehen
bis Weihnachten unter Strafe. ;)

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



Topliste (Bambi, 27. Apr 2006, 10:12:33):
Ich habe mich wieder einmal auf Bugsuche begeben und auch einige der Viecher
gefunden. Daher habe ich die Topliste geplaettet. Nun sollte (hoffentlich) die
Berechnung der Punkte korrekt sein.

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



Neuer Spell fuer Katzenkrieger-Spieler (Bambi, 16. Aug 2006, 19:20:40):
Fuer Katzenkrieger-Spieler gibt es nun einen neuen Spell. Danke an Horror fuer
den Hinweis und Humni fuer die spielerfreundliche Entscheidung.

MfG, Bambi.

P.S.
Fuer Katzenkrieger-Seher gibt es KEINEN neuen Spell.

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



Erweiterung der Gildentitel (Gingko,  4. Mai 2007, 17:30:01):
Hallo Katzenkrieger,
aus gegenbenem Anlass ;-) ist mir bewusst geworden, dass sich der Gildentitel
der Katzenkrieger ab Level 19 bis zum Seherdasein (also 19 Level lang) nicht
mehr aendert. Da das ein bisschen schade ist, hab ich grad mit Ervora zusammen
ueberlegt, ob es nicht moeglich waere, da Abhilfe zu schaffen.
Am einfachsten waere vielleicht, jeden Titel zwei Level lang beizubehalten und
so den vorhandenen "Titelschatz" bis zum Seher zu strecken. Spannender waere
es vielleicht, weitere Titel einzufuegen um die Liste so bis Level 38
aufzufuellen. An ein paar Stellen - besonders bei den Katzenkriegertiteln -
ist eine Verwendung ueber mehrere Level hinweg aber vielleicht trotzdem nicht
verkehrt.
Um die Diskussion anzustoszen hier die Ideen, die uns bisher als moegliche
weitere Titelvorschlaege einfielen (eingefuegt in die so verlaengerte
urspruengliche Liste von der Webseite):

1  Das blinde Kaetzchen           Das blinde Kaetzchen
2  Das tapsige Kaetzchen          Das tapsige Kaetzchen
   Das kleine Kaetzchen           Das kleine Kaetzchen
   Der Wollkneuljaeger            Die Wollkneuljaegerin
   Der Stubentiger                Die Stubentigerin
   Der Maeusejaeger               Die Maeusejaegerin
3  Der neugierige Kater           Die neugierige Katze
   Der unternehmungslustige Kater Die unternehmungslustige Katze
4  Der Wanderkater                Die Wanderkatze
5  Der Waldlaeufer                Die Waldlaeuferin
   Der erfahrene Waldlaeufer      Die erfahrene Waldlaeuferin
   Der Gewitterbaendiger          Die Gewitterbaendigerin
6  Der Lianenschwinger            Die Lianenschwingerin
7  Der Faehrtensucher             Die Faehrtensucherin
8  Der uebermuetige Kater         Die uebermuetige Katze
9  Der wilde Kater                Die wilde Katze
   Der heranwachsende Kater       Die heranwachsende Katze
10 Der herangewachsene Kater      Die herangewachsene Katze
11 Der Entdecker                  Die Entdeckerin
   Der Weltenbummler              Die Weltenbummlerin
12 Der Jaeger                     Die Jaegerin
13 Der erfolgreiche Jaeger        Die erfolgreiche Jaegerin
   Der Jagdexperte                Die Jagdexpertin
14 Der Wildnisexperte             Die Wildnisexpertin
15 Der angehende Katzenkrieger    Die angehende Katzenkriegerin
16 Der Katzenkrieger              Die Katzenkriegerin
17 Der grosse Katzenkrieger       Die grosse Katzenkriegerin
18 Der erfahrene Katzenkrieger    Die erfahrene Katzenkriegerin
19+ Der angehende Katzenkrieger-Seher Die angehende Katzenkrieger-Seherin
S  Der Katzenkrieger-Seher        Die Katzenkrieger-Seherin

So und jetzt bleibt die Frage: was halten die anderen Katzenkrieger von einer
derartigen Erweiterung, was haelt Bambi davon, und was faellt Euch noch an
Titeln ein.
schnurr, Gingko.

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



Re: Erweiterung der Gildentitel (Zesstra,  4. Mai 2007, 17:41:37):
~#! rn=Gingko rt=1178292601 rg=gilden.katzenkrieger
~#! tid=1178292601
Neue Titel nach level 19 einzubauen, findet ich total toll. Ich moechte aber
der Vollstaendigkeit nochmal auf die Fraternitas hinweisen, wo jeder ab Level
20 sich seinen Titel selber aussuchen kann. ;-) (Falls das halt noch jemand
nicht weiss.)

Zesstra

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



Re: Re: Erweiterung der Gildentitel (Bambi, 17. Mai 2007, 12:08:46):
~#! rn=Zesstra rt=1178293297 rg=gilden.katzenkrieger
~#! tid=1178292601
Mein Mudlib-Wissensstand ist zwar schon lange nicht mehr "auf dem neuesten
Stand" (falls er das jemals war), aber ich habe das "damals" nicht eingebaut,
weil die Mudlib imho nur 20 Titel ausliest. Ich kann mich auch irren.

MfG, Bambi.

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



Re^3: Erweiterung der Gildentitel (Zesstra, 17. Mai 2007, 12:15:13):
~#! rn=Bambi rt=1179396526 rg=gilden.katzenkrieger
~#! tid=1178292601
Mhmm, ich hab gerade mal nachgeguckt, bin mir recht sicher, dass es zumindest
heut nicht mehr so ist, da werden beliebig viele Titel verwendet.

Zesstra

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



Re^4: Erweiterung der Gildentitel (Bambi, 17. Mai 2007, 14:28:10):
~#! rn=Zesstra rt=1179396913 rg=gilden.katzenkrieger
~#! tid=1178292601
Super.
Ich habe mir Gingkos Vorschlaege angesehen und mir fiel auf, dass die Titel
(auch die, die heute schon verwendet werden) zwar nette Benennungen sind, aber
mit dem tatsaechlichen Koennen nichts zu tun haben. Ich faende es sinnvoll,
wenn die Titel mehr mit den Spells korrelieren, die man auf dem jeweiligen
Spielerlevel schon beherrscht.
Meinungen?

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



Re^5: Erweiterung der Gildentitel (Darklor, 18. Mai 2007, 00:23:04):
~#! rn=Bambi rt=1179404890 rg=gilden.katzenkrieger
~#! tid=1178292601
Also nur alle 2 Level n neuer Titel? Bzw. nur dann n neuer Titel, wenn man n
neuen Spell lernt? und wie sollen dia dann lauten (Beispiele)? Sowas wie "das
Kratzbuerstige Kaetzchen" wenn man Krallenschlag kann? 

Darklor

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



Re^6: Erweiterung der Gildentitel (Gingko, 18. Mai 2007, 21:03:50):
~#! rn=Darklor rt=1179440584 rg=gilden.katzenkrieger
~#! tid=1178292601
Hi,
Ervora und ich hatten ja eigentlich nur ueberlegt, die bestehende Liste
aufzufuellen. Aber eine Abstimmung mit den Gildenspells ist natuerlich auch
eine gute Idee.
Drum haben Oncilla und ich heute mal etwas Brainstorming betrieben und eine
Vorschlagsliste erstellt:
Lvl Faehigkeit      Gildentitel
1                  Das blinde Kaetzchen
2  Nachtsicht      Das kurzsichtige Kaetzchen
3                  Das sehende Kaetzchen
4  Krallenschlag   Das kratzbuerstige Kaetzchen
5                  Das kratzende Kaetzchen
6  Identifiziere   Das aufmerksame Kaetzchen
7                  Das interessierte Kaetzchen
8  Schaetz         Das neugierige Kaetzchen
9                  Das wissbegierige Kaetzchen
10 Blitz           Die/Der funkenspruehende Katze/Kater
11                 Die/Der Gewitterbaendiger/in
12 Ausweichen      Die/Der geschickte Katze/Kater
13                 Die/Der wendige Katze/Kater
14 Pflanzenfessel  Die/Der Pflanzendompteur/dompteuse
15                 Die/Der Fesselkuenstler/in
16 Wasserstrahl    Die/Der tropfende Katze/Kater
17                 Die/Der spritzige Katze/Kater
18 Schnell         Die/Der flinke Katze/Kater
19                 Die/Der schnelle Katze/Kater
20 Blutwandlung    Die/Der giftige Katze/Kater
21                 Die/Der zaehe Katze/Kater
22                 Die/Der Katzenkriegernovize/in
23                 Die/Der angehende Katzenkrieger/in
24                 Die/Der Katzenkrieger/in
25 Todeskralle     Die/Der Krallenexperte/in
26                 Die Teufelskralle
27                 Die/Der kampferprobte Katzenkrieger/in
28                 Die/Der Kampfexperte/in
29                 Die/Der erfahrene Katzenkrieger/in
30 Katzenauge      Die/Der erkennende Katzenkrieger/in
31                 Die/Der wissende Katzenkrieger/in
32                 Die/Der grosse Katzenkrieger/in
33                 Die/Der maechtige Katzenkrieger/in
34                 Die/Der weise Katzenkrieger/in
35 Winterhauch     Die/Der frostige Katzenkrieger/in
36                 Die/Der Seniorkatzenkrieger/in
37                 Die/Der angehende Katzenkriegerseher/in
38                 Die/Der Katzenkriegerseher/in
So weit unsere Vorschlaege. An manchen Stellen koennte man die Reihenfolge
vielleicht noch etwas aendern und bestimmt hat der ein oder andere auch noch
einen besseren Vorschlag fuer verschiedene Level.
Bin jedenfalls sehr auf die Diskussion dazu gespannt.
schnurr
Gingko

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



Re^7: Erweiterung der Gildentitel (Ark, 18. Mai 2007, 21:31:15):
~#! rn=Gingko rt=1179515030 rg=gilden.katzenkrieger
~#! tid=1178292601
Seniorenkatzenkrieger? Ehm ... spaetestens davor wuerde ich dann nicht mehr
aufsteigen wollen ... Was ist mit meiner Rente? Gibt es Katzenrollstuehle oder
nur ...schredder? Wie waere es mit Eiskatze oder Wintersturm ... ne, letzteren
gibts ja schon. Oder halt Schneekralle oder was weiss ich.


              *** ARK * the * Magnificent ***


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



Re^7: Erweiterung der Gildentitel (Ark, 18. Mai 2007, 21:33:40):
~#! rn=Gingko rt=1179515030 rg=gilden.katzenkrieger
~#! tid=1178292601
Bei Seniorenkatzendingens kommt dann noch eins in den Sinn: Grauer Panther :-)


              *** ARK * the * Magnificent ***


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



Re^8: Erweiterung der Gildentitel (Darklor, 18. Mai 2007, 21:39:43):
~#! rn=Ark rt=1179516820 rg=gilden.katzenkrieger
~#! tid=1178292601
Der Weisse Katzenkrieger

Darklor

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



Re^7: Erweiterung der Gildentitel (Ark, 18. Mai 2007, 22:01:36):
~#! rn=Gingko rt=1179515030 rg=gilden.katzenkrieger
~#! tid=1178292601
Eisschleicher, Frostkralle, Winterwanderer, Wirbelfell, Schneereisender,
Wintertatze, Winterfang, Weissfell, Blauzunge, Eistiger.


              *** ARK * the * Magnificent ***


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



Re^8: Erweiterung der Gildentitel (Darklor, 18. Mai 2007, 22:24:44):
~#! rn=Ark rt=1179518496 rg=gilden.katzenkrieger
~#! tid=1178292601
Winter-, Eis-, katze, Weiser Schneekater,...

Darklor

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



Re^9: Erweiterung der Gildentitel (Gingko, 20. Mai 2007, 00:57:50):
~#! rn=Darklor rt=1179519884 rg=gilden.katzenkrieger
~#! tid=1178292601
hi,
nach Arks kreativen Vorschlaegen, von denen wohl "Winterwanderer" die groeszte
Resonanz fand, ist zu ueberlegen, ob man sich von der bisher bei unseren
Vorschlaegen verfolgten Linie nicht weiter trennen mag.
Es kam ja fast immer "Kaetzchen", "Katze" oder "Katzenkrieger" im Titel vor.
Waere zu ueberlegen, ob man nicht oefter darauf verzichtet und mehr der Art
wie "Winterwanderer" oder "Teufelskralle" findet. In den Vorschlaegen, die ich
neulich mit Ervora gepostet hatte, gabs ja schon das ein oder andere
dahingehend. Muesste man gucken, ob sich da noch mehr findet, das zu den
Gildenspells passt. 
Wir brainstormen mal noch a weng ... 
schnurr
gingko

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



Schaetzen fuer Anfaenger und Fortgeschrittene (Derin, 15. Jun 2007, 13:47:06):
Hallo, geschaetzte Katzenkrieger!

Ich habe mit Bambi und Tassram ein wenig darueber diskutiert, und
ich schaetze, dass auch die Meinungen anderer hier fuer unseren
Gildenchef von Interesse ist. Und zwar gehts ums Schaetzen.

Um das mal mit wenigen Worten zu sagen: Die Level, die ich gebraucht
habe, "schaetz" zu erwerben (also die Level 1-8), sind auch die, in
denen ich es am schmerzlichsten vermisst habe:
 - gerade, wenn man noch neu und unerfahren im Mud ist, ist es extrem
   nuetzlich, wenn man weiss, was eine Nummer zu gross fuer einen ist;
 - gerade, wenn man noch neu und unerfahren im Mud ist, ists nuetzlich,
   wenn man sehen kann, ob man einen Spieler oder ein Monster vor sich
   hat.
Ich haette mit Kusshand "schaetz" als ersten Spell genommen, und dafuer
Nachtsicht oder vor allem auch Krallenschlag nach hintenangestellt.
Identifiziere ist ja ebenfalls sehr nuetzlich, aber die Infos aus
"schaetz" waeren mir meist lieber gewesen.

Tja, und jetzt habe ich "schaetz", aber jetzt erkenne ich in aller Regel
auch einen Spieler, der irgendwo rumsteht. Und ich kann es mir mittler-
weile auch leisten, einfach mal ein Monster auszuprobieren, mein Polster
an Lebenspunkten ist dafuer inzwischen dick genug. Den wirklich
*dringenden* Bedarf an dem Spruch habe ich nicht mehr.

Meine Ueberlegung: man koennte unsere schoene Gilde fuer frische Spieler
doch eigentlich attraktiver (und in sich stimmiger) machen, indem man da
korrigierend Hand anlegt.

Meine Bitte an Euch: schreibt doch mal kurz Eure Meinung dazu. Muss ja
nicht so ein Roman sein wie meine Artikel immer sind. :)


Dankeschoen,
Derin.

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



Pflanzenkrieger & Team (Bambi, 17. Jun 2007, 14:47:11):
Katzenkrieger koennen ab sofort mit ihrem Pflanzenkrieger ein Team gruenden.
Hierfuer ist das Kommando "team aufnahme pflanzenkrieger" zu verwenden, so als
ob man einen anderen Spieler aufnehmen will.
Falls hier Unstimmigkeiten auftreten, bitte melden.

MfG, Bambi.

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



Ausweichen und "ende": bitte vorlaeufig nicht benutzen (Zesstra, 11. Jul 2007, 00:19:21):
Huhu Katzenkrieger,

es gibt einen bloeden Bug, der im Zusammenhang mit eurem Ausweichen-Spell und
einem "ende" auftritt und dazu fuehrt, dass ihr nach dem "ende" nicht mehr
kaempfen koennt. Der Bug ist ein Bug in einer Funktionalitaet in der Mudlib,
die nur von den KK benutzt wird (seit 1.5 bis 2  Wochen), daher ist das bisher
noch nicht aufgefallen.

Bis hierfuer eine passende Loesung gebaut ist, moechte ich euch bitten, auf
"ende" zu verzichten.
Solltet ihr in den letzten 1.5 - 2 Wochen kein "Ausweichen" benutzt haben,
waere es gut, auf dieses Spruch vorlaeufig zu verzichten. (In diesem Fall
koennt ihr auch "ende" benutzen.)

Ich oder Bambi informieren euch, sobald eine endgueltige Loesung gebaut ist.
Solltet ihr Probleme mit dem Metzeln haben, wendet euch bitte an Bambi oder
mich.

Viele Gruesse,

Zesstra

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



Re: Schaetzen fuer Anfaenger und Fortgeschrittene (Gingko, 11. Jul 2007, 23:25:31):
~#! rn=Derin rt=1181908026 rg=gilden.katzenkrieger
~#! tid=1181908026
Seid gegrueszt Katzenkrieger,
ich wuerde Derins Ausfuehrungen durchaus zustimmen. "Schaetz" als ersten und
"Identifiziere" als zweiten Spruch lernen zu koennen, haette fuer Anfaenger
durchaus seine Forteile. Besonders auch der Aspekt den Tassram noch angefuehrt
hat, naemlich dass man die Vorteile von "Nachtsicht" und "Krallenschlag" auch
konventionell bewirken kann (Fackel, Waffe), wuerde auch fuer eine andere
Reihenfolge sprechen. Ich denke, damit halten sich auch die Auf- und
Abwerteeffekte durch das Vertauschen etwa die waage. Identifiziere ist zwar
bei vielen Questobjekten hilfreich, aber mit ganz niedrigem Level ist das noch
nicht so wichtig; dafuer aber ist es sehr hilfreich, wenn das kleine Kaetzchen
sieht, wie stark der Baer ist, vor dem es gerade steht. Vielleicht ist eine so
geaenderte Reihenfolge sogar ein klein wenig "realistischer" :-).
geschnurrte Gruesze
Gingko

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



Re: Re: Schaetzen fuer Anfaenger und Fortgeschrittene (Humni, 13. Jul 2007, 01:51:51):
~#! rn=Gingko rt=1184189131 rg=gilden.katzenkrieger
~#! tid=1181908026
Viele Magier bauen Quests, bei denen sie voraussetzen, dass der (evtl. auch
nicht so grosse) Spieler identifizieren kann.

Ich halte einen recht fruehen Identifiziere-Spell durchaus fuer sinnvoll.

Schaetz-Sprueche (vor allem auf Monster) sind hingegen natuerlich auch gerade
am Anfang wichtiger als spaeter, da man spaeter eh an Gegner geraet, von denen
man erstmal rausfinden muss, was die eigentlich koennen.

Nur mal so als Anmerkung, aber ich halte einen recht fruehen id-Spruch schon
fuer sinnvoll.

Humni

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



Re^3: Schaetzen fuer Anfaenger und Fortgeschrittene (Boing, 13. Jul 2007, 09:11:34):
~#! rn=Humni rt=1184284311 rg=gilden.katzenkrieger
~#! tid=1181908026
Bei Quests die identifizieren erfordern muss eben die Stufenempfehlung
entsprechend hoch gesetzt sein.
  Boing

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



Re: Re: Schaetzen fuer Anfaenger und Fortgeschrittene (Zesstra, 13. Jul 2007, 09:48:59):
~#! rn=Gingko rt=1184189131 rg=gilden.katzenkrieger
~#! tid=1181908026
Mhmm, ich hatte mich bisher nur per tm zu dem Thema geaeussert, aber nen paar
Worte kann ich noch beisteuern.
Ich finde, das realistische Einschaetzen eines Gegners ist eine Sache, die ein
gewisses Mass an (Welt- bzw. Spiel-) Erfahrung vorraussetzt. Daher empfaende
ich es gar nicht so logisch, wenn das sehr frueh geht.
Nun kann ich nicht behaupten, dass Identifiziere in meiner Vorstellung
unbedingt "einfacher" als Einschaetzen sein muss, aber da kommt Humnis Einwand
ins Spiel, den ich voll unterstuetze. In allen moeglichen Questobjekten legen
Magier Infos ab, die vom id-Spruch ausgelesen werden und ohne die man oft
nicht weiterkommt. Ein Beispiel fand ich neulich in der Tanjiangilde, wo ein
Spieler mit Level 25 noch keinen id-Spruch hatte und in einer Quest voellig
aufgeschmissen war. Ich wuerde mich daher sehr dagegen aussprechen, einen
id-Spruch auf hoehere Level zu verlagern.
Was das Einschaetzen angeht: Die meisten Gilden haben den so, dass die
erhaltenen Infos reichhaltiger und genauer werden, wenn der Level steigt.
Sowas koennte ich mir auch bei den KK gut vorstellen, z.B. am Anfang nur grob
was a la "Du hast den Eindruck, der Wechhier ist wesentlich staerker als Du"
und halt so, dass man sich auch mal irrt...

Zesstra

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



Re^4: Schaetzen fuer Anfaenger und Fortgeschrittene (Croft, 13. Jul 2007, 11:09:02):
~#! rn=Boing rt=1184310694 rg=gilden.katzenkrieger
~#! tid=1181908026
Das Irritierende sind idR Questbelohnungen, die identifizieren brauchen,
die aber schon empfohlen werden wenn man noch kein ID hat.

Croft

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



Re^5: Schaetzen fuer Anfaenger und Fortgeschrittene (Shaeena, 13. Jul 2007, 12:57:05):
~#! rn=Croft rt=1184317742 rg=gilden.katzenkrieger
~#! tid=1181908026
Also ich fand nachtsicht durchaus sehr sinnvoll als ich klein war,
aber mit dem Identifizieren kann ich nur zustimmen, dass es schoen
gewesen waere, wenn das frueher verfuegbar gewesen waere.
Schaetz halte ich fuer nicht so wichtig, das merk ich ja, wenn mir ein 
Gegner zu groein ist. Spaetestens wenn er mich umgebracht hat :-)
Was mir Gegenstaende in einer Quest bringen merke ich meist nicht,
weil die mich nicht umbringen und wenn ich im Dschungel rumlaufe
und ploetzlich in einer dunklen Hoehle sitze aus der ich nicht mehr
rauskomme, dann hilft mir auch mein schaetz nichts.

Shaeena

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



Re^6: Schaetzen fuer Anfaenger und Fortgeschrittene (Bambi, 13. Jul 2007, 20:00:38):
~#! rn=Shaeena rt=1184324225 rg=gilden.katzenkrieger
~#! tid=1181908026
Laut Bib ist die Reihenfolge derzeit so:
 nachtsicht ............... Spielerlevel  2
krallenschlag ............ Spielerlevel  4, nur Felinen
identifiziere ............ Spielerlevel  6
schaetz .................. Spielerlevel  8

Das koennte man wie folgt umsortieren.
Auf Level 2 identifiziere
Auf Level 4 schaetz
Auf Level 6 Nachtsicht
Auf Level 8 Krallenschlag

Gibt es weitere Vorschlaege fuer eine andere Sortierung? Wenn ja, dann bitte
mit Begruendung, damit das Ganze nachvollziehbar ist.

Theoretisch (!) ist es auch moeglich, sich ueber eine weitergehende
Ueberarbeitung der Spells zu unterhalten. Beispielsweise wurde angeboten, dass
wir die Blutwandlung komplett aufgeben und dafuer das Duesterwald-Entgifte
bekommen. Der Blutwandlung-Platz wuerde dadurch evtl. freiwerden.
(Andererseits koennte man auch argumentieren, dass man mit der Aufgabe dieses
Spells effektiv aufgewertet wird. ;) )

Bambi.

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



Re^7: Schaetzen fuer Anfaenger und Fortgeschrittene (Gloinson, 13. Jul 2007, 20:04:42):
~#! rn=Bambi rt=1184349638 rg=gilden.katzenkrieger
~#! tid=1181908026
Wie waers denn, das einfach nur nach unten zu schieben und oben etwas
aufzufuellen anstatt den ersten Offensivspell nach oben zu tauschen?

Auffuellen?
> Harmlos.
-> ein Befrieden fuer den Katzenspieler, gilt nur bis Level Blub
   (so eine alte, raeudige Mieze sieht einfach nicht mehr harmlos aus)

Andere Spieler werden sicher gern alberne Ideen zusteuern.


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



Re^8: Schaetzen fuer Anfaenger und Fortgeschrittene (Grimmborn, 13. Jul 2007, 20:42:29):
~#! rn=Gloinson rt=1184349882 rg=gilden.katzenkrieger
~#! tid=1181908026
Bei den ganzen Aufwertungen muss man natuerlich aus Balancegruenden woanders
wieder etwas abwerten. 

GdA

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



Re^9: Schaetzen fuer Anfaenger und Fortgeschrittene (Gloinson, 13. Jul 2007, 21:04:07):
~#! rn=Grimmborn rt=1184352149 rg=gilden.katzenkrieger
~#! tid=1181908026
Och, Spells mehr sind nicht unbedingt eine Aufwertung, insbesondere wenn die
neuen konkurrieren. Kampfspells im Harmlos-Modus-Beispiele gingen nicht, ein
einfacher, weiterer Kampfspells kann nur anstatt des besseren gesprochen
werden etc.pp. Ausserdem schlage ich vor, durchaus auch mal kreativ Spells zu
erfinden, die ab einem bestimmten Level einfach NICHT mehr gehen. Bei so einer
physisch orientierten Gilde sollte das logisch eher gehen als bei sagen, wir
Zauberern.


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



Re^7: Schaetzen fuer Anfaenger und Fortgeschrittene (Gingko, 13. Jul 2007, 21:42:53):
~#! rn=Bambi rt=1184349638 rg=gilden.katzenkrieger
~#! tid=1181908026
Also nach unserer Diskussion eben find ichs eigentlich noch sinnvoller, wenn
identifiziere nicht als erstes kaeme, da es doch eigentlich erst fuer hoehere
quests (so ab leveleinschaetzung 5) benoetigt werden sollte. ich wuerde mir
eigentlich "schaetz" als erste wuenschen, um der unnatuerlichkeit des muds
begegnen zu koennen, dass es woelfe gibt die ich mit einem schlag umhau und
kaefer die mich mit ihren beinchen in den boden stampfen. da ist man als
anfaenger doch etwas aufs glatteis gefuehrt ;-)
nachtsicht ist eigentlich auch ein schoener spruch fuer untere level, aber ich
weisz nicht, ob man den katzenKRIEGERN nicht ein wenig kriegerischen flair
nimmt, wenn der erste kampfspell mit level 8 gelernt werden kann und dann aber
mit level 10 (blitz) gleich der naechste.
mein vorschlag waere:
level 2  -  schaetz
level 4  -  krallenschlag
level 6  -  identifiziere
level 8  -  nachtsicht
wobei ich mit nachtsicht so weit hinten eigentlich auch nicht gluecklich bin.
ist schon schwer *seufz*. aber ich denke identifiziere erst mit level 8 zu
lernen ist dann doch etwas spaet ...
naja. irgendwie wird bambi es schon machen und jedem recht wird keine
reihenfolge sein. wir werden sehen ;-)
schnurr
gingko

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



Re^8: Schaetzen fuer Anfaenger und Fortgeschrittene (Tassram, 13. Jul 2007, 22:58:10):
~#! rn=Gingko rt=1184355773 rg=gilden.katzenkrieger
~#! tid=1181908026
Ich weiss nicht, ob die Welt mit den D11en dunkler wurde, aber ich erinner
mich
noch dass ich zum ueben von Nachtsicht immer extra am Suchen von dunklen
Raeumen
war, da ich mich zu der Zeit noch lange nicht in so finsteren Ecken
herumtrieb.
Es ist schwer zu sagen, was die perfekte Reihenfolge ist, da das auch von den
persoenlichen Vorlieben abhaengt.
Meine persoenliche Vorliebe haette vermutlich zu
level 2  -  identifiziere
level 4  -  krallenschlag
level 6  -  schaetz
level 8  -  nachtsicht
gepasst, aber ich finde
level 2  -  krallenschlag/schaetz
level 4  -  schaetz/krallenschlag
level 6  -  identifiziere
level 8  -  nachtsicht
fuer die nicht so extrem forschintensive Allgemeinheit sinnvoll.
Bleibt noch zu klaeren ob es sinnvoll ist erst zuschlagen ohne Waffe zu lernen
bevor es noetig ist Gegener einzuschaetzen, oder wir die 'Kleinen' eben lehren
mit Waffen umzugehen.

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



Re^8: Schaetzen fuer Anfaenger und Fortgeschrittene (Zesstra, 14. Jul 2007, 01:43:55):
~#! rn=Gingko rt=1184355773 rg=gilden.katzenkrieger
~#! tid=1181908026
Mhmmm, mag jetzt voreilig sein, aber wenn ich mich an meine Zeit als Anfaenger
erinner, war die Moeglichkeit, im Dunkeln zu sehen bzw. das Dunkel hell zu
machen am Anfang fast am wichtigsten, wohingegen ich die ersten 10 Level
praktisch niemanden angegriffen hab (ausser HE).
Ueber Identfifiere liess ich mich ja schon aus. Spells aufzusplitten und
Infos/Faehigkeit je nach Erfahrung/Level freizuschalten faende ich da immer
noch ne Alternative, mit der man etwas flexibler ist als die bisherigen
Vorschlaege. Allerdings sehen dann die Luecken zwischen den Spells u.U. etwas
wilder aus, das muesste man passend dokumentieren.

Zesstra

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



Re^9: Schaetzen fuer Anfaenger und Fortgeschrittene (Darklor, 14. Jul 2007, 05:26:24):
~#! rn=Zesstra rt=1184370235 rg=gilden.katzenkrieger
~#! tid=1181908026
Ich waer fuer
Nachtsicht
Schaetz
Identifiziere
Krallenschlag

Nachtsicht passt ganz gut zu der "ersten" Quest bei den Felinen
Schaetz sollte auf jeden Fall vor Krallenschlag kommen, damit man ungefaehr
weiss, an wem man weniger gefaehrdet den Krallenschlag ueben kann
Identifiziere es gibt ja schliesslich nich ueberall zusaetzliche Informationen
Krallenschlag der erste Kampfskill kaem immer noch frueher als bei den AB's
(und es entspraeche so in etwa auch der Luecke bei den AB's fuer Nichfelinen
;))

Darklor (Menschenkatzenkrieger A.D.)

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



Re^10: Schaetzen fuer Anfaenger und Fortgeschrittene (Bambi, 14. Jul 2007, 10:40:50):
~#! rn=Darklor rt=1184383584 rg=gilden.katzenkrieger
~#! tid=1181908026
Gibt es grundsaetzliche Bedenken, wenn sich ein Neuspieler seine
Spellreihenfolge beliebig (unter den vier genannten!) aussuchen kann, ausser
dass er sich damit die "scheinbar unwichigeren" Spells nach hinten schiebt?

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



Re^11: Schaetzen fuer Anfaenger und Fortgeschrittene (Zesstra, 14. Jul 2007, 18:05:41):
~#! rn=Bambi rt=1184402450 rg=gilden.katzenkrieger
~#! tid=1181908026
Ich haette Bedenken, ob ein neuer Spieler eine ausreichende
Entscheidungsgrundlage hat, aufgrund der er entscheiden koennte.

Zesstra

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



Re^9: Schaetzen fuer Anfaenger und Fortgeschrittene (Maharet, 14. Jul 2007, 19:17:07):
~#! rn=Zesstra rt=1184370235 rg=gilden.katzenkrieger
~#! tid=1181908026
Es geht auch ohne Nachtsicht oder Lichtspell. Es gibt schliesslich Fackeln.
Bei den Kaempfern kuemmerst sich auch keiner drum, wie die bei den 4 elementen
klar kommen ;)

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



Re^10: Schaetzen fuer Anfaenger und Fortgeschrittene (Alkohol, 14. Jul 2007, 19:19:26):
~#! rn=Maharet rt=1184433427 rg=gilden.katzenkrieger
~#! tid=1181908026
es geht sogar viel zuverlaessiger, denn die fackeln laufen immer und licht und
nachtsicht klappen am anfang, wenn dringend benoetigt eh nie *g*

Alki

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



Re^10: Schaetzen fuer Anfaenger und Fortgeschrittene (Gloinson, 14. Jul 2007, 19:20:40):
~#! rn=Darklor rt=1184383584 rg=gilden.katzenkrieger
~#! tid=1181908026
Noch so eine Idee:
- Krallenschlag I und Krallenschlag II

Sprich, ident rutscht nach vorn, Krallenschlag bleibt wo es ist, ist aber
miauhaft schwach und bekommt erst weiter hinten die jetzt angedachte volle
Staerke ... sprich man bekommt nochmal einen kurzen Lala vom Gildenchef zum
Aufstieg, wie man das ordentlich zu machen habe.


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



Re^11: Schaetzen fuer Anfaenger und Fortgeschrittene (Shaeena, 14. Jul 2007, 22:46:39):
~#! rn=Gloinson rt=1184433640 rg=gilden.katzenkrieger
~#! tid=1181908026
Ich wuerde die Reihenfolge so lassen wie sie ist. Zumindest aber
Nachtsicht als ersten Spruch, ich fand den Spruch wirklich sehr
hilfreich und wuesste nicht, wieso man ihn nach hinten schieben
soll.
Krallenschlag koennte zugunsten von Schaetz nach hinten rutschen,
allerdings ergaebe sich dann das Problem, dass Identifiziere 
noch spaeter kaeme. Und den Krallenschlag noch weiter nach hinten
zu verschieben halte ich dann auch wieder fuer unsinnig, da es ja
immerhin die Katzen_krieger_ sind um die es geht und man sich
gerade als kleiner Spieler freut, wenn man das Karnickel dann 
auch mal haerter trifft als es zu kratzen.
Also warum gross rumtauschen, wenn es sowieso keine Idealloesung
gibt die alle super finden, die total schluessig ist und der 
Gilde den letzten Schliff verleiht?

Die Idee die Sprueche selber "lernfaehig" zu machen, also mit
zunehmendem Level besser, finde ich gut, denn die Katzenkrieger-
informationen bei Schaetz und Identifiziere sind fuer hoehere
Level doch eher duerftig.

Shaeena

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



Re^12: Schaetzen fuer Anfaenger und Fortgeschrittene (Croft, 14. Jul 2007, 22:51:17):
~#! rn=Shaeena rt=1184445999 rg=gilden.katzenkrieger
~#! tid=1181908026
Meine 2 cent: ID & ein Kampfspruch soweit es geht nach vorne damit die Spieler
auch mit ihren KP etwas anfangen koennen. Nachtsicht ist schoen und gut, aber
es geht auch ohne.

Croft

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



Re^13: Schaetzen fuer Anfaenger und Fortgeschrittene (Darklor, 15. Jul 2007, 00:41:49):
~#! rn=Croft rt=1184446277 rg=gilden.katzenkrieger
~#! tid=1181908026
Ne Fackel is ziemlich bloed, wenn sie irgendwo mitten im Dunkeln ausgeht...

Darklor

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



Re^14: Schaetzen fuer Anfaenger und Fortgeschrittene (Croft, 15. Jul 2007, 00:44:31):
~#! rn=Darklor rt=1184452909 rg=gilden.katzenkrieger
~#! tid=1181908026
Drum nimmt man auch 2 mit.  Pebkac und so.

Croft

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



Re^15: Schaetzen fuer Anfaenger und Fortgeschrittene (Darklor, 15. Jul 2007, 01:07:58):
~#! rn=Croft rt=1184453071 rg=gilden.katzenkrieger
~#! tid=1181908026
Genau, wo man die erst schon nur ganz knapp tragen kann...

Darklor

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



Re^16: Schaetzen fuer Anfaenger und Fortgeschrittene (Gloinson, 15. Jul 2007, 08:04:15):
~#! rn=Darklor rt=1184454478 rg=gilden.katzenkrieger
~#! tid=1181908026
Da hat er recht. Die Std-Fackel ist heftig schwer.


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



Re^17: Schaetzen fuer Anfaenger und Fortgeschrittene (Croft, 15. Jul 2007, 10:25:04):
~#! rn=Gloinson rt=1184479455 rg=gilden.katzenkrieger
~#! tid=1181908026
Das es Pakete gibt sollte man auch schnell lernen.

Croft

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



Re^18: Schaetzen fuer Anfaenger und Fortgeschrittene (Esme, 15. Jul 2007, 11:35:05):
~#! rn=Croft rt=1184487904 rg=gilden.katzenkrieger
~#! tid=1181908026
So, nun auch noch mein Senf dazu:
Ich finde Nachtsicht als erstes durchaus gut. Zum einen ist er nuetzlich, und
was ich wichtiger finde, passt das einfach zu einer Katze, in der Dunkeleheit
sehen zu koennen, sobald sie erst die Augen aufgemacht hat, ist also
finde ich einfach stimmiger.

Esme

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



Re^16: Schaetzen fuer Anfaenger und Fortgeschrittene (Ark, 15. Jul 2007, 22:13:01):
~#! rn=Darklor rt=1184454478 rg=gilden.katzenkrieger
~#! tid=1181908026
-> Gilden.Zauberer.


              *** ARK * the * Magnificent ***


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



Re: Ausweichen und "ende": bitte vorlaeufig nicht benutzen (Bambi, 15. Jul 2007, 23:25:31):
~#! rn=Zesstra rt=1184105961 rg=gilden.katzenkrieger
~#! tid=1184105961
Entwarnung. Zesstra hat einen Mudlib-Bugfix eingespielt, den ich gerade mit
dem Testspieler getestet habe. Soweit ich das sehe, sollte (nach Ende) nun
alles normal funktionieren.
Falls doch noch Unstimmigkeiten auftreten, bitte bei Zesstra oder mir melden.

Bambi.

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



Ideen (Endor, 21. Jul 2007, 06:15:35):
Wie waers denn mit einem neuen Zauber Kaetzchenmaunzen, wo man den Gegner mit
grossen Kaetzchenaugen ansieht und maunzt,
koennte den Gegner besaenftigen, funktioniert natuerlich nur bei kleinen
Kaetzchen. Dafuer koennte man schaetzen, krallenschlag nach hinten schieben.

Koennte man nicht Nachtsicht nach vorne schieben, dafuer eine Abneigung von
kleinen Kaetzchen gegen alles, was mit Feuer zu tun hat. Die Funken sind ganz
schlecht fuers Fell ...

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



Re: Ideen (Humni, 21. Jul 2007, 12:04:52):
~#! rn=Endor rt=1184991335 rg=gilden.katzenkrieger
~#! tid=1184991335
Hmm. Katzen haben schon Anfaelligkeiten... eigentlich auch genug... wobei mir
Feuer auch logischer vorkommen wuerde als die derzeitigen solchen. Wundert
mich sogar ein wenig, dass die das nicht haben - balancetechnisch gibts im MG
aber  viele Feuerviecher, das wuerde den Katzen (nicht nur den Katzenkriegern)
vermutlich echt weh tun..

Humni

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



Re: Re: Ideen (Shaeena, 21. Jul 2007, 13:11:40):
~#! rn=Humni rt=1185012292 rg=gilden.katzenkrieger
~#! tid=1184991335
Allerdings koennte man Feueranfaelligkeit besser ausgleichen
als es mit dieser bloeden Eisanfaelligkeit geht ;-)
Finde ich, allerdings sind wir ja Dschungel-Katzen, deswegen
ist eine Kaelte-Anfaelligkeit logischer als eine Hitze-
Anfaelligkeit, man sollte die Spiel-bezogenen Gruende nicht
mit den RL-Katzen-technischen durcheinander werfen.
Klar, Fell brennt gut, aber dann muesste man zwischen
Hitze und Feuer untscheiden und irgendwann fuehrt es
dann wohl ein bisschen zu weit...

Die Idee mit den grossen Augen find ich nett, da musste
ich sofort an den gestiefelten Kater von Shrek denken ;-)

Shaeena

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



Re^3: Ideen (Ark, 21. Jul 2007, 15:44:44):
~#! rn=Shaeena rt=1185016300 rg=gilden.katzenkrieger
~#! tid=1184991335
Da es Katzen sowohl in der Kaelte als auch in der Hitze gibt, plaediere ich
bei Katzenkriegern fuer die Faehigkeit "Anpassung", sprich, man kann (einmal
pro Woche oder so, jedenfalls langzeitig) sich resistenter gegen Kaelte oder
gegen Hitze hin- und herentwickeln. Vom Schneeleopard bis zum Panther, waere
das nichts?


              *** ARK * the * Magnificent ***


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



Re: Ideen (Gingko, 21. Jul 2007, 23:00:40):
~#! rn=Endor rt=1184991335 rg=gilden.katzenkrieger
~#! tid=1184991335
die idee mit dem kaetchenmaunzen find ich witzig. das waere was gegen
auto-attack gegner koennte ich mir vorstellen.
maunz Gingko.

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



Re: Re: Ideen (Ark, 21. Jul 2007, 23:17:45):
~#! rn=Gingko rt=1185051640 rg=gilden.katzenkrieger
~#! tid=1184991335
Also ich kann mir nicht vorstellen, dass Autoattacker sich vor einem
Fellbuendel fuerchten ... vielleicht habe ich nur begrenzte Phantasie, aber
das waere ein wenig des Guten zuviel :)


              *** ARK * the * Magnificent ***


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



Re^3: Ideen (Shaeena, 21. Jul 2007, 23:20:24):
~#! rn=Ark rt=1185052665 rg=gilden.katzenkrieger
~#! tid=1184991335
Wieso fuerchten? Mitleid haben :-)

Ich fand uebrigens die Idee mit dem "Wechseln" der Anfaelligkeit
etwas... albern? unangebracht?
Das ist ja als wuerde man sich jede Woche neu entscheiden, wo
man her kommt. Und die MG-Felinen kommen doch alle aus dem
Dschungel, oder hab ich was verpasst?

Shaeena

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



Re^3: Ideen (Liara, 21. Jul 2007, 23:21:50):
~#! rn=Ark rt=1185052665 rg=gilden.katzenkrieger
~#! tid=1184991335
Kindchenschema nennt man das, Ark. *g*

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



Re^4: Ideen (Gingko, 22. Jul 2007, 15:21:56):
~#! rn=Liara rt=1185052910 rg=gilden.katzenkrieger
~#! tid=1184991335
eben. kindchenschema. also ich kann mir schon vorstellen, dass die ihren
angriff beenden wenn man sie mitleidheischend anguckt. natuerlich nur, wenn
man keine waffe zueckt und so lange man noch keinen relevanten schaden
zugefuegt hat. damit ergibt es sich von allein, dass so ein spruch
uninteressant wird wenn man kein kleines kaetzchen mehr ist ;-)  und dann kann
er durch einen anderen ersetzt werden.

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



Re^5: Ideen (Maharet, 22. Jul 2007, 18:49:16):
~#! rn=Gingko rt=1185110516 rg=gilden.katzenkrieger
~#! tid=1184991335
Sorry, aber ich krieg das mit dem Kindchenschema bei 2m grossen Felinen nicht
hin. Wir reden hier nicht von Schosskaetzchen, sondern von Katzenkriegern.
Oder hatte ich da bisher ein zu edles Bild von den hiesige
Toxoplasmoseschleudern?

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



Re^6: Ideen (Liara, 23. Jul 2007, 00:17:38):
~#! rn=Maharet rt=1185122956 rg=gilden.katzenkrieger
~#! tid=1184991335
Ich bin uebrigens auch dagegen ... ich hatte das Kindchenschema nur als
Begriff auf Arks Artikel erwaehnt. Ansonsten schliesse ich mich Maharets
Argumentation voll an. :)

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



Re^4: Ideen (Ark, 23. Jul 2007, 00:39:48):
~#! rn=Shaeena rt=1185052824 rg=gilden.katzenkrieger
~#! tid=1184991335
Nerja, Winterhauch und Wasserstrahl sind ja typisch aus dem Dschungel? :-) Ist
nur ein Vorschlag, ich find den nicht unbedingt unpassend, damit kann man
darstellen, dass man als Katzenkrieger in vielerlei Terrain ueberleben kann.
Das mit dem Augenaufschlag (sorry, hatte ich wirklich missverstanden) ist wohl
eher was fuer blinde Kaetzchen, in den Stufen pflegt man im Allgemeinen noch
nicht auf boese Autoattacker zu stossen. Ganz nebenbei bin ich immer noch der
Meinung, dass dies fernab aller Ueberlegungen generell nicht besonders passend
ist, ausserdem eine zu starke Faehigkeit (aber das kann die entsprechende
Instanz entscheiden).


              *** ARK * the * Magnificent ***


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



Re^5: Ideen (Gnome, 23. Jul 2007, 01:15:08):
~#! rn=Ark rt=1185143988 rg=gilden.katzenkrieger
~#! tid=1184991335
viel zu stark.
man zuechtet sich ein kaetzchen ran, das man auf besagter stufe haelt,
skillt es dort hoch und schickt es durchs zaubererportal zu boesem monster.

die resis/anfaelligkeiten find ich persoenlich etwas seltsam gesetzt.
eigentlich sind jegliche art von raubkatzen sehr wasserscheu, auch wenn
sie aus dem dschungel kommen (0.1), kaelte ist ok (dringt durch ihr
mehr oder weniger dickes fell nicht so gut durch -> -0.1), aber was hat
saeure mit katzen zu tun? wenn man das fell noch miteinbeziehen wollte,
koennte man es als funkenanziehend/-anfaellig betrachten also blitz eher.

ich hab gerade auf der felinenseite gelesen, dass da mal clans geplant
waren? vielleicht koennte man die ausbauen und in diese clans dann den
vorschlag von ark integrieren. so schlecht fand ich den gar nicht.

gnOme

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



Re^6: Ideen (Darklor, 23. Jul 2007, 06:24:08):
~#! rn=Gnome rt=1185146108 rg=gilden.katzenkrieger
~#! tid=1184991335
Das Katzenwesen aus einem verregneten Dschungel kein Problem haben ist ja nun
nich gerad verwunderlich (Selbst unser Hauskater rennt schon mal bei Regen
raus wenn ihm danach ist, es draussen vllt interessanter is ;)) aber das mit
dem Eis hab ich nich so recht verstehen koennen, denn eins duerfte ja klar
sein, Wesen, die aus einem Warmen Gebiet kommen, duerfte die Kaelte nich
gerade behagen.

Die Idee mit den Clans fand ich schon als ich angefangen hab gut -
unterschiedliche (spielbare) Unterarten faend ich auch fuer andere Rassen
interessant...

Was sollte es eigentlich fuer einen Sinn haben einen kleinleveligen
Katzenkrieger in hochleveliges Autoattack-Gebiet zu bringen, wenn er dort dann
nix ausrichten kann? 

Darklor

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



Re^6: Ideen (Esme, 23. Jul 2007, 10:05:53):
~#! rn=Gnome rt=1185146108 rg=gilden.katzenkrieger
~#! tid=1184991335
Es sind nicht alle Raubkatzen wasserscheu. Zum Beispiel ist fuer Tiger mit
vollgefressenem Bauch, ein Fluss der dessen Gewicht ertraeglich macht
eine unverzichtbare Verdauungshilfe ;)

So, genug Unsinn geschrieben,
Esme

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



Re^7: Ideen (Vampire, 23. Jul 2007, 10:18:50):
~#! rn=Esme rt=1185177953 rg=gilden.katzenkrieger
~#! tid=1184991335
Wenn ich so an meine zwei Katzen denke, muss ich sowieso immer schmunzeln.
Wird bei uns zuhause der Wasserhahn benutzt kommen die Katzen angerannt und
spielen mit dem Wasser.

Miro

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



Re^8: Ideen (Gingko, 24. Jul 2007, 10:55:04):
~#! rn=Vampire rt=1185178730 rg=gilden.katzenkrieger
~#! tid=1184991335
hi
also das Vorurteil "Wasserscheu" trifft weder auf alle Hauskatzenindividuen
noch auf alle Raubkatzenarten zu. Wenn die meisten auch nicht freiwillig baden
gehen, gibts trotzdem genug Gegenbeispiele irL die wasserresistente
Dschungelfelinen rechtfertigen finde ich. Bei einem Ausbau der Clans find ich
Arks Idee in der Richtung verschiedene Schwerpunkte zu setzen aber auch
ziemlich reizvoll!
Was den Mitleidsaugenaufschlag anbelangt, so spricht wohl in der Tat zu viel
dagegen, auch wenn ich die Idee nach wie vor ziemlich witzig faend (aber
vielleicht ist sie das - zu witzig ;-)  Ach ja: Autoattack gegener trifft man
auch unter level 10 nicht zu selten, und dafuer braucht man nicht mal grosze
Quests anfangen. Mir fallen spontan z.B. die Schneehasen ein, oder der
Waechter in Moria (muss man da nicht auch fuer einfache ZT und die
Maerchenquest vorbei?)
schnurr. gingko.

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



Re^10: Erweiterung der Gildentitel (Gingko, 10. Aug 2007, 18:59:02):
~#! rn=Gingko rt=1179615470 rg=gilden.katzenkrieger
~#! tid=1178292601
So, genug gebrainstormt. Und gleich eine Entschuldigung: Das hier wird ein
SEHR langer Artikel, denn es folgt nun die Liste, der gesammelten Vorschlaege.
Sie sind in Bloecken sortiert zu den Spells zu denen sie passen wuerden bzw.
dazwischen dem etwaigen Levelbereich. 
Das mit dem (K... ) ist so gedacht, dass man Adjektive wie 'kratzbuerstig'
entweder mit Katze, Kater, Kaetzchen kombinieren kann, oder eben einfach so
als Titel verwenden kann: Der Kratzbuerstige. Ich hoffe, der Rest dieser Liste
erklaert sich einigermaszen von selbst. 
So, und damit das nicht nur als endlose Liste im Raum steht, sagt doch
vielleicht, welche Titel Euch besonders gut gefallen wuerden, oder was man aus
der Liste gleich rausschmeiszen kann ... und vielleicht inspirierts ja den ein
oder anderen zu einer genialen Titelidee ;-)
Genug der Worte, hier die Liste:

n
Die scharfe Kralle
Die Dornenpfote
Die Teufelskralle
Die Assasinenkralle
Die Todestatze
Die Assasinenkralle

Der/Die Katzenkrieger
Der/Die Kampfexperte

(ab hier K... = KaempferIn, (Katzen)kriegerIn)

  30 Katzenauge
der/die/das Sehende (K...)
der/die/das Erkennende (K...)
der/die/das Wissende (K...)
der/die/das Weitsichtige (K...)
der/die/das Scharfsichtige (K...)
Der/Die Spher/-in

der/die/das Kampferprobte (K...)
der/die/das Grosse (K...)
der/die/das Maechtige (K...)
der/die/das Erfahrene (K...)
der/die/das Weise (K...)
Der Schredderschreck
Der Herbstwanderer

  35 Winterhauch
der/die/das Frostige (K...)
Der/Die Paralysierer/-in
her/-inDer/Die Frostspr
Der/Die Frostsammler/-in
Der Winterwanderer

Der/Die angehende Katzenkrieger-Seher/-in

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



Re^11: Erweiterung der Gildentitel (Gingko, 10. Aug 2007, 19:02:39):
~#! rn=Gingko rt=1186765142 rg=gilden.katzenkrieger
~#! tid=1178292601
Mist. da ist beim Pasten was schief gegangen. Neuer Versuch:
(fuer den Anfang: K... = Kaetzchen)

der/die/das Blinde (K...)
der/die/das Kurzsichtige (K...)
der/die/das Tapsige (K...)
der/die/das Kleine (K...)
Der/Die Wollknaeuljaeger/-in
Das Fellkneul
Der Stubentiger

  02 Nachtsicht
der/die/das Sehende (K...)
Der/Die Dunkelschleicher/-in
Der/Die Nachtstreicher/-in
Der Dunkeltappser

  04 Krallenschlag
der/die/das Kratzbuerstige (K...)
der/die/das Kratzende (K...)
Der/Die Krallenwetzer/-in
Der/Die Krallenschrfer/-in
Der/Die Krallenschleicher/-in
Die Samtkralle

Der/Die Maeusejaeger/-in
Der/Die Revier(er)schleicher/-in
Der/Die Streuner/-in
Der Revierschreck

(ab hier: K... = Kater/Katze)

  06 Identifiziere / 08 Schaetz
der/die/das Aufmerksame (K...)
der/die/das Interessierte (K...)
der/die/das Wissbegierige (K...)
der/die/das Gewiefte (K...)
der/die/das Neugierige (K...)
der/die/das Neugierige (K...)
der/die/das Abschtzende (K...)
der/die/das Unternehmungslustige (K...)
Der/Die Beobachter/-in
Der/Die Entdecker/-in
Der/Die junge Forscher/-in
Der Analysierer

der/die/das Wanderk...
Der/Die Weltenbummler/-in
Der/Die Waldlaeufer
Der Wanderer

  10 Blitz
der/die/das Funkenspruehende (K...)
der/die/das Aufgeladene (K...)
Der/Die Gewitterbaendiger/-in
Der/Die Blitzbaendiger/-in
Der/Die Krallenblitzer/-in
Der Blitzableiter
Der Funkensprueher

  12 Ausweichen
der/die/das Geschickte (K...)
der/die/das Wendige (K...)
der/die/das Biegsame (K...)

Der erfahrene Waldlaeufer

  14 Pflanzenfessel
Der/Die Lianenschwinger/-in
Der/Die Pflanzendompteur/-dompteuse
Der/Die Pflanzenbaendiger/-in
Der/Die Fesselkuenstler/-in
Der/Die Kampfflorist/-in
Der/Die Faehrtensucher/-in
Die Floristenkralle

der/die/das Uebermuetige (K...)
der/die/das Wilde (K...)
der/die/das heranwachsende (K...)
der/die/das herangewachsene (K...)

  16 Wasserstrahl
der/die/das Tropfende (K...)
der/die/das Spritzige (K...)
Der/Die Wasserbaendiger/-in
Der/Die Gegen-den-Strom-schwimmer/-in
Der/Die Wasserwerfer/-in
Der/Die Wasserschleicher/-in
Der/Die Wasserkrieger/-in
Der/Die Wasserkaempfer/-in
Der Wasserverspritzer
Die Wasserpfote

Der/Die Jaeger/-in
Der/Die erfolgreiche Jaeger/-in
Der/Die Jagdexperte/-in
Der/Die Wildnisexperte/-in

  18 Schnell
der/die/das Flinke (K...)
der/die/das Schnelle (K...)
der/die/das Rasante (K...)
der/die/das Beschleunigte (K...)
der/die/das gestiefelte K...
Der/Die Wettlaufgewinner/-in
Der/Die Sprinter/-in
Der/Die Sprintlaeufer/-in
Der/Die Blitzlaeufer/-in
Der/Die flinke Jaeger/-in
Der Kampfschemen
Der Gepardenueberholer

  20 Blutwandlung
der/die/das Giftige (K...)
der/die/das Zaehe (K...)
der/die/das Medizink...
der/die/das Werk...
Der/Die Giftschleicher/-in
Der/Die Heilschleicher/-in
Der/Die Giftmischer/-in
Der/Die Toxikologe/-in
Der/Die Alchimist/-in
Der/Die Kurpfuscher/-in
Der/Die Medizinmann/-frau
Die Blubberpfote
Die Heilpfote
Die Giftpfote
Die Medizinpfote
Die Toxinpfote

Der/Die Katzenkriegernovize/-in
Der/Die angehende Katzenkrieger/-in
Der/Die Erwachende

  25 Todeskralle
der/die/das Schlitzgescheite (K...)
Der/Die Krallenschleifer/-in
Der/Die Krallenexperte/-in
Der/Die Krallenkaempfer/-in
Die scharfe Kralle
Die Dornenpfote
Die Teufelskralle
Die Assasinenkralle
Die Todestatze
Die Assasinenkralle

Der/Die Katzenkrieger
Der/Die Kampfexperte

(ab hier K... = KaempferIn, (Katzen)kriegerIn)

  30 Katzenauge
der/die/das Sehende (K...)
der/die/das Erkennende (K...)
der/die/das Wissende (K...)
der/die/das Weitsichtige (K...)
der/die/das Scharfsichtige (K...)
Der/Die Spher/-in

der/die/das Kampferprobte (K...)
der/die/das Grosse (K...)
der/die/das Maechtige (K...)
der/die/das Erfahrene (K...)
der/die/das Weise (K...)
Der Schredderschreck
Der Herbstwanderer

  35 Winterhauch
der/die/das Frostige (K...)
Der/Die Paralysierer/-in
Der/Die Frostsprueher/-in
Der/Die Frostsammler/-in
Der Winterwanderer

Der/Die angehende Katzenkrieger-Seher/-in


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



Echo-Spell freigegeben (Bambi, 29. Sep 2007, 12:04:09):
Hallo Katzenkrieger.

Nach langer Testphase wurde der neue Spell "echo" nun der Allgemeinheit der
Katzenkrieger zugaenglich gemacht. Besonderer Dank geht an Tassram und Simtur,
die den Spell auf Herz und Nieren geprueft haben, sowie an Humni fuer die
problemlose Abnahme.

Das Erlernen des Spells ist, im Gegensatz zu den anderen bisher in der Gilde
verfuegbaren Spells, an weitere Anforderungen gebunden als nur die Stufe und
den Seherstatus. Eine bestimmte Miniquest muss geloest werden, um den Spell
erlernen zu koennen. Zur Zeit ist das die FDO-Miniquest. Diese Quest ist aber
eigentlich nicht als Anforderung vorgesehen. Eine andere, leichtere Miniquest
ist in Arbeit, wird aber noch einige Zeit bis zur Vollendung benoetigen.
Sobald (falls jemals) die Lernanforderung umgestellt wird, gebe ich zeitnah
hier Bescheid.

Fuer Diskussionen und weitere Anregungen stehen die MPA und mein Postfach zur
Verfuegung.

Ich wuensche euch nun viel Spass mit eurem neuen Spell.

Bambi.

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



Re: Echo-Spell freigegeben (Ark, 29. Sep 2007, 13:21:47):
~#! rn=Bambi rt=1191060249 rg=gilden.katzenkrieger
~#! tid=1191060249
Wieviele sind das? *laester* :)


              *** ARK * the * Magnificent ***


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



Re: Re: Echo-Spell freigegeben (Bambi, 29. Sep 2007, 14:56:46):
~#! rn=Ark rt=1191064907 rg=gilden.katzenkrieger
~#! tid=1191060249
Aktive Katzenkrieger? Weiss ich nicht.
Aktive Katzenkrieger, die "aktiv" auf den Spell warten? Imho 1.

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



Re^3: Echo-Spell freigegeben (Humni, 29. Sep 2007, 15:02:55):
~#! rn=Bambi rt=1191070606 rg=gilden.katzenkrieger
~#! tid=1191060249
Kurze Anmerkung von mir als Gildenbalance: Der Spell ist interessant, IMHO
recht maechtig, aber nicht zu maechtig. Man muss sich einigermassen auskennen,
um ihn sinnvoll einsetzen zu koennen. Die Einschraenkungen sind nicht zu
verachten, und dass er eine nicht ganz triviale Vorquest hat passt auch dazu.
Ich denke, dass er die Katzen ein Stueck attraktiver, aber keinesfalls
uebermaechtig macht.

Humni

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



Nachtsicht (Humni, 20. Okt 2007, 11:05:36):
Huhu,

aufgrund eines Bugs bin ich nicht sicher, ob Eure Nachtsicht noch
funktioniert. Hab das notduerftigste gefixt (ihr solltet jetzt wieder
ueberhaupt was sehen). Um den Rest wird sich gekuemmert, wenn Bambi da ist
oder jemand sonst Zeit hat.

Gruesse
Humni

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



Winterburgfolgen (Bambi, 26. Nov 2007, 23:42:02):
Hallo Gilde.

Das Jahr neigt sich dem Ende zu und eine sehr interessante Winterburg-Party
hat vor wenigen Tagen stattgefunden. Auch wenn es sich zunaechst "nur" um ein
nettes RL-Treffen handelt, hat dieses Wochenende ein paar interessante
Auswirkungen auf unsere Gilde gehabt. 

Zum einen wurde der umstrittene Spruch "blutwandlung" abgeschafft. Die
Entgifte-Wirkung war teurer und schwaecher als die Questbelohnung im
Duesterwald, die allen anderen schon immer offenstand. Die unterstuetzende
Wirkung auf den Giftdolch lag aufgrund der zu geringen Wirkung ungenutzt
brach. Der Spell war damit effektiv ein reiner Malus fuer die Gilde.

Mit gildenerzmagierlicher Genehmigung habe ich daher vor ein paar Minuten den
entgifte-Spell als Duesterwald-Questbelohnung auch fuer Katzenkrieger
freigeschaltet.

Der bisher geuebte Blutwandlung-Skill wird nicht auf den entgifte-Skill
uebertragen. Wer darueber jammert, darf seine Gilde wechseln und bei den
Zauberstabschwingern anheuern.


Ein weiterer Punkt auf der Liste zu verkuendender Neuerungen stellt die
Tatsache dar, dass das Gildenspellbook um einen hoffentlich dem Flair
entsprechenden neuen Spell erweitert wird. Ab Level 20 findet sich nun
anstelle von Blutwandlung ein Idle-Spell, der automatisch mit 100% beherrscht
wird. Sobald die letzten Tests erfolgreich abgeschlossen sind und Humni sein
endgueltiges OK gibt, wird er dokumentiert und angeschlossen.

Bis dahin wuensche ich euch froehliches Mudden und viel Spass mit dem
entgifte-Spell-ueben.

MfG, Bambi.

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



Re: Winterburgfolgen (Bambi, 26. Nov 2007, 23:45:49):
~#! rn=Bambi rt=1196116922 rg=gilden.katzenkrieger
~#! tid=1196116922
Bei den Umstellungsarbeiten fielen uebrigens zwei Sachen auf.

1. Im ausweichen-Spell gab es einen klitzekleinen Bug, der sich nicht auf das
Ausweichen an fuer sich, wohl aber auf die moegliche Cast-Haeufigkeit
auswirkte. Der Bug wurde nebenbei behoben.
2. Der Nachtsichtskill wurde technisch bereinigt. Das hat zur Folge, dass
(theoretisch) nur noch der Gildenskill beruecksichtigt wird, nicht mehr aber
allgemeine Nachtsichtskills. Da vermutlich nur die Dunkelelfen-Rasse so etwas
besitzt und bei uns nicht eintreten kann, ist das nur theoretisch ein Problem.
Sollte trotzdem jemandem etwas auffallen, gebt mir bitte Bescheid.

Bambi.

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



Gildentitel (Bambi, 26. Nov 2007, 23:58:05):
Hallo.

Seit jetzt hat die Gilde neue Titel. Die Liste wurde auf 38 erhoeht und im
Wesentlichen in ihrer Benennung dem Spell angepasst, der zuletzt erlernt
werden konnte. Ab Level 38 gilt man im Titel als Seher.

MfG, Bambi.

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



Re: Gildentitel (Bambi, 26. Nov 2007, 23:59:38):
~#! rn=Bambi rt=1196117885 rg=gilden.katzenkrieger
~#! tid=1196117885
Besonderer Dank geht uebrigens an Gingko und Ravina, die die Liste erstellt,
gepflegt, mit Alternativvorschlaegen erweitert und zur Winterburgparty
mitgebracht haben.

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



Re: Winterburgfolgen (Gnome, 28. Nov 2007, 01:49:59):
~#! rn=Bambi rt=1196116922 rg=gilden.katzenkrieger
~#! tid=1196116922
gab es nicht die moeglichkeit, blutwandlung besser zu machen als gleich
abzuhaengen?
entgiften koennen die kleris ja schliesslich auch besser als der rest.
warum das also nicht fuer die KK auch so handhaben?

gnOme

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



Re: Re: Winterburgfolgen (Bambi, 28. Nov 2007, 11:54:08):
~#! rn=Gnome rt=1196210999 rg=gilden.katzenkrieger
~#! tid=1196116922
Es gab mehrere Anlaeufe, Blutwandlung attraktiv zu machen. Sie sind alle
gescheitert. Letztendlich war es auch nicht erwuenscht, dass die Katzenkrieger
in dieser Hinsicht wesentlich besser werden. Der Spell haette seine
Daseinsberechtigung gehabt, wenn nicht jeder einzelne Spieler den
Kleriker-Spell haette lernen koennen. In welcher Reihenfolge die
Spelleinfuehrung (blutwandlung) und die Spellfreigabe (kleriker-entgifte fuer
fast alle) kam, weiss ich nicht. Ich persoenlich stehe auf dem Standpunkt,
dass man das entgifte fuer alle wieder haette rueckgaengig machen
sollen/koennen, das fand aber (auch unter (Erz-)Magiern) keine Mehrheit. Damit
kann ich auch leben und bin mit dem Kompromiss zufrieden. Ich hoffe nur, dass
zukuenftig keine "wesentlichen" Gildenspells als Questbelohnung mehr verwendet
werden.

Bambi.

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



Re^3: Winterburgfolgen (Zesstra, 28. Nov 2007, 12:03:49):
~#! rn=Bambi rt=1196247248 rg=gilden.katzenkrieger
~#! tid=1196116922
Waehrend ich ebenfalls auf dem Standpunkt stehe, dass ich die Nutzung eines
Gildenspells durch fast alle alle anderen nicht sonderlich mag, ist es doch
sehr problematisch, das Rad in dieser Hinsicht zurueckzudrehen. Magier gehen
nicht zuletzt deshalb mit dem Vergiften von Spielern relativ grosszuegig um,
weil (fast) alle eine einfache Moeglichkeit des Entgiftens haben und es
deshalb weitgehend unproblematisch ist. Entzieht man nun einem Grossteil der
Spieler diese Faehigkeit, ist es vermutlich noetig, eine ganze Reihe von
Vergiftungen zu pruefen und ggf. zu entschaerfen, wofuer sich sicher keiner so
richtig haette begeistern koennen. Ansonsten waere das eine Moeglichkeit
gewesen.

Zesstra

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



Re^4: Winterburgfolgen (Grimmborn, 28. Nov 2007, 12:44:31):
~#! rn=Zesstra rt=1196247829 rg=gilden.katzenkrieger
~#! tid=1196116922
Genau. Am Ende waeren die Spieler noch gezwungen sich an andere Spieler zu
wenden, weil nichtmal der Zweitie anstaendig entgiften kann. Das wollen wir
doch unter allen Umstaenden vermeiden!

GdA

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



Re^5: Winterburgfolgen (Derin, 28. Nov 2007, 14:40:33):
~#! rn=Grimmborn rt=1196250271 rg=gilden.katzenkrieger
~#! tid=1196116922
Huhu,

Dir ists noch nie passiert, dass Dir sowas nachts um zwei passiert, wo kaum
noch eine Seele eingeloggt ist? Mir schon oft.

Derin.

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



Re^6: Winterburgfolgen (Gloinson, 28. Nov 2007, 16:12:05):
~#! rn=Derin rt=1196257233 rg=gilden.katzenkrieger
~#! tid=1196116922
Mahlzeit,
mir faellt da "normative Kraft des Faktischen" zu ein.

Einerseits: Gift ist nicht so schlimm wie es scheint. Selbst eine maximale
Vergiftung rafft den normalen Spieler nicht in 60 Sekunden hinfort.
Darin und in dem CoOp-Gedanken sehe ich den eigentlichen Grund, dass mit
Standard-Gift immer locker umgegangen wurde. Schwank aus meiner Jugend: einer
meiner allerersten Tode war, von dem Skorpiongift (suedlich PV) getoetet zu
werden. Ich habs ueber die Schulter eines groesseren Spielers gelesen, den ich
gerade um Hilfe bitten wollte. Zu dessen Rechner musste ich erstmal hingehen.

Andererseits: CoOp ist wegen Spielerschwunds oft out, manchmal ist es zwei Uhr
nachts, Heil-NPCs sind nicht immer bekannt und teuer, Ausweichmoeglichkeiten
(wie sie jeder waehrend der Abhaengung des "entgifte" dank des
Skriptabenteuers ... siehe Archiv ... bei sich trug) unbekannt. Entgifte hat
sich halt (wieder) billig durchgesetzt.
Blutdingsda? Giftschwaechung? Sind damit einfach unnuetz. Siehe erster Satz
dieses Artikels.

Was man machen kann? Krankheiten und Gifte standardisieren, nutzen und dann
solche Spells wieder aufleben lassen. In etwa in der Reihenfolge. Besteht kein
Interesse an ein Giftepalette, dann besteht auch kein Spielerbedarf an
spezialisierten Giftheilungsspells.


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



Re^3: Winterburgfolgen (Ark, 28. Nov 2007, 19:54:19):
~#! rn=Bambi rt=1196247248 rg=gilden.katzenkrieger
~#! tid=1196116922
Naja, entgifte fuer alle gibt es nicht erst seit Duesterwald, urspruenglich
war das mal Questbelohnung von einer Quest auf Aurora, die abgehaengt wurde.
Nimm den ganzen Spielern diesen Skill -> Aufruhr, Koenigsmord, Goetterzorn.
Ich haette da auch meine Haende in Unschuld gewaschen. Und dann ueberarbeite
mal alle Monster, die nicht unbedingt vergiften muessen ... die sind mit dem
Unbedenklich-Hinweis auf "jeder hat es" entstanden, sei dessen gewiss.
Insofern ist der Ansatz durchaus ok.


              *** ARK * the * Magnificent ***


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



Re^5: Winterburgfolgen (Ark, 28. Nov 2007, 19:56:28):
~#! rn=Grimmborn rt=1196250271 rg=gilden.katzenkrieger
~#! tid=1196116922
Jaja, Polemik ole :-) Der Feinsinn fuer das Machbare verliert sich recht
schnell im nichtspielenden Magiervolk, nein?


              *** ARK * the * Magnificent ***


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



Re^6: Winterburgfolgen (Grimmborn, 28. Nov 2007, 21:41:33):
~#! rn=Ark rt=1196276188 rg=gilden.katzenkrieger
~#! tid=1196116922
Aeh, nein? Sicher, Leute, die dann spielen wenn sie hier alleine sind lasse
ich ja gelten, aber dann muss man halt lernen dass man nicht immer zu jeder
Zeit alles machen kann. Sicher ist es moeglich einen Heiler zu basteln, der
"teuer" genug ist um Mitspieler vorzuziehen, aber dennoch erreichbar. 

GdA

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



Re^7: Winterburgfolgen (Kessa, 29. Nov 2007, 01:06:05):
~#! rn=Grimmborn rt=1196282493 rg=gilden.katzenkrieger
~#! tid=1196116922
Der Punkt ist, wenn ich es richtig verstehe, dass Vergiftungen durch Items/NPC
wegen der nun einmal zustandegekommenen allgemein zugaenglichen
Entgifte-Faehigkeit als recht unproblematisch eingestuft werden. Das ist ein
Stueck Mud-Geschichte, das wohl nicht mehr aus der MUD-Welt zu kriegen ist.
Dass die KK, um entgiften zu koennen, einen eigenen Spell zu lernen hatten,
war eine indirekte Abwertung der Gilde, da sie 1. es damit schwerer hatten als
andere und 2. damit eine moegliche andere Gildenfaehgikeit blockiert wurde.
Bambis Vorschlag scheint mir darum sinnvoll und konsequent (also generell das
Entgiften durch eine andere Gildenfaehigkeit zu ersetzen, wenn ich auch noch
keinen Schimmer habe, was wohl hinter dem neuen Skill steckt :)). Bin mal
gespannt.

Gruss, Kessa

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



Re^8: Winterburgfolgen (Bambi, 29. Nov 2007, 13:07:14):
~#! rn=Kessa rt=1196294765 rg=gilden.katzenkrieger
~#! tid=1196116922
(quote) 
wenn ich auch noch keinen Schimmer habe, was wohl hinter dem neuen Skill
steckt 
(/quote) 
Die Katzenkrieger koennen jetzt besser idlen als andere. 


@topic: 
Mir sind die meisten Argumente fuer und gegen ein entgifte fuer alle bekannt.
Ich schwinge auch nicht die Fahne, dass das jetzt ubedingt geaendert werden
muss. Trotzdem bin ich eher der Fraktion zuzuordnen, die lieber anstatt des
Kleriker-Spells eine weit schwaechere Variante fuer alle vorziehen wuerde, um
zum Beispiel die Kleriker dadurch aufzuwerten und Gift als Komponente etwas
interessanter zu machen. 

Die Aenderung der Katzenkriegergilde wurde initial dadurch ausgeloest, dass
jeder Popel-Kaempfer (TM) unglaeubig nachgefragt hat, wenn Katzenkrieger an
bestimmten Stellen wie die Fliegen an Gift gestorben sind, weil eben davon
ausgegangen wird, dass jeder Spieler (ab einer gewissen Entwicklungsstufe)
Gift praktisch ignorieren kann. 

Diese Entwicklung zurueckzudrehen ist weder meine Forderung noch meine
Intention. Von daher bin ich auch ganz froh, dass das Thema "Blutwandlung" nun
endgueltig vom Tisch ist. 


Bambi.

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



Re^9: Winterburgfolgen (Gnome, 30. Nov 2007, 14:06:48):
~#! rn=Bambi rt=1196338034 rg=gilden.katzenkrieger
~#! tid=1196116922
aber eine deutlich verbesserte version von blutwandlung haette die KK
doch aufgewertet und sie in dem punkt den klerikern mindestens
gleichgestellt.
fuer mich ist ein "naturnaher" spell (blutwandlung) fuer eine natuerliche
sache (vergiftung) viel stimmungsvoller als ein schnoedes "entgifte".

generell sollten gildenspells deutlich staerker gestaltet werden als
ihre pendants in form von questbelohnungen, wenn es denn ueberhaupt zu
solchen ueberschneidungen kommen muss.

gnOme

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



Re^10: Winterburgfolgen (Ark, 30. Nov 2007, 17:38:27):
~#! rn=Gnome rt=1196428008 rg=gilden.katzenkrieger
~#! tid=1196116922
Ja. Aaaaber: Du musst das Gekreisch "MG jetzt unspielbar", "ich hoer auf",
"Altspieler benachteiligen", "hat sich deshalb geloescht", "komme nicht mehr
wieder" auch nicht anhoeren. Insofern: kleineres Uebel. Room for improvement
still there.


              *** ARK * the * Magnificent ***


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



Re^11: Winterburgfolgen (Gnome,  1. Dez 2007, 02:02:22):
~#! rn=Ark rt=1196440707 rg=gilden.katzenkrieger
~#! tid=1196116922
das verstehe ich jetzt nicht.

ich habe mit keinem wort gesagt, dass man das entgifte fuer alle
abhaengen sollte, sondern lediglich fuer die KK deutlich maechtiger.
ist naemlich schon ein wenig albern, fuer eine entgiftung zu einem
kleriker zu duesen, wenn man den spruch als *gilden*skill eigentlich
selber zur verfuegung stehen hat.

aber so ist es ja jetzt auch... elegant geloest und die kleriker werden
weiterhin ihrem zweitieruf gerecht bleiben. so gehoert sich das.

gnOme

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



Re^12: Winterburgfolgen (Gloinson,  1. Dez 2007, 02:40:58):
~#! rn=Gnome rt=1196470942 rg=gilden.katzenkrieger
~#! tid=1196116922
> kleriker ... zweitieruf

Man muss nicht unbedingt Zweitie sein, um zu helfen. Oder wie viele Trves sind
Zweities, weil man sie ganz prima zuecken kann?

Anderer Thread.


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



Idle-Goetter (Bambi,  1. Dez 2007, 16:16:50):
Hallo alle.

Der doese-Spruch ist nun von Humni abgenommen worden und der Oeffentlichkeit
(sprich: Katzenkriegern ab Level 20) zugaenglich. Es gibt in der Bibliothek
einen Eintrag zum neuen Spell. Ausserdem habe ich fuer jeden
Katzenkrieger-Spell eine Kurzfassung als Hilfe-Eintrag erstellt. Die Betonung
liegt hierbei auf _Kurzfassung_. Die ausfuehrlicheren Varianten findet man
nach wie vor in der Bibliothek. 

Die Webseite ist nicht auf dem aktuellen Stand und sollte daher nur als
Notloesung verwendet werden.

Ich wuensche euch viel Spass mit dem neuen Spell.

Bambi.

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



Re^10: Idee Kaempferfaehigkeit (Gloinson,  6. Sep 2008, 00:11:49):
~#! rn=Esme rt=1220652658 rg=gilden.chaos
~#! tid=1220646566
Katzen kotzen kratziges Kloputzgewoelle!


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



Re^11: Idee Kaempferfaehigkeit (Darklor, 14. Sep 2008, 05:57:54):
~#! rn=Gloinson rt=1220652709 rg=gilden.katzenkrieger
~#! tid=1220646566
Katzen fuehren mit "aufmunterndem" Loewengebruell in die Schlacht ;)

Darklor

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



Re^12: Idee Kaempferfaehigkeit (Lug,  5. Nov 2008, 20:42:08):
~#! rn=Darklor rt=1221364674 rg=gilden.katzenkrieger
~#! tid=1220646566
Katzen ergeben gute Rheumadecken, nachdem man sie durch den Schredder gejagt
hat...



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



Goblins, willkommen. (Bambi, 23. Mai 2009, 14:45:03):
Hallo.

Xelonir laesst nun auch Goblins bei den Katzenkriegern eintreten. Bei Bedenken
wendet euch direkt an ihn oder gegebenenfalls an mich.

Bambi.

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



PK fuettern (Caldra,  2. Apr 2010, 20:49:48):
Mahlzeit!

falls jemand in den letzten Tagen seinen PK fuettern wollte und daran
gescheitert ist ... jetzt geht es wieder ... dank an Zook :-)

Caldra

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



Re: PK fuettern (Bambi, 17. Apr 2010, 07:16:08):
~#! rn=Caldra rt=1270234188 rg=gilden.katzenkrieger
~#! tid=1270234188
Von mir auch. Ich war leider ziemlich beschaeftigt und waere erst heute morgen
dazu gekommen.

Gruss, Bambi

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



Bugfix bei "schleichen" (Bambi, 10. Jun 2010, 09:56:28):
Hi.

Wer Probleme hatte, dass er trotz schleichen Dresche kriegt, ich habe da einen
kleinen Bug gefixt, der seit einiger Zeit haette auftreten muessen.

Bambi

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



Garfield (Maharet, 12. Aug 2010, 10:27:28):
Fuer Euch:

http://garfield.com/comics/vault.html?yr=2008&addr=080424

;)
Maha

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



wissenschaftliche Kurzmeldung (Caldra, 25. Sep 2011, 19:00:29):
Hallo Ihr Lieben,

nach jahrelanger Forschung ist es mir endlich gelungen, die geheimnisvollen
Kraefte der Talafaer zu kanalisieren und in einer interessanten neuen
Lebensform zu fixieren. Wenn ihr Euch dafuer interessiert, kommt mich doch
einfach in den Fiebersuempfen auf Akhar Nth'Tar besuchen

Eamane Lossehelin

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



Pflanzenkrieger und Teams (Zesstra,  2. Sep 2012, 23:34:24):
Eure Pflanzenkrieger sollten es wieder in die Teams schaffen.

Zesstra

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



Re: Pflanzenkrieger und Teams (Bambi,  5. Sep 2012, 00:22:18):
~#! rn=Zesstra rt=1346621664 rg=gilden.katzenkrieger
~#! tid=1346621664
Danke.

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



Diskussion: Orks in der Gilde? (Bambi, 20. Feb 2013, 20:50:05):
Hi.

Nachdem es eine neue Spielerrasse (Orks) im MG gibt, moechte ich gerne eine
Diskussion anregen, ob es aus eurer Sicht sinnvoll ist, dass Orks in die KKG
eintreten bzw. nicht eintreten duerfen.

Bambi

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



Re: Diskussion: Orks in der Gilde? (Ark, 20. Feb 2013, 20:58:38):
~#! rn=Bambi rt=1361389805 rg=gilden.katzenkrieger
~#! tid=1361389805
Krallenschlag? Sieht komisch aus. Pflanzenfessel? Oeko-Orks. Oerks :)


              *** ARK * the * Magnificent ***


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



Re: Re: Diskussion: Orks in der Gilde? (Vector, 20. Feb 2013, 21:00:16):
~#! rn=Ark rt=1361390318 rg=gilden.katzenkrieger
~#! tid=1361389805
nicht-felinen koennen keinen krallenschlag und keine todeskralle, 
also andere rassen (mit einschraenkung) warum nicht bei den KK?
aus der unschoenen situation bei den dunkelelfen (nur die d11-gilde)
sollte man doch gelernt haben dass komplettes aussperren von rassen
bei gilden dauerhaft unschoen ist

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



Re^3: Diskussion: Orks in der Gilde? (Ark, 20. Feb 2013, 21:12:03):
~#! rn=Vector rt=1361390416 rg=gilden.katzenkrieger
~#! tid=1361389805
Naja, Hobbits mit Todeskralle ... nur weil man ner Gilde beitritt, wachsen
einem doch nicht gleich Krallen. Okok, Werwoelfe, sagt nix, aber ist nur
bedingt vergleichbar :-) Ist nur meine Meinung, ueberzeugen ist zwecklos :-P


              *** ARK * the * Magnificent ***


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



Re^4: Diskussion: Orks in der Gilde? (Vector, 20. Feb 2013, 21:14:20):
~#! rn=Ark rt=1361391123 rg=gilden.katzenkrieger
~#! tid=1361389805
gegen die einschraenkungen innerhalb der gilde hab ich ja nix,
und ausser felinen kann keine rasse dort krallenschlag oder
todeskralle. ich finds nur doof das man die d11 zwingt in der
gilde zu bleiben und die keinerlei auswahl haben.
dunkelelfen bei trves, zaubis, chaoten, karate finde ich 
durchaus vorstellbar

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



Re^5: Diskussion: Orks in der Gilde? (Humni, 20. Feb 2013, 23:05:24):
~#! rn=Vector rt=1361391260 rg=gilden.katzenkrieger
~#! tid=1361389805
Aus Balance-Sicht ist mir das voellig egal. Eben, weil viele der Spells nicht
(richtig) gehen. Nur mal so. Das darf Bambi also gerne komplett allein
entscheiden.

Humni

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



Re^6: Diskussion: Orks in der Gilde? (Ark, 20. Feb 2013, 23:13:19):
~#! rn=Humni rt=1361397924 rg=gilden.katzenkrieger
~#! tid=1361389805
Ich finde es uebrigens ueberhaupt nicht tragisch, wenn man Rassen von Spells
oder der ganzen Gilde aufgrund von Logik odverbietet. Es gibt doch damit noch
mehr Gewicht fuer eine bestimmte Rasse ausser den marginal anderen Stats.


              *** ARK * the * Magnificent ***


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



Re^7: Diskussion: Orks in der Gilde? (Darklor,  4. Mai 2013, 11:24:23):
~#! rn=Ark rt=1361398399 rg=gilden.katzenkrieger
~#! tid=1361389805
Wenn Menschen zu den Katzenkriegern koennen, warum nich auch Orks? Haben Orks
nich sogar eher Krallen als Menschen? ;) Aber warum sollte ein Ork zu den
Katzenkriegern gehen wollen? Ist ihre eigene Gilde sogar noch schwaecher, als
die der Katzenkrieger?

Darklor

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



Re^8: Diskussion: Orks in der Gilde? (Bambi,  9. Mai 2013, 12:04:23):
~#! rn=Darklor rt=1367659463 rg=gilden.katzenkrieger
~#! tid=1361389805
Ich kenne die Ork-Gilde nicht, daher kann ich keinen Kampfkraft-Vergleich
anstellen. Ob die Kampfkraft der einzige Grund fuer oder gegen eine Gilde ist,
muss jeder fuer sich entscheiden.

Nach den bisherigen Stimmen, wurde ich nicht aktiv. Sprich: Die Orks koennen
nach der aktuellen Regelung keine KK werden und ich habe aktuell auch nicht
vor, das zu aendern.

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



Erkennen von Pflanzenkriegern als Spielerhelfer (Zesstra, 10. Nov 2013, 22:09:24):
Eine Reihe von NPC, bei denen es wichtig ist, wer sie umgehauen hat, koennen
den Katzenkrieger, der einen Pflanzenkrieger kontrolliert, jetzt (bzw. evtl.
nach Neuladen/Reboot) erkennen.
(Das gilt nicht fuer EKs.)

Davon profitieren evtl. auch andere Gilden/helfende Begleiter.

Zesstra

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



Neuer Name fuer Echo (Humni, 26. Jul 2018, 14:37:31):
Hallo ihr,

die Gilden-Faehigkeit "echo" blockiert das Shellkommando, das man als
Questbelohnung bekommt. "Gluecklicherweise" so herum, dass der Gildenspruch
funktioniert. Dennoch sollte man das aendern.

Richtg ist hier, kein zusaetzliches Spielerkommando zu definieren, sondern den
Gildenspruch umzubenennen. Dazu brauchen wir Vorschlaege, wie er heissen soll.

Eine Moeglichkeit waere "echoschlag". Alternativ diskutiert werden
"retourkutsche", "plagiat", "imitat", "imitiere", "repro", "klon",
"guttenberg", "rueckschlag" und "wiedumirsoichdir".

Sicher sind die nicht alle gleich gut. Schreibt doch mal, was ihr meint -
gerne auch neue Ideen.

Humni

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



Re: Neuer Name fuer Echo (Chagall, 26. Jul 2018, 14:45:35):
~#! rn=Humni rt=1532608651 rg=gilden.katzenkrieger
~#! tid=1532608651
Ich stimme fuer wiedumirsoichdir.

MC

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



Re: Re: Neuer Name fuer Echo (Ark, 26. Jul 2018, 15:26:50):
~#! rn=Chagall rt=1532609135 rg=gilden.katzenkrieger
~#! tid=1532608651
"soeder", "bambi" (echo ist ja auch ein preis), "widerhall", "hall", "oche"
(laesst sich eh besser tippen), "cheo" (gleichberechtigt mit "oche").


              *** ARK * the * Magnificent ***


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



Re^3: Neuer Name fuer Echo (Brzfttl, 26. Jul 2018, 17:09:22):
~#! rn=Ark rt=1532611610 rg=gilden.katzenkrieger
~#! tid=1532608651
spiegel


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



Re^4: Neuer Name fuer Echo (Amaryllis, 26. Jul 2018, 21:39:19):
~#! rn=Brzfttl rt=1532617762 rg=gilden.katzenkrieger
~#! tid=1532608651
"kollegah", "farid", "fahridbang", "bang"...

Ama*

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



Neuer Name fuer Echo (ernst gemeint) (Smeraldina, 22. Okt 2018, 05:04:07):
Hallo, ihr Lieben,
mir gefaellt spiegeln sehr gut, dafuer muss man nicht Meister
imSchnellschreiben
sein und es ist bildhaft.
Ich finde allerdings, dass man die Vorraussetzung fuer diesen Spruch
vielleicht
doch ein klein wenig vereinfachen sollte. Ich verlange den ja nicht fuer
umsonst,
aber selbst im fuenferteam bin ich letztes Jahr beim versuch mehrfach
gescheitert, was sehr demotiviert. Vielleicht irgendwas langwieriges aber
schaffbares im Minolab oder so.
Ganz liebe Gruesse: smeraldina

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



Re: Neuer Name fuer Echo (ernst gemeint) (Bambi, 22. Okt 2018, 11:27:02):
~#! rn=Smeraldina rt=1540177447 rg=gilden.katzenkrieger
~#! tid=1540177447
Ich wuerde katzenecho nehmen, das bleibt am naechsten am urspruenglichen
Namen.
Die Umbenennung koennte aber aufwaendiger sein als erwartet. Das muss ich mal
mit Humni klaeren.

Was meinst du mit "scheitern" im Rahmen der Spellanwendung? Schick mir dazu
doch ne Mail.

Bambi

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



Gelernte Pflanzenkrieger-Varianten (Bambi, 11. Jan 2020, 01:21:53):
Hi,
aufgrund eines Implementierungsfehlers vergass das dafuer zustaendige Objekt
trotz Savefile, wer welche Pflanzenkrieger-Varianten gelernt hatte. Arathorn,
Humni, Zesstra und ich haben uns das mal angeschaut und den Fehler behoben.
Ausser dass das Objekt nun nicht mehr vergisst, wer welche Variante gelernt
hat, weiss es nun auch rueckblickend fuer die letzten ~11 Jahre, wer welche
Variante bereits beherrschte. Es gibt eine theoretische Ausnahme, von der wir
ausgehen, dass sie tatsaechlich nicht aufgetreten ist. Das waere gewesen, wenn
zwei Crashes oder Reboots am gleichen Tag stattgefunden haben und zwischen
diesen beiden Zeitpunkten jemand eine PK-Variante gelernt hatte, nach dem
zweiten Reboot (bis heute) aber nicht mehr.

Sollte euch irgendetwas seltsames auffallen, zum Beispiel dass ab heute
gelernte PKs nach dem Reboot doch wieder neu gelernt werden muessen, gebt
einfach Bescheid.

Bambi

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



Echo (Bambi,  8. Mar 2020, 20:30:43):
Hi,

nachdem der Echo-Spell aufgrund seiner Eigenschaft als HP-SP-Blocker kaum bis
keine Anwendung fand, hat Humni sein OK gegeben, dass die ersten 25
Aufladungen keine HP und keine SP mehr blocken. Falls euch bezueglich des
Einsatzes irgendetwas auffaellt, gebt bitte Bescheid.

Und opfert dem Drachen bitte ein paar gebratene Jungfrauen. Oder Bier. Bier
soll helfen.

Bambi

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



Teamkampf (Bambi, 22. Mar 2020, 22:36:48):
Hi,

in Absprache mit Humni habe ich (zunaechst testweise) eine
Teamkampf-Verbesserung eingebaut.

Immer dann, wenn ihr einen eurer Kampfzauber (Blitz, Krallenschlag,
Todeskralle, Wasserstrahl, Giftdolch, Winterhauch) (aber nicht Echo) auf einen
Gegner castet und dabei in einem Team seid, erhalten andere Katzenkrieger in
eurem Team einen kleinen Schadensbonus auf den naechsten von ihnen auf dieses
Ziel gecasteten Angriffszauber.
Dass ihr den Bonus erhaltet, seht ihr an einer Meldung, die zusaetzlich zur
normalen Meldung erscheint.

Ihr muesst nicht den gleichen Spell casten, aber nur der jeweils letzte Caster
gilt als "ablenkender Angreifer". Wenn also KK 1 zaubert, danach KK 2 und dann
noch einmal KK 2, erhaelt KK 2 nur beim ersten Angriff den Bonus (und wird
selbt zum ablenkenden KK), beim zweiten Angriff jedoch nicht (da er nun der
"ablenkende Angreifer" ist).

Mehrere Teams, die am gleichen Gegner kaempfen, sollten bezueglich der Boni
anderer Teams nichts merken. Die Einschraenkung, dass der Bonus nur fuer
Mitglieder im gleichen Team wirkt, wurde bewusst so getroffen.

Der Bonus ist im Uebrigen nicht abartig hoch, also wenn ihr ploetzlich Gegner
atomisiert, die ihr vorher nur gekratzt habt, oder wenn ihr irgendwelche
anderen Auffaelligkeiten oder Fehler bemerkt, gebt bitte Bescheid.

Bambi

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



Re: Gelernte Pflanzenkrieger-Varianten (Bambi, 31. Mar 2020, 12:11:33):
~#! rn=Bambi rt=1578702113 rg=gilden.katzenkrieger
~#! tid=1578702113
Hi,

beim Umbau des Pflanzenkrieger-Codes sind ein paar unschoene Sachen
aufgefallen, die ich erst im Laufe der naechsten Tage (und nur mit Hilfe
anderer Magier (RM oder W+)) (oder durch Reboot) behoben bekomme.

Bis es so weit ist, funktionieren die meisten Pflanzenkrieger nicht mehr.
Aktuell sollten der SSP-PK und der Ogerwald-PK problemlos funktionieren,
vielleicht noch der Nusskrieger. Fuer die anderen PKs arbeite ich zusammen mit
einigen Magiern an einer (dauerhaften) Loesung.
Zur Folge hat das unter anderem, dass die aktuell in Umlauf befindlichen
Komponenten wertlos sind. Die werde ich daher in absehbarer Zeit entsorgen.

Ich bitte fuer die Umstaende um Entschuldigung.
Bambi

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



Schaetz-Zauber (Bambi,  1. Apr 2020, 23:22:16):
Hi,

das Einschaetzen von Lebewesen wurde leicht angepasst. Man bekommt nun eine
*hust* sinnvollere *hust* Einschaetzung, was die Lebenspunkte des Gegenuebers
anbelangt.

Bambi

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



Katzenkrieger-Ostergeschenke (Bambi, 12. Apr 2020, 00:53:59):
Hi,

die Gilde, genauer: das Spellbook, hat in der heutigen Osternacht ein paar
Aenderungen erfahren.

Erstens kann der Zauber "pflanzenkrieger" ab sofort bereits als Spieler
gelernt werden, nicht erst als Seher.

Zweitens erkennt ein Katzenkrieger per Schaetz einige nicht angeschlossene
Gilden nicht mehr.
Nochmal zweitens erkennt ein Katzenkrieger dafuer nun einige angeschlossene
Gilden, die er zuvor nicht erkannt hat.

Drittens sollte schaetz auf ein Lebewesen nun einige interessante
Informationen liefern, die man vorher nicht bekommen hat.

Viel Spass wuenscht euch Bambi.

P.S.
Vielen Dank an Humni fuer die rasche Genehmigung
P.S.
Vielen Dank an Maunzerle fuer den Hinweis bezueglich Mindestlevel und
Seherlevel beim PK-Spell.

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



Stoerrisch, Stoerrisch (Humni, 20. Jan 2021, 21:29:25):
Einst waren die Pflanzenkrieger stoerrisch,
man koennt gar sagen, sie waren moerrisch.
Nun jedoch, das ist zu verkuenden,
tun sie sich nicht mehr an Waffen versuenden
Sondern machen das, was man ihnen sagt,
ohne dass man mehrfach fragt.
Dies war ein Wunsch von einem Reh,
der nun erfuellt wurde.

Juchhe!

Humni

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



Pflanzenkrieger-Skill (Arathorn, 23. Jan 2021, 23:39:20):
Hallo zusammen,

Xelonir hat jetzt fuer den Pflanzenkrieger-Skill eine Einschaetzung fuer euch,
auch wenn ihr noch kein Seher seid.

Gruss, Arathorn.

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



