Neue Rubrik (Boing, 19. Jan 1998, 15:43:11):
Damit die Abenteurer nicht als einzige ohne eigene Rubrik dastehen,
gibt es jetzt diese Rubrik. Hier kann alles rein, was die Abenteurergilde
betrifft.
  Boing
PS: Ach ja ... es gibt auch nen neuen Spruch :)
PPS: Hilfeseite folgt

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



Re: Neue Rubrik (Zino, 19. Jan 1998, 15:58:32):
~#! rn=Boing rt=885220991 rg=gilden.abenteurer
~#! tid=885220991
Huebscher Spruch, danke, Boing.
Owen Braddon in Port Vain muesste noch darauf umgestellt werden, damit man
dort auch den Grad des Koennens bei diesem Spruch abfragen kann.

Zino

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



Re: Re: Neue Rubrik (Orktoeter, 19. Jan 1998, 16:09:09):
~#! rn=Zino rt=885221912 rg=gilden.abenteurer
~#! tid=885220991
Ist soeben geschehen, Zino.
Danke Boing ! Endlich ist man als Abenteuerer etwas flexibler !

OrkT ist und bleibt Abenteurer.

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



Re^3: Neue Rubrik (Lavinia, 19. Jan 1998, 20:08:49):
~#! rn=Orktoeter rt=885222549 rg=gilden.abenteurer
~#! tid=885220991
Super, es tut sich ja doch noch was :-)))

Danke!
Lavinia

P.S. Abenteurer aufwerten ! :-)

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



*Jubel* (Polgara, 20. Jan 1998, 13:00:33):
Hi Boing,
ich finde es echt klasse, dass sich endlich was getan hat. vielen vielen dank
fuer den neuen spruch.

Polgara uebt schon fleissig.

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



Re: *Jubel* (Zarniya, 20. Jan 1998, 13:13:35):
~#! rn=Polgara rt=885297633 rg=gilden.abenteurer
~#! tid=885297633
"uebt schon fleissig" ??? Ich wuerd ja nun auf Skripterei testen :)

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



Re: Neue Rubrik (Qitess, 20. Jan 1998, 16:21:05):
~#! rn=Boing rt=885220991 rg=gilden.abenteurer
~#! tid=885220991
als eingefleischter und ueberzeugter Abenteurer 

KUESSE ICH DEINE FUESSE , BOING

dass endlich mal jemand was an der gilde gebastelt hat :)

QI** strahlt


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



Re: Re: Neue Rubrik (Mingo, 20. Jan 1998, 16:33:25):
~#! rn=Qitess rt=885309665 rg=gilden.abenteurer
~#! tid=885220991
Baeh, Boing, jetzt wuerd ich mir die aber waschen.

Gloin

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



Re: Re: *Jubel* (Lavinia, 20. Jan 1998, 19:38:17):
~#! rn=Zarniya rt=885298415 rg=gilden.abenteurer
~#! tid=885297633
Vielleicht bin ich ja zu bloed, aber skripten kann man das nicht. Ich
stehe jedenfalls dauernd vollgefressen und sturzbesoffen rum und warte,
bis es wieder weitergeht. Dabei bin ich bei den Abenteurern, weil ich
keine Lust zum ewigen Ueben habe. 

Ich glaube ich gehe mal lieber wieder Questen...

Lavinia ist heute gelangweilt und liest sogar mal Zeitung

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



zweigstelle (Wurzel, 17. Feb 1998, 21:02:27):
die abenteurergilde hat eine zweigstelle im buero der festungsverwaltung
der zwergenfestung eroeffnet.

wurzel

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



Re: zweigstelle (Boing, 18. Feb 1998, 08:41:06):
~#! rn=Wurzel rt=887745747 rg=gilden.abenteurer
~#! tid=887745747
Und wieso weiss ich da nix davon?
  Boing

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



Re: Re: zweigstelle (Lug, 18. Feb 1998, 17:41:26):
~#! rn=Boing rt=887787666 rg=gilden.abenteurer
~#! tid=887745747
Aeh,

hmm Goetter haben auch ALzheimer? ;)

Lug

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



Zaubersprueche ? (Arutha, 24. Mar 1998, 07:54:31):
Guten Morgen Abenteurer :)

Ich habe mir vor einigen Tagen sgaen lassen, dass es nach dem Spruch Schnell
zumindest noch einen, naemlich Saeurestrahl (??) geben soll (ab Stufe 30 ?).
Ich habe inzwischen auch festgestellt, dass man hilfe saeurestrahl aufrufen
kann, aber koennte man nicht einen Verweis darauf in die Hilfe-Dateien der
anderen Sprueche aufnehmen ?
Es ist zwar ganz nett, wenn andere Spieler einen darauf hinweisen, aber es
waere doch schoen, wenn man sich da auch selbst informieren koennte.
Gibt es ausser diesem Spruch noch weitere ?

xxx Arutha, das erste Mal etwas schreibend

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



Re: Zaubersprueche ? (Trancefear, 24. Mar 1998, 10:16:21):
~#! rn=Arutha rt=890722471 rg=gilden.abenteurer
~#! tid=890722471
Hm... "um den Saeurestrahl schiessen zu koennen, brauchst Du zwei freie
Haende" - eventuell auch "... und darfst keine Hose tragen" ? :-) Mal im
Ernst, wer hat sich denn *das* ausgedacht? So ein Schwachsinn (meine Meinung);
also Feuerball, das ist ja noch ganz ok, aber sowas... tststs

tf

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



Re: Zaubersprueche ? (Freund, 24. Mar 1998, 11:02:07):
~#! rn=Arutha rt=890722471 rg=gilden.abenteurer
~#! tid=890722471
Einen Verweis auf den Spruch und den Level und die Kosten findest Du bei hilfe
abenteurer.

Ich werde aber gerne noch die Verweise der anderen Sprueche ergaenzen.

Freund.

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



Neue Gildentitel (Boing,  6. Apr 1998, 10:30:03):
Hallo Abenteurer,

da es inzwischen nicht mehr der Fall ist, dass man mit Stufe 20 Seher wird,
haben Hobo, Vincent und ich uns ein paar Gedanken ueber neue Gildentitel
fuer die Abenteurer ab Stufe 19 ueberlegt. Beim Brainstorming ist die 
Liste rausgekommen, die ich unten praesentieren werde. Wer dazu Kommentare
oder weitere Anregungen fuer Titel hat, moege diese hier loswerden.

[Anmerkung: Alle Titel sind nur in maennlicher Form und ohne Zuweisung
 an einen bestimmten Level aufgelistet]

der Veteran
der Siegreiche
der Bezwinger
der noch nicht Verfuehrte <- soll heissen: noch nicht von anderen Gilden
                             verfuehrt :)
der Schlitzer
der Bluemchenpfluecker
der Wagemutige
der Peiniger
der Desperado
der Knochenbrecher
der Meister der Saeure (Stufe 30, Saeurestrahl)
der Recke
der Haudegen
der Imposante

  Boing

PS: Nein! 'Boing' ist KEIN Gildentitel ...

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



Re: Neue Gildentitel (Obermotz,  7. Apr 1998, 09:33:22):
~#! rn=Boing rt=891851403 rg=gilden.abenteurer
~#! tid=891851403
Die Titel klingen gut. Aber ich glaube Veteran haben schon die Trevs. "Der
noch nicht Verfuehrte" koennte man ja in "der ewige Abenteuerer" umaendern.

OM

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



Re: Re: Neue Gildentitel (Trekan,  7. Apr 1998, 09:43:57):
~#! rn=Obermotz rt=891934402 rg=gilden.abenteurer
~#! tid=891851403
heisst das nicht 'stuemper' ? :)
Trekan

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



Re: Neue Gildentitel (Bogus,  7. Apr 1998, 17:35:49):
~#! rn=Boing rt=891851403 rg=gilden.abenteurer
~#! tid=891851403
Wie waere es denn wieder mit dem Titel Prophet? Der ist irgendwann mal
abgeschafft worden. Fuer den doch bitte wieder ein

Bogus (wahrscheinlich der letzte Prophet)

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



Feuerball (Polgara, 16. Jun 1998, 17:52:55):
Hiho,
ich habe soeben festgestellt das ich bei Eismonstern mit dem Saeurestrahl mehr
schaden anrichte wie mit dem Feuerball. Ich moechte hiermit eigentlich nur
eine kleine Diskussion anregen damit vielleicht mal wieder etwas fuer die
Abenteurer getan wird.

Gruessle Polle

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



Re: Feuerball (Yendi, 16. Jun 1998, 19:10:27):
~#! rn=Polgara rt=898012375 rg=gilden.abenteurer
~#! tid=898012375
Ich will jetzt nicht anfangen zu schreien "Abenteurer aufwerten!", aber ein
Feuerball sollte bei Eismonstern mehr wehtuen als Saeure... oder?

YTY


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



Re: Re: Feuerball (Grimmborn, 16. Jun 1998, 20:05:55):
~#! rn=Yendi rt=898017027 rg=gilden.abenteurer
~#! tid=898012375
Noe. Bischen heisse Luft macht weniger Eis alle als beispielsweise ein Schuss
Salpetersaeure (wenns nicht zu kalt ist). Das Geheimnis heisst
"Gefrierpunktserniedrigung".

Grimmborn der Atheist

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



Re: Feuerball (Mahatma, 16. Jun 1998, 22:04:31):
~#! rn=Polgara rt=898012375 rg=gilden.abenteurer
~#! tid=898012375
Das geschilderte Phaenomen, dass der Saeurestrahl bei Eismonstern mehr Schaden
macht als der Feuerball, halte ich bei solchen, die auf uebliche Weise
feuerempfindlich sind (d.h. den Schaden verdoppeln) fuer ein Geruecht, da der
Saeurestrahl weniger als doppelt soviel Schaden macht, sondern nur 8/5 mal
soviel.
Wenn Du also tatsaechlich mit dem Saeurestrahl mehr Schaden gemacht haben
solltest, muessen nicht die Abenteurer aufgewertet werden, sondern dem
Eismonster die entsprechende Empfindlichkeit verpasst werden.

Mahatma, im Auftrag von Zino

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



Re^3: Feuerball (Nixihou, 17. Jun 1998, 09:00:03):
~#! rn=Grimmborn rt=898020355 rg=gilden.abenteurer
~#! tid=898012375
saeure auf eis -> wie grimmi sagt: gefrierpunktserniedrigung...
aber was dazu kommt es entsteht auch eine gewisse waerme bei der 
zwangslaeufigen verduennung der saeure durch das schmelzwasser....

nixihou

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



Re: Re: Feuerball (Boing, 17. Jun 1998, 09:09:23):
~#! rn=Mahatma rt=898027471 rg=gilden.abenteurer
~#! tid=898012375
Das beschriebene Phaenomen tritt tatsaechlich (bei meinen Eismonstern)
nur beim Eistitan auf, der mit voller Absicht nicht feueranfaellig ist.
Also ist es ganz logisch, dass der staerkere Spruch dort mehr Schaden
macht.
  Boing

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



Re^3: Feuerball (Trekan, 17. Jun 1998, 18:27:52):
~#! rn=Boing rt=898067363 rg=gilden.abenteurer
~#! tid=898012375
mmh .. der titan is net feueranfaellig? 
tsts .. wieder was dazugelernt. ich hab den noch nie identifiziert .. immer
nur feuer reingebrezelt ;)))
Trekan -> Wurst(stolz,idel)
**\

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



Keine Aenderung? :) (Augra, 29. Jul 1998, 10:20:18):

Nanu,

eine Gilde ohne blauen Brief? Sollten die Abenteurer wirklich ungeschoren
davon kommen? Oder holt das Schicksal noch aus, um dann verspaetet, aber um so
haerter zuzuschlagen?

A. Weissnix

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



Re: Keine Aenderung? :) (Boing, 29. Jul 1998, 10:21:34):
~#! rn=Augra rt=901700418 rg=gilden.abenteurer
~#! tid=901700418
Es holt noch aus, aber es wird nicht hart zuschlagen ... wohin auch? :)
  Boing

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



Re: Re: Keine Aenderung? :) (Arutha, 29. Jul 1998, 14:01:45):
~#! rn=Boing rt=901700494 rg=gilden.abenteurer
~#! tid=901700418
'Licht' abwerten ? 

Arutha, stellt sich schuetzend vor den Saeurestrahl

PS: Vielleicht koennte man selbigen im Gegenzug aufwerten ? ;)
x

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



Re: Keine Aenderung? :) (Trancefear, 30. Jul 1998, 11:26:43):
~#! rn=Augra rt=901700418 rg=gilden.abenteurer
~#! tid=901700418
Hmja ich denke mal, die AB-Gilde ist der unterste Grund, wo die anderen alle
hinwollen bzw. sollen...

tf

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



Aenderungen (Boing, 30. Jul 1998, 13:25:23):
Hallo,
hier kurz ein Ueberblick ueber die Aenderungen bei den Abenteurern:
- alle Sprueche die auf ein Ziel gerichtet sind, beruecksichtigen jetzt
  SpellDefend(), d.h. das Opfer kann sich dagegen wehren. 
- Kampfschrei und Schnell sind in ihrer Wirkungsdauer nach oben begrenzt,
  die Grenzen sind allerdings ziemlich grosszuegig gewaehlt.
- Identifizieren kostet nur noch 10 statt 15 Magiepunkte.
Das war's auch schon,
  Boing

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



Karateka schlaegt eine verbesserung fuer die abenteurer vor (Boing, 22. Okt 1998, 08:38:29):
~#! on=Phygos ot=908991969 og=entwicklung
Klar ich bin karateka
will mich auch garnicht ueber die gildenfaehigkeiten der karatekas beschweren
( naja ueber ne kleine aufwertung auch nicht )  aber ich denke mal es wird
zeit etwas fuer die abenteurer die trommel zu ruehrern
ich finde die kosten ( MP pro zauber ) " etwas " uebertieben.
speziell die kosten fuer den schnellspruch   aber auch feuerball und
saeurestrahl sind gesalzen. 
dafuer das die abenteurer eine bzw die anfaengergilde sind ( ergo ueber weng
MPs verfuegen ) sind die kosten hoch  nicht unueberwindbar aber hoch  wenn man
sich dazu die wirkung und kosten anderer gilden und ihrer zauber ansieht,
sogar sehr hoch  
mensch magier ( ja ja auch zwerg elf katze hobbit und was da sonst kreucht und
fleucht )  greift mal den kleinen unter die arme anstatt euch die koepfe wg.
der highlevelplayer einzubeulen. 
und jetzt bitte nicht eine eiligst geclonte abenteurer-aufwerten/diskussion
mit hundert und einem flame
oki mal sehn obs was wird :)
 gruss

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



Re^9: Internet und wie alles begann ... (Hobo, 22. Okt 1998, 09:35:15):
~#! rn=Wurzel rt=908994083 rg=puiz
~#! tid=908262319
Ich bin auch fuer eine Aufwertung der Abenteurer. Allerdings in einem eng
begrenzten Rahmen:
Der Schnellspruch ist definitiv zu teuer, da man sowieso relativ wenig Schaden
macht. Ausserdem ist (gerade wenn man zu mehreren kaempft) der Kampfschrei
auch wesentlich effektiver (und billiger ist der doch auch, oder?)
Andererseits finde ich den Saeurestrahl schon ok. Wenn man bei der AG von
einer Anfaengergilde und daher wenig MP spricht, dann hat sich das bis zu dem
Level, ab den man den SS kann, voellig gegeben.
Eventuell koennte man einen gestaffelten MP-Verbrauch fuer die Feuerbaelle
machen? Obwohl ich (aeh, mein Zweitie) die eigentlich nicht zu teuer fand.
Mein Zweitie hat sich als Spieler recht wohl gefuehlt als Abenteurer. Aber als
Seher war das Abenteurerleben doch etwas eintoenig.
Wie waere es denn mit Vorschlaegen fuer die Abenteurer-Seher? Nicht unbedingt,
um die Gilde staerker zu machen, sondern um sie einfach interessanter zu
machem? 

Ciao

   Hobo

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



Re: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Boing, 22. Okt 1998, 10:04:51):
~#! rn=Boing rt=909045509 rg=gilden.abenteurer
~#! tid=909045509
Tryfan hat mir eben eine mail geschickt mit der Bitte, den folgenden
Artikel hier zu posten. Das ist also nicht auf meinem Mist gewachsen
sondern von Tryfan! :)

--------------------------------- Tryfan on ---------------------------------
Ich schlage folgenden neuen Spruch fuer die Abenteurer vor. 'Verhoere
<Opfer>'
Sollte der Spruch 100%-tig gelingen erzaehlt einem das Opfer freimuetig
alle Informationen auf alle Frage, die es beantworten kann. Dieses ist
ein voellig neuer Spruch, der kaum Auswirkungen auf Kaempfe hat und die
Abenteurer bei dem untestuetzt, was ihre Passion sein sollte, das
Abenteuer suchen.
Welche Kosten durch den Spruch entstehen lasse ich Boing und der Balance
frei. Aber ich koennte mir auch noch ausser MP etwas (z.B. Komponenten
einer 'Scheiss-egal-Droge' vorstellen).
Vorschlag: 10 MP plus Droge
Auch die Stufe, ab wann man ihn sprechen kann, und der Grad mit dem er
gelingt, muesste man noch festlegen.
Vorschlag:  (Spielerstufe-10) * 5%   als Basiswahrscheinlichkeit, die
noch per Zufall variable ist.
Wem fallen noch spezifische Abenteurersprueche ein? Lasst eurer Fantasie
freien Lauf und denkt nicht immer nur ans Metzeln!
                Tryfan aus Duncton

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



Re: Re: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Anatol, 22. Okt 1998, 10:11:47):
~#! rn=Boing rt=909050691 rg=gilden.abenteurer
~#! tid=909045509
Waer bei manchen Quest-NPCs ziemlich heftig. Schliesslich gehoert es
zum Questen, aus einem Info-NPC das Wissen, das mach braucht, herauszuholen.
Gerade Tryfan mit seinen Maulwuerfen muesste das einleuchten - mit dem
Joker "alle Antworten herauszwingen" ist der 'Stein von Duncton' jedenfalls
keine 50 Abenteuerpunkte mehr wert. Und Baseballspielen kann man dann auch
viel einfacher lernen...

Den Scroll bei "verhoere chilana" auch gar nicht haben wollend,
Anatol :o)


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



Re^3: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Ark, 22. Okt 1998, 11:02:37):
~#! rn=Anatol rt=909051107 rg=gilden.abenteurer
~#! tid=909045509
Hm, wenn die programmierenden Magier etwas Arbeit auf sich naehmen *aehem*,
koennte man verschiedene Infos, die quasi nie abgefragt werden, aber dennoch
interessant sind, fuer so ein Verhoer freigeben und sie kennzeichnen. Is
natuerlich im Nachhinein recht aufwendig, aber ich wuerde da durchaus
mitspielen. Bei neuen Npcs muesste man sich halt noch etwas mehr Gedanken
machen, welche Infos fuer einen solchen Spruch in Frage kaemen.
Natuerlich sollten FP-Infos ausgeklammert werden, da muss man sich die Arbeit
wohl machen, denke ich. Insgesamt waere es ne nette Idee, einen Npc zu
'hypnotisieren'. Natuerlich koennen einige Npcs das sicher abwehren, oder sich
auch auf den Schlips getreten fuehlen :-)
Also, dafuer, Boing, bitte uebernehmen und programmieren ;^)


              *** ARK * the * Magnificent ***


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



Re^4: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Morgoth, 22. Okt 1998, 11:07:07):
~#! rn=Ark rt=909054157 rg=gilden.abenteurer
~#! tid=909045509
Nur eine Verstaendnisfrage:
Wenn der Spruch benutzt wird, gibt der NPC die Infos freiwillig raus, man muss
ihn nicht mal nach allem Scheiss fragen? 
oder... wenn er nicht benutzt wird, bekommt man einige Antowrten nicht, weil
sich der NPC weigert?
Also die erste Variante waere genial, das sollte es dann auch fuer Details
geben, dann kann man sich dieses bloede Forschen sparen!! ;-))

Morgoth wuerde gerne 100MP fuer die Details ausgeben....

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



Re^5: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Ark, 22. Okt 1998, 11:15:08):
~#! rn=Morgoth rt=909054427 rg=gilden.abenteurer
~#! tid=909045509
Oeh, noe, so einfach nun nich :-) Soll ja noch ein bisserl Atmosphaere dabei
sein, nicht so ein mechanisches Frageskript sein. Sowas wie AddInfoSpecial,
die dann beim Anwenden raussprudeln. Was der Npc noch so verbirgt, liegt dann
im Ermessen des Mags. FP sollten mit diesen markierten Antworten NICHT zu
bekommen sein. Ist halt ein wenig mehr an Grips, den man beim Gestalten seiner
Npcs verwenden muss. Hm, Feuerdaemonen oder Saeuredaemonen fallen da sowieso
raus, oder reden die mit einem ? ;^)


              *** ARK * the * Magnificent ***


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



Re^6: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Orktoeter, 22. Okt 1998, 11:52:05):
~#! rn=Ark rt=909054908 rg=gilden.abenteurer
~#! tid=909045509
Zum Anfang des Thraeds : Ich will nicht behaupten, mich mit den heftigsten
Gegnern im MG gemessen zu haben, aber "fuer den Hausgebrauch" ist man als
Abenteurerseher gerade nachdem es den Saeurestrahl gibt nicht so ganz ohne.
Die kosten fuer Schnell sind extrem hoch (sicher im Vergleich zu anderen
Gilden uebertrieben hoch), aber das waren sie schon immer und eine Anpassung
wuerde der schleichenden Aufruestungsspirale wieder eine kleinen Schubs geben.
Fazit, lasst es, wie es ist.

Zu dem Angedachten neuen Spruch :
Das grosse Problem, was ich sehe, ist, das man ja keine wirklich wichtigen
Infos bekommen soll/darf, das wird erstens vielen Spielern die Lust nehmen den
Spruch zu verwenden und zweitens vielen Magiern, so etwas in ihre NPC
einzubauen (zumindest aeltere NPC anzupassen).
Also wird es wenn nur relativ wenige (neuere) NPC geben, bei denen der Spruch
ueberhaupt etwas bringt. Das wiederum bedeutet, das Abenteurer ca 90% oder
mehr ihrer derartigen Spells "verschwenden", was die motivation, den Spell zu
benutzen nicht gerade foerdern duerfte.

OrkT.

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



Re^7: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Ark, 22. Okt 1998, 11:58:15):
~#! rn=Orktoeter rt=909057125 rg=gilden.abenteurer
~#! tid=909045509
Naja, das haengt von uns Magiern ab, Sachen wie die neue Property Material
wurden ja auch inner Kraftaktion eingefuehrt. Es bedeutet sicher einiges an
Arbeit und Grips, aber das soll ja kein resigniertes 'Es nutzt uns nur bei ein
paar neuen Npcs' zur Folge haben. Wenn es NUR das ist, was dem Spruch
'entgegen' steht, dann isses ja gut :-)


              *** ARK * the * Magnificent ***


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



Re^4: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Hood, 22. Okt 1998, 13:13:43):
~#! rn=Ark rt=909054157 rg=gilden.abenteurer
~#! tid=909045509
dass diese art von freischaltung von npc's nicht funktionieren wird, sieht
man an P_GUARD, der spell waer also eh fuer die katz und man kann es
auch gleich lassen.

------
patryn

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



Re^7: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Qitess, 22. Okt 1998, 13:40:29):
~#! rn=Orktoeter rt=909057125 rg=gilden.abenteurer
~#! tid=909045509

Also, ich als eingefleischter Abenteurer moechte auch mal ein paar Dinge
anmerken:

> Erstens moechte ich mich strikt dagegen aussprechen, die Abenteurer-Gilde
als 'Anfaenger-Gilde' zu bezeichnen. Abenteurer heisst fuer mich naemlich,
dass der Charakter jemand ist, der von allem ein wenig kann (was hier im MG
allerdings nicht so ganz zutrifft). Und als Seher in der Abenteurer-Gilde
ist man ja wohl kein Anfaenger mehr. Vielleicht koennte man ja den
  'Erfahrenen Abenteurer'   einfuehren? Sozusagen als zweites Bonbon nach
der Seher-Werdung, ein paar Stufen spaeter halt. Wenn man dann alle seine
Sprueche gelernt hat und auf ein bestimmtes Niveau gebracht hat (sagen wir
mal, alle Sprueche oder eine bestimmte Anzahl an Spruechen kann der Charak-
ter perfekt), dann werden die Sprueche billiger. Oder er kann sich aus den
anderen Gilden eine oder zwei Faehigkeiten (eingeschraenktes Angebot) aus-
suchen und damit seinen Allrounder-Status festigen.(Das koennte aber wohl
ein zu hoher Programmieraufwand werden, wenn man die Fuelle an Auswahlmoeg-
lichkeiten bedenkt...naja, eigentlich auch nicht. Man muss ja nur die Files
der erlernbaren, also zur Verfuegung stehenden Spells aus der einen Gilde
in die Abenteurer-Gilde kopieren und die Zugriffsbeschraenkung dransetzen.)

> Zum Zweiten, wo wir gerade bei billigeren Spruechen sind: Der Schnell-
Spruch ist eindeutig nicht nur ein bisschen zu teuer. Und auch im Zuge der
'Ruestungs-Spirale' ist es mir scheissegal, ob das wieder ein Schritt nach
oben ist. Wenn naemlich die Haelfte meiner MP schon weg ist, bevor ich was
vernuenftiges am NPC anbringen konnte, dann finde ich es doch schon ziem-
lich entmutigend. Deswegen meine Bitte dazu: Macht den Schnell-Spruch bil-
liger. (Durchaus teurer als bei den anderen, aber trotzdem billiger als
diese fiesen 100 MP !)

> Als Drittes halte ich die Idee mit der Informations-Droge und dem dazuge-
hoerigen 'Sag-mir-alles-Spruch' fuer schlecht. Denn der Sinn eines Abenteu-
ers liegt doch wohl darin, das Abenteuer zu bestehen. Und dazu kommen einem
die Leute eben nicht entgegen und erzaehlen alles. Auch und gerade bei den
Abenteurern liegt doch wohl der Anreiz eines Abenteuers im zu Bestehenden,
im Ausfragen und Suchen. Wenn ich nur noch hingehen muss und der NPC er-
zaehlt mir auf Knopfdruck alles, was wichtig ist, dann kann ich auch gleich
ein Script laufen lassen. (Gut, gut, einige werden sogar das ganz besonders
reizend finden. Sinn und Zweck eines Abenteuers ist es aber garantiert
nicht, ein ausgekluegeltes Script zu schreiben. Und im Sinne des Morgen-
Grauens ist es erst recht nicht.) Dazu faellt mir die Idee ein, dass es
eine 'Ahnungs-Droge' geben koennte. Wenn man die einnimmt, bekommt man u.U.
eine Eingebung, was man den NPC fragen koennte. Natuerlich sollte man diese
Eingebung nicht immer bekommen, und auch nicht immer zuverlaessig.

> Viertens will ich endlich wissen, wo Astar meinen 'Staubsauger' hinge-
setzt hat, aber eigentlich tut das hier gerade nichts zur Sache. ;)

> Fuenftens habe ich vergessen, das hat der Mops grad aufgefressen.

> Sechstens wuensche ich mir einen Wasserstrahl als Kampfspell. Oder auch
Eis. Ist aber nur ein Wunsch. Das koennte dann nach dem Saeurestrahl er-
lernbar sein, und noch ein bisschen mehr kosten (40 MP?).

> Und dan als siebten Punkt haette ich neben den magischen Spells, die
Abenteurer setzen koennen auch ganz gerne etwas handfesteres wie einen Waf-
fenskill oder Angriffstechniken wie Schlaege oder Tritte. Schliesslich ist
vor allem das letztgenannte etwas, was man als Abenteurer (Streuner,
Gluecksritter, etc) immer mal zu tun hat. Aehm...jedenfalls wuerde das auch
den Allrounder-Status festigen.


Ich weiss natuerlich, dass das jetzt ziemlich viel ist. Einiges davon kann
aber sicher ueberdacht werden.

QI** ist heute mal produktiv.


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



Re^8: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Wurzel, 22. Okt 1998, 16:26:34):
~#! rn=Qitess rt=909063629 rg=gilden.abenteurer
~#! tid=909045509
hm, die kernaussage von tryfan haben wohl leider die wenigsten verstanden.
es geht eigentlich nicht wirklich um diesen ausfrage-spruch (den ich auch
eher stimmungstoetend finde), sondern darum dass die abenteurer eigentlich
die gilde an sich fuer leute ist, die nicht ihr hauptaugenmerk aufs metzeln
legen. man koennte auch sagen, eine bluemchenpflueckergilde. die ganzen
diskussionen der gildenfaehigkeiten etc. drehen sich doch immer nur um die
kampffaehigkeiten, es fehlt eigentlich wirklich etwas fuer die anderen dinge
des mudlebens.
insofern ist tryfans idee zu begruessen, mal ueber was anderes als
nur metzelei nachzudenken.
natuerlich wird hier viel gemetzelt. irgend jemand (weiss nicht mehr wer) hat
den interessanten vorschlag gemacht, sich von anderen gilden "was abzuschauen"
(natuerlich duerfen das dann nicht gerade die toplevelsprueche sein), das
wuerde dem flair des allround-abenteurers gerecht. sollte natuerlich nur als
seher gehen. evtl koennte man das auch auf sachen beschraenken, die man als
mitglied der speziellen gilde mal gelernt hat, was dann auch einer
oft gehoerten forderung wenigstens zum teil nachkaeme.

insgesamt finde ich, dass die abenteurer durchaus ein "interessanter machen"
vertragen wuerden (das boese wort von der aufwertung will ich jetzt nicht
verwenden :)

wurzel

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



karateka schlaegt bla bla (Phygos, 22. Okt 1998, 16:29:35):
oh mann was hab ich da nur vom zaun gebrochen   
ich wollte doch nur ein wenig ( EIN GANZ KLEINES BISCHEN ) verbesserung 
ploetzlich ist hier die rede von neuen zaubern etc 
ich wars nicht
ich bestreite alles
ohne meinen anwalt sag ich nix mehr
macht das unter euch aus
heoffe nur auf ne kleine erleichterung fuer die abenteurer
jeder solte da  zumindest nen zweiti haben
die einzig verbliebene gilde mit richtig atmosphaere ohne rekordzwang :)
gruss
euer sprengmeister

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



Re^9: Karateka schlaegt eine verbesserung fuer die abenteurer vor (Deepblue, 22. Okt 1998, 16:48:07):
~#! rn=Wurzel rt=909073594 rg=gilden.abenteurer
~#! tid=909045509
Wie waere es, wenn man dem Abenteurer die Moeglichkeit verschafft, auch auf
anderem Wege als Metzeln XPs zu sammeln?

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



'Verhoere'-Spruch (Tsunami, 26. Okt 1998, 16:53:19):
Ich habe mich grad durch die MPA gelesen. Den 'Verhoere-NPC'-Spruch finde
ich eine gute Idee und wuerde das entsprechende Propertie in alle meine NPCs
einbauen. Nur denke ich, dass dieser Spruch eher zu den Klerikern passen
wuerde. So in der Art 'Spanische Inquisition' :)

Tsunami

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



Re: 'Verhoere'-Spruch (Jesko, 26. Okt 1998, 19:32:45):
~#! rn=Tsunami rt=909420799 rg=gilden.abenteurer
~#! tid=909420799
Peace!

Ich denke wie schon von manchen hier angebracht eigentlich auch, dass
ein reines rausscrollen mit allem, was ein NPC zu sagen hat wohl doch
eher spassbremsig als spassfoerdernd ist. Hingegen ist IMHo eine Variante
welche ein paar (halb)offensichtliche Themen hergibt, nach denen man die
Person befragen koennte fuer viel interessanter. Manchmal ist ja gerade der
Einstieg in das Gespraech mit dem NPc das Problem, der Rest ergibt sich
ja doch eigentlich von alleine (idealisiert).

Insgesammt wuerde ich sagen dass die Gilde schon noch ein, zwei Extras
verdient hat und eben KEINE reine Anfaengergilde ist. Was soll den ein HLP
sonst machen, wenn ihm keine der vorhandenen Gilden zusagen? Ich faende es
daher schon nett, wenn man noch die eine oder andere Idee integrieren
koennte (vielleicht sogar auch eine Gildenquest? Oder gibts sowas und ich
hab es nur noch nicht gefunden...).

Jesko, Abenteurer, weil keine andere Gilde zu einem Bluemchenpfluecker
wie ihm passt.

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



Re: Re: 'Verhoere'-Spruch (Anatol, 26. Okt 1998, 19:38:35):
~#! rn=Jesko rt=909430365 rg=gilden.abenteurer
~#! tid=909420799
Der Nachteil dieser Idee liegt hauptsaechlich darin, dass man diese
halboffenen Infos explizit schreiben muesste, aehnlich den zusaetzlichen
Sonder-Informationen, die ein Monster oder Gegenstand beim Identifizieren
herausgibt...

Anatol


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



Re^3: 'Verhoere'-Spruch (Jesko, 26. Okt 1998, 19:42:49):
~#! rn=Anatol rt=909430715 rg=gilden.abenteurer
~#! tid=909420799
Peace!

Das ist wohl wahr. (Ausserdem waehre die eben vorgeschlagene Variante
schon kein Verhoer mehr sondern nur so ne Art Empatie).

Vielleicht sollte man sich auch nicht an diesem Spruch allgemein fest-
legen sondern hauptsaechlich weiter rumspinnen bis man vielleicht auch
auf eine Idee kommt, die ausgewogen und realisierbar ist.

Jesko, macht sich zumindest ein paar Gedanken

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



verhoerspruch und schlimmeres (Phygos, 27. Okt 1998, 08:14:39):
Nun gut, ich gebs zu. Ich hab diese unselige diskussion zweck aufwertung der
abenteurer vom zaun gebrochen.
ABER... ich hab keine neuen sprueche verlangt!!!!
Warum muss hier eigentlich jeder sofort uebers ziel hinaus/schiessen/scheissen
?!
ich habe nur nach einer kleinen erleichterung fuer die abenteurer gefragt und
schon bricht hier eine wueste welle von veraenderungswuenschen los.
lasst die abenteurer wie sie sind.
sollten sich ein paar hochlevlige mags dazu durchringen, die kosten fuer
einzelne abenteurersprueche bzw deren wirkung zu veraendern ( natuerlich bitte
zum positiven ) dann reicht das allemal
sicher lags an meinem ungenauen artikel. naja wenn ein denkanstoss nicht
reicht, hier ein paar vorschlaege.
ALLES NUR VORSCHLAEGE ( flames bitte nach schmarrn verlegen/ mails les ich eh
nicht )  >:)
1) Pfeil
entweder etwas billiger oder etwas staerker
2) Feuerball
entweder etwas billiger oder eine laengere wirkdauer---> naja wenn der
feuerball trifft muss das feuer doch nicht gleich ausgehen oder?
3) Schnell
BILLIGER und laengere wirkdauer
4) saeurestrahl
genau richtig nix aendern
5) identifiziere
habs immer schon als ziemlich mager empfunden, aber verglichen mit dem was die
kaempfer als angeblich magisch vollkommen unbegabt koennen ist ein boeser
scherz!!
6) licht
ziemlich seltsamer spruch  warum als ablegbares objekt? warum leuchtet nicht
der abenteurer?
alle anderen sprueche sind ok.
allerdings koennte sich mal jemand aufraffen in owen ein paar nette
erklaerungen zu den einzelnen spruechen abzulegen   ----> frage owen nach bsp.
feuerball etc etc
bzw wie waers auch mit angaben zu SMS Wurfstern Bumi ( falls es mal ein skill
wird )
ja ja ich weiss es jetzt schon  die mags verweisen mich an den zustaendigen
regieons oder gildenmag, und von seiten der spieler kommen tausend flames
weill einige sofort nen neuen toooootaaaaaal spuper alles niedermetzelnden
alles erklaerenden spruch haben wollen.
ich wills nicht. machts den abenteurern einfach nur ETWAS leichter.
Mit explosiven gruessen
Phygos

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



Re: verhoerspruch und schlimmeres (Boing, 27. Okt 1998, 10:52:13):
~#! rn=Phygos rt=909476079 rg=gilden.abenteurer
~#! tid=909476079
Das 'identifiziere' der Abenteurer und Kaempfer gibt exakt (!) die
selbe Information.
  Boing

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



identifizieren der kaempfer (Phygos, 27. Okt 1998, 11:07:20):
naja also was kaempfer mittels verschiedenster skills an infos aus
verschiedensten gegenstaenden herausbekommen koennen isr doch wohl ne kleine
ecke mehr als das was abenteuere herausfinden koennen

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



Re: identifizieren der kaempfer (Hobo, 27. Okt 1998, 12:04:17):
~#! rn=Phygos rt=909486440 rg=gilden.abenteurer
~#! tid=909486440
..und hat mit Magie nicht zu tun, sondern mit der fantastischen Kenntnis, die
Kaempfer in ihrer Ausbildung ueber Waffen und Ruestungen erwerben.

  Hobo

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



Re: Re: identifizieren der kaempfer (Schoko, 27. Okt 1998, 12:21:33):
~#! rn=Hobo rt=909489857 rg=gilden.abenteurer
~#! tid=909486440
Hmm ihr solltet euch einigen, ob ihr ueber schaetz oder identifiziere redet
:))

Schoko

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



Re^4: identifizieren der kaempfer (Morgoth, 27. Okt 1998, 12:29:52):
~#! rn=Hobo rt=909491031 rg=gilden.abenteurer
~#! tid=909486440
My mustard
1. Die (Angriffs)spells vom Level her runtersetzen (pfeil 9, fb 12, sa 30)
2. Vielleicht noch ein spell fuer den Mitt-20er Bereich. Hm? Hammerhand?
schlaegt mit den Faeusten mal kraeftig zu (also physikalisch)
3. Kosten nerven nur bei schnell und kampfschrei, wobei KS eh relativ sinnlos
ist (obwohl Boing mir was anderes erzaehlt)

mustard off

M*

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



Re: verhoerspruch und schlimmeres (Alpha, 27. Okt 1998, 12:58:17):
~#! rn=Phygos rt=909476079 rg=gilden.abenteurer
~#! tid=909476079
Waarum die Lichtkugel nicht ablegen....ich fand das immer toll...kann man
anderen Leuten, die Licht noch nicht koennen mal fix ne Kugel inne Hand
druecken.
Also waers doch eher ne Abwertung, wenn datt wechkommt.

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



Re: verhoerspruch und schlimmeres (Karam, 27. Okt 1998, 17:08:22):
~#! rn=Phygos rt=909476079 rg=gilden.abenteurer
~#! tid=909476079
Ich finde die Abenteurer groesstenteils in Ordnung. Jedoch ist da ab
Stufe 30 nicht mehr viel los. Ein paar neue Sprueche oder Skills am
oberen Ende waeren ganz nett. Aber erstmal zum Vorhandenen:

Schnell ist viel zu teuer. Den Spruch verwende ich aeusserst selten,
wenn mit magischen Angriffen nichts auszurichten ist. Sollte deshalb
deutlich billiger werden.

Pfeil koennte stufenabhaengig etwas billiger werden. Benutze ich sonst
auch nicht, weil er zu wenig Schaden pro KP macht.

Nun zu moeglichen Erweiterungen: Mir ist der Charakter der Abenteurer
als Allround-Gilde sehr wichtig. Zur Zeit kommt da die Benutzung von
Waffen viel zu kurz, was sich aber durch einen billigeren
Schnell-Spruch sehr verbessern wuerde. Eine Waffe nehme ich fast
nur zum Elstern-Jagen in die Hand. Sonst immer Saeurestrahl (was
irgendwie eintoenig ist).

Richtwert fuer Aufwertungen im Kampf sollte der Saeurestrahl sein.
Neue Angriffsarten sollten nur in besonders guenstigen Situationen mehr
Schaden pro Runde als Saeurestrahl machen.

Ein neuer Spruch, den ich mir wuensche, ist "Eislanze". Schaden wie
Feuerball, KP-Verbrauch wie Saeurestrahl, dafuer einhaendig zu
zaubern. Zu erlernen ab Stufe 40.

Eine aufwendigere Erweiterung waere, den Abenteurern Zugang zu Skills
und Spruechen anderer Gilden zu verschaffen. Entweder ueber eine
"Zweitgilde", in der der Abenteurer bis in mittelgute Gildenlevel
aufsteigen kann, oder ueber eine Zahl an Faehigkeiten, die sich in
beliebiger Mischung aus dem Angebot auswaehlen lassen. Ich bin
eher fuer die zweite Variante, da sie die Vielfalt mehr foerdert.

Noch ein paar konkretere Gedanken zur zweiten Variante: Es koennten
insgesamt 4 Faehigkeiten erlernt werden: 2 leichte (die im Kampf
nichts oder fast nichts bringen duerfen), eine mittelschwere und eine
schwere (schwer aus Sicht der Abenteurer sollte in etwas mittelschwer
aus Sicht der jeweiligen Gilde sein). Ab Stufe 25 koennte man z.B.
eine leichte Faehigkeit lernen, ab Stufe 35 noch eine mittlere,
ab Stufe 45 eine zweite leichte fuer Zwischendurch und ab Stufe 50
dann die schwere (ich habe hier noch Saeurestrahl mit Stufe 30 und
Eislanze mit Stufe 40 eingeplant). So hat man bis Stufe 50 viel zu tun
und auch noch darueber hinaus, bis man alles pefekt kann.

Leichte Faehigkeiten koennten sein: Konzentration auf einen Gegner
(Karate-Gilde), Einschaetzen von Waffen und Ruestungen (Kaempfer),
Sonnenschutz (Klerus), Nachtsicht (Chaos), Sand (Bierschuettler).

Mittelschwere Faehigkeiten koennten sein: Fauskampf (Karate),
Schildparade (Kaempfer), Schutzhuelle (Zauberer), Heile (Klerus).

Schwere Faehigkeiten koennten sein: Kampftritt (Karate),
Waffenschlag (Kaempfer), Hand (Zauberer), Elementarschild (Klerus),
Beschwoerung von Irkitis oder Harkuhu (Chaos).

Besonders kritisch sehe ich die Defensivfaehigkeiten, da sie sich
typischerweise in Kombination mit vorhandenen Angriffen nutzen lassen.
Sie muessen also deutlich schwaecher ausfallen, damit nicht alle
Abenteurer Schutzhuelle und Elementarschild waehlen und dann mit
der Abwehr eines Klerikers fleissig Saeurestrahl zaubern.

Bei Faehigkeiten, die dem Abenteurer normalerweise sehr fremd sind,
sollte dieser nicht ohne spezielle Hilfsmittel auskommen, z.B. ein
Amulett oder Ring zum Beschwoeren eines Daemons (zusaetzlich zu den
sich verbrauchenden Zutaten, und das Amulett muss natuerlich die
ganze Zeit getragen werden, weil der Daemon sonst wieder verschwindet).

PS: Ich kenne nur Abenteurer und Karate einigermassen gut. Falls
ich unsinnige Vorschlaege gemacht habe, bitte nicht einfach flamen
("Mit dem Elementarschild werden die Abenteurer ja besser als die
Kaempfer"), sondern einen bessern Vorschlag mitliefern
("Elementarschild sollte maximal <so> stark sein").

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



Re: Re: verhoerspruch und schlimmeres (Trancefear, 27. Okt 1998, 19:29:08):
~#! rn=Karam rt=909508102 rg=gilden.abenteurer
~#! tid=909476079
Nunja die anderen Gilden moegen vielleicht staerker sein als die Abenteurer,
aber zu welchem Preis? Ein fehlgehender Spell kann im schlimmsten Fall den
Spieler umbringen, und das Lerntempo ist auch nicht so dolle... neinein die
Abenteurer als "Erstgilde" in die der unbedarfte Jungspieler kommt ist so wie
sie ist eigentlich ok. Setzt meinetwegen die KP fuer "schnell" auf 60 (wie ich
das in anderen MUDs gesehen hab) herunten, aber sonst sollte da nicht mehr
geaendert werden (meine persoenliche Meinung). 

tf

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



Re^3: verhoerspruch und schlimmeres (Zino, 28. Okt 1998, 11:26:55):
~#! rn=Trancefear rt=909516548 rg=gilden.abenteurer
~#! tid=909476079
Also in meinen Augen ist der Schnellspruch einer der staerksten Sprueche der
Abenteurergilde und mit 100 KP auch nicht zu teuer. Immerhin haelt der Spruch
ganz schoen lange, und mit der richtigen Waffe beim entsprechenden Gegner
bringt das allerhand. Wuerd ich also so lassen, wie es ist.
Auch der Kampfschrei ist ausserordentlich nuetzlich, allerdings haelt der im
Verhaeltnis zu seinen Kosten von 30 KP (auch im Vergleich zum Schnellspruch)
nicht so lange, da koennte man vielleicht noch was machen.
Die Angriffssprueche sind seit der Einfuehrung des Saeurestrahls eigentlich
auch ausreichend, und wer irgendwelche anderen Schaeden (Eis etc.) machen
will, muss sich eben im MUD etwas umgucken, Tools dafuer gibts haufenweise.

Zino (zufriedener Abenteurer)

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



Re: Re: verhoerspruch und schlimmeres (Key, 29. Okt 1998, 09:17:11):
~#! rn=Karam rt=909508102 rg=gilden.abenteurer
~#! tid=909476079
Hmm oki ich laber jetzt auchmal was ...

Schnell soll also billiger werden ....
Hmm warum?
Was soll das bringen? Ausser das man es schneller hochuebt?
Ausserdem find ich den Spell reltiv stark, wenn man damit an nen NPC geht der
keinen max-Body hat.
Aber dann sollte man net schnell sondern den body aendern :)
Sonst hauste halt 2 mal die runde auf nen gegner und verfehlst ihn ;)

Key 

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



Re^3: verhoerspruch und schlimmeres (Morgoth, 29. Okt 1998, 11:22:50):
~#! rn=Key rt=909652631 rg=gilden.abenteurer
~#! tid=909476079
Gute idee, dafuer braeuhcte es ne NPC-Balance. ;-))

Morgoth for NPC-Balance

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



Re^3: verhoerspruch und schlimmeres (Acrimon, 29. Okt 1998, 18:19:01):
~#! rn=Key rt=909652631 rg=gilden.abenteurer
~#! tid=909476079
So seh ich das auch.
"schnell" ist - auch von den Kosten her gesehen - der staerkste Angriffsspruch
der Abenteurer.
Da sind im Vergleich "feuerball", "pfeil", "saeurestrahl" wesentlich teurer
als "schnell".

Acrimon, der Rote Ritter

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



Re^4: verhoerspruch und schlimmeres (Wurzel, 29. Okt 1998, 18:32:35):
~#! rn=Zino rt=909574015 rg=gilden.abenteurer
~#! tid=909476079
die offensive ist sicherlich fuer abenteurer hinreichend. was dagegen 
noch verbessert werden koennte, ist was fuer die defensive (ist sicherlich 
fuer bluemchenpfluecker auch nicht unwichtig).

wurzel (fuer jemand, der lange abenteurer gespielt hat)

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



Re^5: verhoerspruch und schlimmeres (Boing, 29. Okt 1998, 18:41:35):
~#! rn=Wurzel rt=909685955 rg=gilden.abenteurer
~#! tid=909476079
Nachdem ich mir das jetzt mal alles eine Weile angehoert habe, gebe ich
auch mal einen Kommentar dazu ab:
o Die Offensive erscheint mir ok, vor allem seit es den Saeurestrahl gibt.
  Der Schnellspruch ist zwar sehr teuer, aber auch sehr effektiv, wenn man
  ihn richtig einsetzt. Man muss halt wissen, dass das kein universell
  einsetzbarer Spruch ist. 
  Das einzige, was ich mir bei der Offensive noch zusaetzlich vorstellen
  koennte, waere ein rein mechanischer Angriff, der aber nicht so stark
  sein sollte (vielleicht irgendwas zwischen Pfeil und Feuerball).
o Wie Wurzel schon festgestellt hat hapert es etwas an der Defensive,
  hier koennte man vielleicht dem Schild irgendwie zu einer hoeheren
  Bedeutung verhelfen. Einfach die Schildparade von den Kaempfern zu
  klauen ist aber wohl auch nicht so toll. Wenn da also jemand eine
  bessere Idee hat, immer her damit.
o Wissensbeschaffung: Hier gibt es wohl das groesste Potential, schaetz
  und id sind doch ziemlich mager. Ich koennte mir vorstellen, dass mit
  steigendem Abenteurerlevel beim Schaetzen mehr Informationen rueber-
  kommen. Allerdings ist das auch nicht so einfach, ohne in die Domaenen
  der anderen Gilden einzubrechen.

Im grossen und ganzen ist die Abenteurergilde als einfache Gilde gedacht,
es soll hier keine grossen Ueb-Orgien wie in anderen Gilden geben. Im
Gegenzug kann aber auch nicht erwartet werden, dass man als Abenteurer
supermaechtig wird. 

  Boing (unsichtbar)

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



Re^6: verhoerspruch und schlimmeres (Anatol, 29. Okt 1998, 18:46:17):
~#! rn=Boing rt=909686495 rg=gilden.abenteurer
~#! tid=909476079
Warum muss eigentlich in puncto "Wissensbeschaffung" die Spirale mit
aller Gewalt nach oben getrieben werden? Die Zeit, in der man die
Anfaelligkeiten eines Gegners nicht mit 20% Genauigkeit bestimmen
konnte, in der man nicht wusste, was fuer einen Schaden der Gegner
machte (ausser, wenn sich zufaellig der Eispanzer aufloeste etc.), 
die Zeit, in der zwischen Programmierung und Wissen ein gutes
Mass Abschaetzung war, war ja nicht so uebel, oder? :o)

Aber seit Magier anfingen, auf Spielergejammer zu hoeren...

Anatol, duckt sich und findet "id" und "schaetz" der Abenteurer ok


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



Re^7: verhoerspruch und schlimmeres (Wurzel, 29. Okt 1998, 18:55:41):
~#! rn=Anatol rt=909686777 rg=gilden.abenteurer
~#! tid=909476079
was mit dem schild? hm...
fuer bluemchenpfluecker waere vielleicht sowas wie "volle deckung" ganz
okay. koennte im prinzip so aussehen: der abenteurer konzentriert sich
darauf, sich zu verteidigen, kostet also konzentrationspunkte. jeglicher
angriff, spruch z.b., bricht die konzentration. in der zeit der konzentration
auf die abwehr schlaegt der abenteurer nicht zu, selbst wenn er eine waffe
hat. die waffe wird nur zum parieren verwendet, kein angriff damit.

damit kann er sich (solange die kp reichen) relativ gut schuetzen. auch wenn
gelegentlich ein schlag durchkommt.
kosten: vielleicht 3-5 kp pro kampfrunde (diskutabel)
komponente: auf jeden fall ein schild muss getragen werden, eine parierwaffe
ggf verstaerkend.
koennte auf erfahrene abenteurer beschraenkt sein, vielleicht ab level 40.

comments?

wurzel

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



Re^8: verhoerspruch und schlimmeres (Saladin, 29. Okt 1998, 20:46:13):
~#! rn=Wurzel rt=909687341 rg=gilden.abenteurer
~#! tid=909476079
Die Frage die ich mir hier stelle: wozu sollte dieser Schutz dienen?
Um den Raum auf Details untersuchen zu koennen? - wuerde bei dem gescrolle
wohl kaum funktionieren, ansonsten waere es nur ein Spruch der einem die
Moeglichkeit bietet sich verpruegeln zu lassen.

Saladin

P.S.: Nicht boes gemeint, aber ich find wirklkich keinen Sinn drin.

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



Re^9: verhoerspruch und schlimmeres (Trancefear, 29. Okt 1998, 20:47:13):
~#! rn=Saladin rt=909693973 rg=gilden.abenteurer
~#! tid=909476079
Nunja ein Spruch der dazu dient sich verpruegeln zu lassen *hat* seine
Berechtigung. Man faengt Schlaege ab die dan andere nicht treffen...

tf

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



Re^10: verhoerspruch und schlimmeres (Saladin, 29. Okt 1998, 20:48:30):
~#! rn=Trancefear rt=909694033 rg=gilden.abenteurer
~#! tid=909476079
Ich wusste nicht das die Diskussion in den Bereich, Abenteurer mein
Pruegelzweiti geht:)

Saladin

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



Re^11: verhoerspruch und schlimmeres (Sharia, 29. Okt 1998, 20:58:34):
~#! rn=Saladin rt=909694110 rg=gilden.abenteurer
~#! tid=909476079
fuer was anderes sind sie ohnehin kaum zu gebrauchen :-)

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



schnell-spruch (Quengistu, 30. Okt 1998, 14:47:15):
Wo hier gerade ueber den "schnell-spruch" diskutiert wird:
Ich faende es hilfreich, wenn man eine Meldung bekommt, wenn der Spruch endet,
so ungefaehr "Du fuehlst Dich wieder langsamer."

Aus der Diskussion um die Spruchkosten halte ich mich als Wurstseher lieber
heraus.
Gruss, Queng*

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



Re^9: verhoerspruch und schlimmeres (Wurzel,  2. Nov 1998, 19:32:28):
~#! rn=Saladin rt=909693973 rg=gilden.abenteurer
~#! tid=909476079
eine einfache anwendung koennte sein, wenn man unwissend in ein gefaehrliches
gebiet gestolpert ist und nur noch wieder raus will. kommt in so einem
bluemchenpflueckerleben schon das ein oder andere mal vor.

das mit dem pruegelzweiti bringt wahrscheinlich nicht so sehr viel, da gibts
doch andere moeglichkeiten.

wurzel

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



Kleine Aenderung (Boing, 14. Mar 2001, 07:58:48):
Hi,

ab sofort benoetigen die Sprueche Pfeil, Feuerball und Saeurestrahl
keine freien Haende mehr. Das hat wahrscheinlich eh fast jeder mit
irgendwelchen Makros umgangen.
Dank an Anacrion fuer den Vorschlag und an Nachtwind fuer die schnelle
Genehmigung.

  Boing

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



Re: Kleine Aenderung (Qitess, 14. Mar 2001, 12:20:41):
~#! rn=Boing rt=984553128 rg=gilden.abenteurer
~#! tid=984553128
Hej, Dafuer ein RIESIGES
DDDDDDD         AAAA        NNNN     NNN KKK   KKKK EEEEEEEEEEEE  !!!!
DDDDDDDD       AAAAAA       NNNNN    NNN KKK  KKKK  EEEEEEEEEEEE  !!!!
DDD   DDD     AAAAAAAA      NNNNNN   NNN KKK KKKK   EEE           !!!!
DDD    DDD   AAAA  AAAA     NNN NNN  NNN KKKKKKK    EEEEEEEE      !!!!
DDD    DDD  AAAAAAAAAAAA    NNN  NNN NNN KKKKKKK    EEEEEEEE      !!!!
DDD   DDD  AAAAAAAAAAAAAA   NNN   NNNNNN KKK KKKK   EEE           !!!!
DDDDDDDD  AAAA        AAAA  NNN    NNNNN KKK  KKKK  EEEEEEEEEEEE 
DDDDDDD  AAAA          AAAA NNN     NNNN KKK   KKKK EEEEEEEEEEEE  !!!!

QI** glueckliche Abenteurerin...

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



Re: Re: Kleine Aenderung (Orktoeter, 14. Mar 2001, 19:02:02):
~#! rn=Qitess rt=984568841 rg=gilden.abenteurer
~#! tid=984553128
Zu dem Artikel von Boing sage ich erst mal noch nichts. Ich weiss noch nicht,
ob ich diese Vereinfachung fuer uns Abenteurer wirklich so gut finden soll,
aber zu dem Reply von Qitess ein:

Auch dieses Font haben will! Das hat ja soger Kerning!

OrkT.

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



Re^3: Kleine Aenderung (Yendi, 22. Mar 2001, 14:18:33):
~#! rn=Orktoeter rt=984592922 rg=gilden.abenteurer
~#! tid=984553128
Was issn "Kerning"?

YTY, neugierig


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



Re^4: Kleine Aenderung (Boing, 22. Mar 2001, 14:40:20):
~#! rn=Yendi rt=985267113 rg=gilden.abenteurer
~#! tid=984553128
Das naeher Zusammenruecken von Buchstaben, die sonst einen unnatuerlich gross
aussehenden Abstand haetten. Hier ist es das D und das A, die ueberschneiden
sich in der Horizontalen Ausrichtung.
  Boing

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



Re^5: Kleine Aenderung (Yendi, 22. Mar 2001, 14:42:04):
~#! rn=Boing rt=985268420 rg=gilden.abenteurer
~#! tid=984553128
Wieder was gelernt...


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



Re^6: Kleine Aenderung (Yendi, 22. Mar 2001, 14:42:40):
~#! rn=Yendi rt=985268524 rg=gilden.abenteurer
~#! tid=984553128
Das stellt dann die Frage: Wo kriegt man diesen Font?
Qitess?


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



Re^7: Kleine Aenderung (Humni, 22. Mar 2001, 14:52:33):
~#! rn=Yendi rt=985268560 rg=gilden.abenteurer
~#! tid=984553128
Haltet ihr es fuer moeglich, dass Quitess das einfach mit einem Editor gemalt
hat?

Humni
(hat aber keine Ahnung davon)

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



Re^7: Kleine Aenderung (Qitess, 26. Mar 2001, 17:03:18):
~#! rn=Yendi rt=985268560 rg=gilden.abenteurer
~#! tid=984553128
dieser font, der das huebsche ineinanderschieben hat, findet man auf jedem
guten editor.
das grosse prblem ist allerdings, dass es der phantasie, der ausdauer und der
geduld eines jeden users ueberlassen ist, wieviel und wie lange er damit
schreiben moechte.
QI**

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



Re^7: Kleine Aenderung (Anatol, 26. Mar 2001, 17:08:54):
~#! rn=Yendi rt=985268560 rg=gilden.abenteurer
~#! tid=984553128
Hm... /usr/bin/figlet

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



Re^8: Kleine Aenderung (Menace, 27. Mar 2001, 02:27:30):
~#! rn=Anatol rt=985619334 rg=gilden.abenteurer
~#! tid=984553128
nett, aber da fehlt immernoch der Font, der dann auch die Buchstaben aus den
Buchstaben zusammensetzt
zumindest bei mir ist der nicht standardmaessig dabei
gefaellt mir aber trotzdem

Menace wird den mal testen

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



Re^8: Kleine Aenderung (Yendi, 27. Mar 2001, 12:21:27):
~#! rn=Anatol rt=985619334 rg=gilden.abenteurer
~#! tid=984553128
Habe ich auf unseren Mathe-UNIXen nicht gefunden...

YTY

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



Lichtkugeln (Boing,  2. Aug 2002, 09:52:42):
Damit in dieser Rubrik auch mal was steht ... :)
Ich hab das interne Handling der Lichtkugeln etwas umgestellt, falls es
zu Problemen kommen sollte, bitte melden. Ich meine damit auch, dass die
Lichtkugeln nicht mehr verschwinden oder aehnliche Effekte ... ;)
Fuer Spieler _sollte_ sich nix geaendert haben, aber man weiss ja nie.
  Boing

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



Gildenebene (Boing,  6. Aug 2002, 13:44:52):
Auf Wunsch Samos' gibt es jetzt eine eigene Gilden-Ebene fuer
Abenteurer: -abgilde
Ich hoffe es kommt da nicht zu zu vielen Verwechslungen mit -abenteuer,
ansonsten muesste man sich einen besseren Namen ueberlegen. 
  Boing

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



Re: Lichtkugeln (Boing, 18. Aug 2002, 17:17:14):
~#! rn=Boing rt=1028274762 rg=gilden.abenteurer
~#! tid=1028274762
Es gibt ein Problem mit den Lichtkugeln, das ich morgen beheben werde. Ich
moechte euch bitten bis dahin keine Lichtkugeln manuell zu zerstoeren,
also im Muellschlucker oder so ...
  Boing

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



Re: Re: Lichtkugeln (Boing, 18. Aug 2002, 17:31:18):
~#! rn=Boing rt=1029683834 rg=gilden.abenteurer
~#! tid=1028274762
Ok, habs doch gleich gefixed, war nicht so schwer ... :) 
Es darf also wieder entsorgt werden. Dank an Liara und Vanion fuer die
Hinweise zur Fehlerbehebung.
  Boing

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



Abentuerer-Topliste? (Boing, 28. Aug 2002, 16:11:42):
Hallo,

es kam der Wunsch nach einer Abenteurer-Topliste auf, also eine Topliste,
auf der nur Abenteurer erscheinen. Ich selbst halte Toplisten fuer eher
nutzlos, aber evtl. gibt es ja ein paar Argumente, die mich ueberzeugen
koennten, das einzubauen.

  Boing

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



Re: Abentuerer-Topliste? (Weltfrieden, 28. Aug 2002, 16:21:31):
~#! rn=Boing rt=1030543902 rg=gilden.abenteurer
~#! tid=1030543902
hmm, argumente? fuer die niedrig(st)stufigen gibbet dann schneller
erfolgserlebnisse, da man dann staendig steigt und faellt... waerend das 
steigen in stufen eher manchmal langsam ist, hat der abendteuer dann aber
schon vielleicht durch einfach AP zwei plaetze inner liste gutgemacht...
motivierend und kommunikativ den leuten gegenueber die nahe bei einem sind...

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



Re: Re: Abentuerer-Topliste? (Elberet, 28. Aug 2002, 16:22:17):
~#! rn=Weltfrieden rt=1030544491 rg=gilden.abenteurer
~#! tid=1030543902
was heisst denn Erfolg?

Elbi

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



Re^3: Abentuerer-Topliste? (Muaddib, 28. Aug 2002, 16:23:21):
~#! rn=Elberet rt=1030544537 rg=gilden.abenteurer
~#! tid=1030543902
Na, ist doch klar - moeglichst schnell auf der Topliste aufsteigen. Manche
Leute denken halt in Highscorelisten.

Mua

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



Re^4: Abentuerer-Topliste? (Sarkon, 28. Aug 2002, 16:26:04):
~#! rn=Muaddib rt=1030544601 rg=gilden.abenteurer
~#! tid=1030543902
Schon allein die Tatsache, dass man hier im Spiel durch Punkte Stufen
erreichen kann fuehrt doch in die Richtung von Toplisten. Ich waere also
dafuer, die Stufe beim fingern ab sofort nicht mehr anzuzeigen :)

Sarkon

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



grummel (Weltfrieden, 28. Aug 2002, 16:27:18):
w
oben
hmm.. wie kann man einen angefangenen artikel wieder abbrechen?
und Erfolg? ehm nenn es "Erfolgserlebnis"

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



Re: grummel (Matis, 28. Aug 2002, 16:28:51):
~#! rn=Weltfrieden rt=1030544838 rg=gilden.abenteurer
~#! tid=1030544838
Ich glaube, Toplisten sind fuer eine groessere Gruppe Mudder durchaus 
ein starker Anreiz (und ja, ich gehoere dazu). Alle anderen koennen sich
gerne als moralisch ueberlegen ansehen, aber lasst uns doch diese Freude.
Jeder bezieht seine Motivation halt aus anderen Dingen ...

Matis

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



Re: grummel (Bambi, 28. Aug 2002, 16:34:33):
~#! rn=Weltfrieden rt=1030544838 rg=gilden.abenteurer
~#! tid=1030544838
Mit ~q soweit ich weiss.
Und Du kannst mit "loesche artikel <nr>" den artikel mit der Nummer <nr>
loeschen, wenn Du die entsprechende Berechtigung hast.
Naeheres: hilfe mpa

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



Re: Abentuerer-Topliste? (Grumpf, 28. Aug 2002, 17:00:20):
~#! rn=Boing rt=1030543902 rg=gilden.abenteurer
~#! tid=1030543902
Hm, hm, wenn Magier anfangen zu fragen ob sie etwas proggen sollen finde ich
das hoechst bedenklich... Macht ihr doch sonst auch nie? Spieler werden doch
sonst auch vor vollendete Tatsachen gestellt? Ich deute das nach der letzten
Diskussion auf -abg mal so das Du hoffst das keine vernuenftigen Gruende
kommen?! ;-) Aber ich finde auch eine Anfaengergilde koennte ruhig eine
Top-Liste haben, sollen sich die Luetten doch schonmal dran gewoehnen wie
"wichtig solche Listen spaeter mal werden, ausserdem muessen sie sich so nicht
umstellen wenn sie in eine andere Gilde wechseln weil afaik haben alle anderen
Gilden solche Listen? Aber ich komme ins Schwafeln, gebt den kleinen (und
grossen) AB's doch ihre Liste tut doch keinem weh?
Grumpf grumpft.

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



Re: Re: Abentuerer-Topliste? (Boing, 28. Aug 2002, 17:08:24):
~#! rn=Grumpf rt=1030546820 rg=gilden.abenteurer
~#! tid=1030543902
Ich habe meine Meinung zu dem Thema ja schon gesagt, ich halte so eine
Topliste fuer unnoetig. Ist es Dir lieber, wenn ich naechstes mal gleich
abblocke? Kann ich gerne tun, ist weniger Aufwand. Dass meine Meinung
oefters mal von Deiner abweicht kann ich nicht aendern. 
Es besteht die Moeglichkeit, dass es gute Gruende gibt, die ich nicht
bedacht habe. Darum hab ich zuerst auf dem Magierkanal und dann hier
gefragt. 
Und uebrigens haben nicht alle anderen Gilden Top-Listen, die Kaempfer-
Gilde hat zum Beispiel keine und wird auch keine bekommen. Das ist 
sozusagen Zardoz' Vermaechtnis, das ich gerne zu erfuellen bereit bin.
Zum letzten Punkt (tut doch keinem weh): Evtl. tut es halt doch einem
weh, denn das Erzeugen von Top-Listen ist immer mit lag verbunden, gerade
bei der nicht gerade geringen Anzahl von Abenteurern verbietet sich 
eine Generierung im Mud (wie das bei anderen Gilden der Fall ist). Und
das normale Toplisten-Script erzeugt schon gehoerig Lag, wie Dir andere
bestimmt versichern koennen.

  Boing

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



Re^3: Abentuerer-Topliste? (Grumpf, 28. Aug 2002, 17:11:37):
~#! rn=Boing rt=1030547304 rg=gilden.abenteurer
~#! tid=1030543902
Naja, mit solchen Argumenten wie Lag kann ich ja tatsaechlich was anfangen,
wobei generieren sich diese Listen nicht nur alle 24 Stunden einmal? Und wenn
dem so waehre koennte man das nicht auf unterschiedliche Zeiten legen, oder
gibt es sowas wie einen Top-Listen master das die sich alle zur gleichen Zeit
abgleichen? Sorry, das ich so bloed frage aber ich hab mich bisher noch nie
mit diesen Listen beschaeftigt...
Grumpf

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



Re^4: Abentuerer-Topliste? (Gloinson, 28. Aug 2002, 17:16:50):
~#! rn=Grumpf rt=1030547497 rg=gilden.abenteurer
~#! tid=1030543902
Die werden schon auf unterschiedlichen Zeiten liegen, aber viele Datensaetze
auch nicht eingeloggter Teilnehmer einzusammeln und zu ordnen kostet seine
Zeit. Und wer weiss, vielleicht laesst in dem Moment noch ein anderer Magier
was ganz anderes laufen. Et voila: Lagspitze.
Grad bei der Anzahl der freiwillig unfreiwilligen Kleinabenteurer kann eine
komplette Liste schon bedenklich viel Zeit kosten (selbst fuers Aussortieren
bei Top-100 musst Du ja alles mal anfassen). Das geht dann in die Region
der legendaeren Sique-geschriebenen-Semmel-angehaengten Gesamttopliste.

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



Re^5: Abentuerer-Topliste? (Solmyr, 28. Aug 2002, 18:35:24):
~#! rn=Gloinson rt=1030547810 rg=gilden.abenteurer
~#! tid=1030543902
Hmm,

also Toplisten an sich sind auch eher ein nettes "Spielzeug", aus dem
halt einige Spieler im MG etwas mehr machen, als es eigentlich ist.
In Anbetracht der Massen von (unfreiwilligen) Abenteurern sollte man
vielleicht ueber 'ne Zwischenloesung nachdenken, beispielsweise die
Topliste erst ab einer bestimmten Stufe laufen lassen, so dass man
sehen kann, wer von den Seher Abenteurern sich oben in der Topliste
halten kann. Kleine Spieler sind schon genug mit Questen, ZTs und dem
verstehen des Muds an sich beschaeftigt, es kann mir keiner erzaehlen,
das einem Erstie, der neu beim Mudden ist, Wert auf eine Topliste
legt.

Uebrigends find ich das Reparieren der Rage Ebene viel wichtiger :D

Fare well,
Sol*

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



Re^6: Abentuerer-Topliste? (Orktoeter, 28. Aug 2002, 18:40:21):
~#! rn=Solmyr rt=1030552524 rg=gilden.abenteurer
~#! tid=1030543902
Von mir aus kanns ruhig eine Abenteurertopliste geben, aber das sollte dann
auch eine richtige Abenteurertopliste sein, soll heissen: Es zaehlen nur die
Abenteuerpunkte (Abenteurer sein muss man natuerlich auch) :)

OrkT. sich immer noch MG I zurueckwuenschend

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



Re^3: Abentuerer-Topliste? (Elberet, 28. Aug 2002, 18:41:08):
~#! rn=Boing rt=1030547304 rg=gilden.abenteurer
~#! tid=1030543902
die kaempfer haben doch ne Topliste, oder? Auch wenn nur ein Name draufsteht
:)

Elbi

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



Re^4: Abentuerer-Topliste? (Croft, 28. Aug 2002, 18:42:12):
~#! rn=Elberet rt=1030552868 rg=gilden.abenteurer
~#! tid=1030543902
Hm. In der Kneipe ist noch ne andere ;-)

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



Re^5: Abentuerer-Topliste? (Gloinson, 28. Aug 2002, 18:43:12):
~#! rn=Croft rt=1030552932 rg=gilden.abenteurer
~#! tid=1030543902
Das ist in Wirklichkeit eine Bierschuettlertopliste. Jeder weiss, dass die da
fuehren.

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



Re^3: Abentuerer-Topliste? (Elberet, 28. Aug 2002, 19:05:15):
~#! rn=Boing rt=1030547304 rg=gilden.abenteurer
~#! tid=1030543902
zu der lagerzeugung durch die Liste hab ich mal ne Frage.

Wie sieht das aus wenn man so ne Topliste macht, wo nur die beruecksichtigt
werden, die in den letzten 4 Wochen eingelogt waren. Wuerde das dann auch lag
produzieren? Ich weiss ja nciht wie die erzeugt werden. 

Aber wenn so ne Liste durchaus lag produziert, dann wuerd ich das fuer ein
schwerwiegendes Argument halten und mich gegen eine Topliste aussprechen.

Elbi

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



Re^4: Abentuerer-Topliste? (Boing, 28. Aug 2002, 19:08:10):
~#! rn=Elberet rt=1030554315 rg=gilden.abenteurer
~#! tid=1030543902
Wenn man das Erzeugen in das normale Script einbaut (fuer die ueberall
rumliegenden Listen), dann gibt das halt einmal nachts (weiss nicht genau
wann das script laeuft) etwas zusaetzliches lag. Wieviel das ist, kann
ich nicht sagen. Nur die letzten 4 Wochen zu beruecksichtigen wird wohl
nicht viel bringen, da ja trotzdem alle files mal angefasst werden muessen.
Ich kann aber kein perl, kann also ueber die Funktionsweise des Scripts
nicht viel sagen.
  Boing

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



Re: Re: Lichtkugeln (Grumpf, 28. Aug 2002, 19:08:28):
~#! rn=Boing rt=1029683834 rg=gilden.abenteurer
~#! tid=1028274762
Wenn diese Listen ernsthaft Lag erzeugen sollten, sollte man doch mal drueber
nachdenken dann nicht nur keine neue mehr anzuschliessen sondern auch die
alten abzuklemmen?
Grumpf grumpft!

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



Re^3: Lichtkugeln (Elberet, 28. Aug 2002, 19:09:38):
~#! rn=Grumpf rt=1030554508 rg=gilden.abenteurer
~#! tid=1028274762
wenn ich richtig verstanden habe erzeugt die menge der abenteurer lag. Die
anderen Toplisten sind doch typischerweise viel kleiner.

Elbi

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



Re^4: Lichtkugeln (Grumpf, 28. Aug 2002, 19:11:39):
~#! rn=Elberet rt=1030554578 rg=gilden.abenteurer
~#! tid=1028274762
Gibt es denn wirklich SO viele von denen? dachte ab Lvl 10 suchen die sich
spaetestens ne neue "richtige" (hoehoe) Gilde?
Grumpf grumpft!

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



Re^4: Lichtkugeln (Solmyr, 28. Aug 2002, 19:12:13):
~#! rn=Elberet rt=1030554578 rg=gilden.abenteurer
~#! tid=1028274762
Deswegen meinte ich ja auch, das nur Spieler ab einem bestimmten Level
in der Topliste aufgelistet werden sollten. Oder geht der bei der Er-
zeugung der Topliste trotzdem wirklich alle xxxx Abenteurer durch?

Fare well,
Sol*

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



Re^5: Lichtkugeln (Gloinson, 28. Aug 2002, 19:12:52):
~#! rn=Solmyr rt=1030554733 rg=gilden.abenteurer
~#! tid=1028274762
Preisfrage: Wie bekommst Du das LEvel heraus?

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



Re^4: Lichtkugeln (Boing, 28. Aug 2002, 19:12:58):
~#! rn=Elberet rt=1030554578 rg=gilden.abenteurer
~#! tid=1028274762
Du musst unterscheiden zwischen den Toplisten die innerhalb des Muds
erzeugt werden (z.B. Katzenkrieger) und den normalen Toplisten (Seher,
Spieler). Die 'normalen' laufen ueber ALLE savefiles, wie es die 
internen machen weiss ich nicht, evtl. gibt's da Gildenlisten, so dass
nicht ueberall reingeschaut werden muss. Waere zumindest sinnvoll. :)
Eine interne scheidet fuer mich aus, da es halt vergleichsweise viele
Abenteurer gibt und auch keine Liste aller Abenteurer existiert. Ok,
koennte man einmal anlegen, halte ich aber nicht fuer sinnvoll. Wenn
dann muesste es ueber das Script laufen, da kommen dann halt noch ein
paar Abfragen dazu und das Sortieren/Schreiben der zusaetzlichen Liste.
  Boing

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



Re^5: Lichtkugeln (Orktoeter, 28. Aug 2002, 19:13:34):
~#! rn=Solmyr rt=1030554733 rg=gilden.abenteurer
~#! tid=1028274762
Das du erst mal zu jedem Playerfile wissen musst ob er 1. Abenteurer ist und
2. welchen Level er hat ist dir schon klar? Und irgendwo musst du diese Infos
haben...


OrkT.

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



Re^5: Lichtkugeln (Boing, 28. Aug 2002, 19:13:50):
~#! rn=Grumpf rt=1030554699 rg=gilden.abenteurer
~#! tid=1028274762
Weisst Du Grumpf, Deine Artikel und staendige Sticheleien erhoehen meine
Motivation nicht gerade ...
  Boing

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



Re^7: Lichtkugeln (Croft, 28. Aug 2002, 19:16:20):
~#! rn=Solmyr rt=1030554866 rg=gilden.abenteurer
~#! tid=1028274762
Grumpf ist schuld ;-)

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



Re^6: Lichtkugeln (Grumpf, 28. Aug 2002, 19:20:58):
~#! rn=Boing rt=1030554830 rg=gilden.abenteurer
~#! tid=1028274762
Weisst Du Boing ich bin und habe keinen Abenteurer also warum sollte es mich
treffen wenn Du mir sagst das ich Deine Motivation bremse, und wenn Du
Stichelleien liest muss ich Dir leider sagen das Du Dinge in meine Artikel
reininterpretierst die eindeutig nicht drinstehen. Aber wie gesagt man liest
was man lesen moechte wenn einem gewissen Menschen gegen den Strich gehen
oder? Nur mal so...
Grumpf

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



Re^7: Lichtkugeln (Orktoeter, 28. Aug 2002, 19:23:28):
~#! rn=Grumpf rt=1030555258 rg=gilden.abenteurer
~#! tid=1028274762
Wieso ist denn das schon wieder Re^6: Lichtkugeln ? Den hatte Solmyr doch
gerade erst mit Artikel 34 geschrieben?

OrkT, verwirrt.

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



Re^7: Lichtkugeln (Cadrach, 28. Aug 2002, 19:24:38):
~#! rn=Grumpf rt=1030555258 rg=gilden.abenteurer
~#! tid=1028274762
Man sollte mal jemand fragen der sich damit auskennt..
Ich denke man kann zu so einer Liste stehen wie man will, aber lag macht das
meines Wissens schon lang nicht mehr. Fragt vielleicht mal vorsichtig bei Hate
an.

Cad*

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



Re^7: Lichtkugeln (Jehova, 28. Aug 2002, 19:25:59):
~#! rn=Grumpf rt=1030555258 rg=gilden.abenteurer
~#! tid=1028274762
Also wenn das nur ein Perl-Skript ist, der per cronjob aufgerufen wird, dann
muesste man den Ressourcenverbrauch auch mittels Unix-Tools einschraenken
koennen. Und zur Not muss man halt ein Tool suchen, das nicht so viel CPU-Zeit
verschleudert wie Perl. Ich bin jedenfalls fuer eine Abenteurerliste und gegen
das Abklemmen bestehender Listen.

J*

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



Re^5: Abentuerer-Topliste? (Elberet, 28. Aug 2002, 19:32:36):
~#! rn=Boing rt=1030554490 rg=gilden.abenteurer
~#! tid=1030543902
so mal wieder in den richtigen thread rein

koennte man als Abenteurertopliste nicht einfach die Spielertopliste nehmen
und alle nicht Abenteurer loeschen?
dann gaebs ne Topliste und aufwand kann das nciht wirklich sein, oder?

Elbi

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



Re^6: Abentuerer-Topliste? (Orktoeter, 28. Aug 2002, 19:34:42):
~#! rn=Elberet rt=1030555956 rg=gilden.abenteurer
~#! tid=1030543902
Bin dagegen, Elberet. das waere doch nur eine Gesamttopliste (ohne
nicht-abenteurer). Wo ist das das spezifische fuer eine Abenteurertopliste?

Also ich bin dafuer das nur AP gezaehlt werden!

OrkT.

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



Re^7: Abentuerer-Topliste? (Asuka, 28. Aug 2002, 19:35:25):
~#! rn=Orktoeter rt=1030556082 rg=gilden.abenteurer
~#! tid=1030543902
Und was soll eine Abenteuertopliste, in der nur die AP gezaehlt werden
aussagen?

Asuka

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



Re^7: Abentuerer-Topliste? (Cadrach, 28. Aug 2002, 19:36:11):
~#! rn=Orktoeter rt=1030556082 rg=gilden.abenteurer
~#! tid=1030543902
Wenn Du _nur_ AP zaehlst, dann wirst Du alle Topseher auf Platz 1 haben (und
den dann ggf. auch 50 mal vergeben [wg. zweities]) weil recht viele alle APs
haben...

Cad*

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



Re^8: Abentuerer-Topliste? (Grumpf, 28. Aug 2002, 19:36:31):
~#! rn=Asuka rt=1030556125 rg=gilden.abenteurer
~#! tid=1030543902
Vielleicht denkt OrkT. (ist das eigentlich der uneheliche Sohn von Ice T?) er
waer dann mal auf PPlatz 1 einer Liste?!
Grumpf grumpft.

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



Re^8: Abentuerer-Topliste? (Orktoeter, 28. Aug 2002, 19:36:32):
~#! rn=Asuka rt=1030556125 rg=gilden.abenteurer
~#! tid=1030543902
Na was schon? Das sind die Abenteuerpunkte... und es die Abenteurergilde?
*klingel* ?

OrkT.

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



Re^9: Abentuerer-Topliste? (Lurchi, 28. Aug 2002, 19:38:48):
~#! rn=Orktoeter rt=1030556192 rg=gilden.abenteurer
~#! tid=1030543902
Abenteu_erpunkte AbenteuRergilde ... faellt dir der unterschied auf?

lurchi

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



Re^8: Abentuerer-Topliste? (Ark, 28. Aug 2002, 19:40:48):
~#! rn=Cadrach rt=1030556171 rg=gilden.abenteurer
~#! tid=1030543902
Bei einer Umbewertung der Abenteuer AP maessig (schon ein oder zweimal
passiert) werden einmal vergebene APs auch nicht abgezogen. Keine Gnade der
spaeten Geburt :-)


              *** ARK * the * Magnificent ***


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



Re^9: Abentuerer-Topliste? (Elberet, 28. Aug 2002, 19:41:24):
~#! rn=Orktoeter rt=1030556192 rg=gilden.abenteurer
~#! tid=1030543902
dann will ich ein metzelverbot fuer abenteurer, wenn die punkte eh nicht
zaehlen 

Elbi

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



Re^8: Abentuerer-Topliste? (Willow, 28. Aug 2002, 20:59:52):
~#! rn=Asuka rt=1030556125 rg=gilden.abenteurer
~#! tid=1030543902
hmmm... und was ist mit einer liste, in der nur die eps gezaehlt werden???
das Weiderl

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



Re^9: Abentuerer-Topliste? (Grimmborn, 28. Aug 2002, 21:01:20):
~#! rn=Willow rt=1030561192 rg=gilden.abenteurer
~#! tid=1030543902
Warum werden die Savewfiles nicht einfach auf eine Datenbank verteilt, dann
kann man jede beliebige Abfrage relativ leicht generieren...

GdA

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



Re: Abentuerer-Topliste? (Thargor, 28. Aug 2002, 21:54:27):
~#! rn=Boing rt=1030543902 rg=gilden.abenteurer
~#! tid=1030543902
ja ein argument waere das ich ne chance kriege
.. und wer will schon einen frustrierten Barbaren durchs MG laufen sehen

ein anderes argument waere auch abenteuerer sind eine gilde ...
.. vielleicht koennt man ja eine gilde der gildenlosen einfuehren, die nur
zufaellig dieselben spells und faehigkeiten wie die abenteurer haben .. denen
wuerde   ich mich anschliessen :)

Thargor
der Clanlose

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



Re: Re: Abentuerer-Topliste? (Boing, 29. Aug 2002, 13:11:26):
~#! rn=Thargor rt=1030564467 rg=gilden.abenteurer
~#! tid=1030543902
Haengt ...
  Boing
PS: Solmyr, ich hoffe Du verzeihst mir, dass ich einen Artikel von Dir
 loeschen musste ... :)

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



Re^3: Abentuerer-Topliste? (Solmyr, 29. Aug 2002, 15:18:52):
~#! rn=Boing rt=1030619486 rg=gilden.abenteurer
~#! tid=1030543902
Np, ich hab ja nix "boeses" geschrieben, denke ich... :)

Fare well,
Sol*

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



Re: Re: Abentuerer-Topliste? (Roland, 30. Aug 2002, 22:09:26):
~#! rn=Thargor rt=1030564467 rg=gilden.abenteurer
~#! tid=1030543902
hmmmm

wiederspruch in sich .... oder ?
   ' vielleicht koennt man ja eine 'GILDE' der gildenlosen einfuehren '

Roland nachdenklich.

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



Re^3: Abentuerer-Topliste? (Alpha, 17. Sep 2002, 23:28:45):
~#! rn=Roland rt=1030738166 rg=gilden.abenteurer
~#! tid=1030543902
Reicht es fuer eine AbenteuererListe nicht aus, dass wann immer ein Abenteurer
die Gilde betritt, geguggt wird, ob er auf der Liste steht, wenn ja ob er
inzwischen mehr Punte hat als der Player ueber ihn, das solange, bis es auf
einen Spieler mit mehr Punkten auf der Liste trifft? Das fasst doch selten
mehr als 2-3 Files an und macht auch kein lag...

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



Re^4: Abentuerer-Topliste? (Karis, 18. Sep 2002, 23:41:49):
~#! rn=Alpha rt=1032298125 rg=gilden.abenteurer
~#! tid=1030543902
Fast gewinnt man den Eindruck, dass Du die A-Gilde 
nciht ernst nimmst.
Karis

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



Re^5: Abentuerer-Topliste? (Imda, 19. Sep 2002, 00:55:31):
~#! rn=Karis rt=1032385309 rg=gilden.abenteurer
~#! tid=1030543902
Nuja, is ja auch ned ernstzunehmen...
Aber sone Topliste faend ich ganz hervorragend. Endlich mal was fuer mien Ego.
Imda. Will auch mal ganz oben stehn.

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



Re^6: Abentuerer-Topliste? (Thargor, 19. Sep 2002, 19:56:10):
~#! rn=Imda rt=1032389731 rg=gilden.abenteurer
~#! tid=1030543902
Natuerlich ist die Abenteurer-Gilde ernstzunehmen. Was ist
so ungewoehnlich an den div. Faehigkeiten, die diese Gilde vermittelt?

Und wenn es denn tatsaechlich so sein sollte, dass es in der Abenteurergilde
schwerer ist auf den Top-Listen nach oben zu kommen, dann sind 
die Abenteurer die wahre Elite im MorgenGrauen

Thargor, der Barbar
Mitglied der elitaeren Abenteurergilde
:-)

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



Karten fuer Abenteurer (Knudsson, 29. Apr 2003, 15:34:22):
Guten Morgen,

boing ich hoffe du hast noch Lust etwas am Konzept der Abenteurer zu arbeiten.
Ich waere naemlich fuer einen Kartenraum in der AB Gilde, der natuerlich nur
den Mitgliedern der Gilde zur Verfuegung steht und je nach GL andere Karten
zur Verfuegung stellt. Karten koennen und sollen von Abenteurern selbst
gepostet werden, alle natuerlich im ASCII Format, also so Karten wie die von
PV oder moron.
Natuerlich sollten die Karten nicht zu detailiert sein und evtl. von einem
Kartenmeister aus der Gilde reviewed werden. Ich denke das wuerde zum Konzept
eines Abenteurers passen, wuerde die Gilde auch ueber den Anfaenger hinaus
interessant machen und ich denke es ist keine allzu grosse Gefahr fuer das
Spielgleichgewicht.

Knudsson.

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



Re: Karten fuer Abenteurer (Roland, 29. Apr 2003, 15:50:08):
~#! rn=Knudsson rt=1051623262 rg=gilden.abenteurer
~#! tid=1051623262
und was soll das das bringen .. das sich jetzt alle nen abenteuer zuechten um
an karten zu kommen die sie evtl noch cniht selber hatten? oder zb. um neuen
den weg durch das polar weisen ,,, ... 

hmmm ne ich finde jeder solte sich seine karten selber machen .. sofern er den
bracht ..

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



Re: Re: Karten fuer Abenteurer (Croft, 29. Apr 2003, 15:50:52):
~#! rn=Roland rt=1051624208 rg=gilden.abenteurer
~#! tid=1051623262
Zumal es sehr schoene Karten im Web gibt.

Croft

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



Re^3: Karten fuer Abenteurer (Grimmborn, 29. Apr 2003, 15:51:38):
~#! rn=Croft rt=1051624252 rg=gilden.abenteurer
~#! tid=1051623262
Genau. Guggst Du zum Beispiel hier: http://www.maps.ethz.ch/

GdA

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



Re: Re: Karten fuer Abenteurer (Knudsson, 29. Apr 2003, 16:06:31):
~#! rn=Roland rt=1051624208 rg=gilden.abenteurer
~#! tid=1051623262
Sind hier im MG nur PowerGamer anzutreffen? Wage ich zu bezweifeln. Die Karten
sollen keinen Loesungsweg beschreiben. Waere schliesslich auch ein Regelbruch.
Dass sich dann jeder nen Ab-Zweitie zieht ist glaube ich unrealistisch, rennt
auch nicht jeder mit einem Bank-Zweitie oder nem Zweitie generell herum.
Der Kartenraum kann aber als Anlaufstelle fuer Anfaenger genutzt werden, die
dann grobe Einblicke in die Welt erhalten, aber feiner als durch die Karten
auf www.mg.mud.de. Das es Karten im Web gibt glaube ich gerne, aber wieviel
davon ist Insider wissen? Ausserdem stehen diese nicht zur Diskussion, da sie
nicht in-play stehen und somit IMHO nichts zum flair des Spieles beitragen.
Der Kartenraum koennte also als Anlaufstelle dienen und das Konzept des
Abenteurers erweitern, denn so manch Abenteurer wird sich sicher damit
beschaeftigen Karten zu zeichnen und sich an i anderen Karten zu erfreuen.

Knudsson.

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



Re^3: Karten fuer Abenteurer (Foobar, 29. Apr 2003, 17:27:06):
~#! rn=Knudsson rt=1051625191 rg=gilden.abenteurer
~#! tid=1051623262
Wie genau sieht denn das "Konzept der Abenteurer" aus?

Gruss,

   Foobar

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



Re^4: Karten fuer Abenteurer (Knudsson, 29. Apr 2003, 17:32:43):
~#! rn=Foobar rt=1051630026 rg=gilden.abenteurer
~#! tid=1051623262
Also laut hilfe abenteurer sind sie ein Gilde in der man die Moeglichkeit
haben soll, einen groben Ueberblick ueber das MG zu bekommen um sich dann
letzten Endes fuer eine andere Gilde zu entscheiden. Aber ich denke Abenteurer
zu sein, sollte mehr sein, als nur Sprungbrett. Ich denke da eher an z.B.
Bilbo aus The Hobbit. Der Karten sammelte und studierte und dann letzten Endes
auszog, des Abenteuers willen und nicht des Ruhmes wegen. Bei Abenteurer denke
ich daran die Strassen und Wege des MG zu erkunden und sich mal an einem
schoen Ort zu ergoetzen, und das sollte 'interessanter' sein als das stupide
p's sammeln. Ein Leben halt um das MG zu durchqueren, des durchquerens Wegen.
Vielleicht ja eine zu sehr rollenspielerische Angehensweise.

Knudsson.

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



Re^5: Karten fuer Abenteurer (Karis, 29. Apr 2003, 17:58:28):
~#! rn=Knudsson rt=1051630363 rg=gilden.abenteurer
~#! tid=1051623262
Ich waere der letzte, der gegen eine Erweiterung der AB-Gilde stimmt. Ich
finde auch Deine
Idee recht gut und stimmig. 
Allerdings... laut Boing ist die AB-Gilde eine Einsteigergilde mit der
Intention, spaeter mal zu wechseln. Eventuell wird deshalb nichts weiter an
der Gilde
gedreht. Nicht, dass wir vielleicht mal 
ncoh staerker als Zaubis werden oder so .. ;)

Karis

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



Re^5: Karten fuer Abenteurer (Gnome,  1. Mai 2003, 13:37:57):
~#! rn=Knudsson rt=1051630363 rg=gilden.abenteurer
~#! tid=1051623262
bist du zu faul, um eigene karten zu zeichnen?

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



Re^6: Karten fuer Abenteurer (Deepblue,  7. Mai 2003, 22:12:39):
~#! rn=Gnome rt=1051789077 rg=gilden.abenteurer
~#! tid=1051623262
Replay auf den letzten Artikel und Urlaubsbedingt ne Woche spaeter: 
Wenn ich Knudsons Idee mal weiterdenke, koennte der Kartenraum doch Karten von
Schaetzen, und aehnlichem enthalten, die dann zu Gildenquests oder eventuell
zu Schriftrollen, die einem die AB-Gildenspells lehren, fuehren

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



Re^7: Karten fuer Abenteurer (Zarniya,  8. Mai 2003, 09:46:54):
~#! rn=Deepblue rt=1052338359 rg=gilden.abenteurer
~#! tid=1051623262
Hmmm ein Wiederholungsspiel? :-)

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



Re^7: Karten fuer Abenteurer (Knudsson,  8. Mai 2003, 09:59:53):
~#! rn=Deepblue rt=1052338359 rg=gilden.abenteurer
~#! tid=1051623262
Ist zwar nicht das, was ich mir zunaechst drunter vorgestellt hatte, klingt
aber an sich auch nicht schlecht.

knudsson.

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



Re^8: Karten fuer Abenteurer (Bambi,  8. Mai 2003, 16:47:28):
~#! rn=Knudsson rt=1052380793 rg=gilden.abenteurer
~#! tid=1051623262
Papier ist geduldig...
Wirst Du Magier und setzt es um? :)

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



Aenderung der Angriffszauber (Boing,  1. Jul 2005, 16:05:57):
Hallo,
die Angriffszauber der Abenteurer wirken jetzt aus hinteren Kampfreihen
besser.
Vorschlag und Lib-Aenderung stammt von Humni, Dank und Flames also bitte
an ihn ... ;)
  Boing

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



Aenderung der Lichtkugeln (Boing,  6. Dez 2005, 10:14:48):
Hi,
es sollte jetzt keinen Fehler mehr geben, wenn man eine Lichtkugel erzeugt
und zu viele Objekte im Inventar hat. Falls es Probleme gibt, sagt mir bitte
Bescheid.
  Boing

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



Re^24: Aenderungen: Teil I (Boing, 20. Mar 2006, 16:31:11):
~#! on=Chagall ot=1142867704 og=gilden.kaempfer
~#! rn=Darklor rt=1142867480 rg=gilden.kaempfer
~#! tid=1141772614
Eventuell waere es angebracht, mal die jetzige Bindung der Abenteurerspells
an die Stufen zu ueberdenken.

MC

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



Re^25: Aenderungen: Teil I (Boing, 20. Mar 2006, 16:31:12):
~#! on=Darklor ot=1142867882 og=gilden.kaempfer
~#! rn=Chagall rt=1142867704 rg=gilden.kaempfer
~#! tid=1141772614
Wozu? - Um die Abenteurer noch schlechter zu machen?

Darklor

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



Re^26: Aenderungen: Teil I (Boing, 20. Mar 2006, 16:31:13):
~#! on=Sharia ot=1142867997 og=gilden.kaempfer
~#! rn=Darklor rt=1142867882 rg=gilden.kaempfer
~#! tid=1141772614
Eine Gilde ist doch immer nur so schlecht wie diejenigen die darin spielen
oder ? Es kommt doch immer einfach nur drauf an was man draus macht :)

LG Sharia



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



Re^26: Aenderungen: Teil I (Boing, 20. Mar 2006, 16:31:14):
~#! on=Chagall ot=1142868007 og=gilden.kaempfer
~#! rn=Darklor rt=1142867882 rg=gilden.kaempfer
~#! tid=1141772614
Gehst Du eigentlich grundsaetzlich davon aus, dass Aenderungen 
schlecht sind?

Ich dachte eher daran, zumindestens schaetz und identifziere etwas
frueher fuer Abenteurer nutzbar zu machen. Aber das hat die
GB zu entscheiden.

MC

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



Re^27: Aenderungen: Teil I (Boing, 20. Mar 2006, 16:31:15):
~#! on=Darklor ot=1142868121 og=gilden.kaempfer
~#! rn=Chagall rt=1142868007 rg=gilden.kaempfer
~#! tid=1141772614
Ach das sind Erfahrungswerte... ;) - Aber das faend ich schon gut, denn genau
fuer diese Skills war ich am Anfang Katzenkrieger...

Darklor

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



Re^25: Aenderungen: Teil I (Boing, 20. Mar 2006, 16:31:16):
~#! on=Zook ot=1142868609 og=gilden.kaempfer
~#! rn=Humni rt=1142867694 rg=gilden.kaempfer
~#! tid=1141772614
Aber die Atmosphaere der Abenteurer ist bis Level 5 wohl deutlich schwaecher,
oder?

Zook.

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



Re^26: Aenderungen: Teil I (Boing, 20. Mar 2006, 16:31:51):
~#! rn=Boing rt=1142868676 rg=gilden.abenteurer
~#! tid=1141772614
Ich hab das mal verlegt ... das muss ja nicht in der Kaempfer-Rubrik
diskutiert werden.
  Boing

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



Re^27: Aenderungen: Teil I (Darklor, 20. Mar 2006, 16:33:55):
~#! rn=Boing rt=1142868711 rg=gilden.abenteurer
~#! tid=1141772614
Ok.

Welche Atmosphaere?

Darklor

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



Re^28: Aenderungen: Teil I (Humni, 20. Mar 2006, 16:34:43):
~#! rn=Darklor rt=1142868835 rg=gilden.abenteurer
~#! tid=1141772614
Ahso. Ok, das streite ich hingegen nicht ab.

Ich dachte, ihr diskutiert ueber die Kampfkraft.

Humni

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



Re^29: Aenderungen: Teil I (Orktoeter, 20. Mar 2006, 18:18:18):
~#! rn=Humni rt=1142868883 rg=gilden.abenteurer
~#! tid=1141772614
Ich lese hier schon wieder etwas von Kampfkraft.. das ist doch ein Questmud,
da kann man die Abenteurer auch ruhig langsamer zu Spells kommen lassen (ok,
Licht dafuer noch frueher wuerde evtl. das Questen fuer Abenteurer
erleichtern).

OrkT.

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



Re^30: Aenderungen: Teil I (Croft, 20. Mar 2006, 18:23:12):
~#! rn=Orktoeter rt=1142875098 rg=gilden.abenteurer
~#! tid=1141772614
Und das Identifizieren reicht ja auch erst spaeter.  Die Questbelohnungen
laufen ja nicht weg ("Was macht XYZ?" "Identifizier es." "Kann ich noch
nicht." "Na dann musst du wohl warten bis du es lernst.").

Croft

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



Re^28: Aenderungen: Teil I (Knurps, 20. Mar 2006, 19:02:15):
~#! rn=Boing rt=1142868675 rg=gilden.abenteurer
~#! tid=1141772614
Guter Hinweis, die Katzenkrieger stehen ja allen offen, (mit Ausnahme der
Delfen vielleicht). Kann ich jedem nur empfehlen, lieber Katzenkrieger als
Abenteurer zu spielen. Mag zwar etwas seltsam anmuten, einen
Zwergenkatzenkrieger zu haben, aber zum Seher spielt man damit netter und
entspannter.

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



Harte oder weniger harte Monster - was schult Waffenskills? (Masul,  7. Okt 2006, 11:12:25):
Nachdem ich letztens die Einschaetzung eines Kaempfers zu meinen Waffenskills
gesehen habe, moechte ich diese nun trainieren. Das geht jawohl nur durch
Kaempfe. Und in diesem Zusammenhang meine Frage: Bei welchen Kaempfen lerne
ich am meisten?
Lerne ich am meisten im Kampf gegen harte Monster? Oder lerne ich genauso viel
im Kampf gegen weniger harte Monster? Geht der Lerneffekt pro Kampfrunde, pro
effektiver Schadenspunkte oder wie ist der Zusammenhang zwischen Kampf und
Lernen der Waffenskills?
Und zu guter letzt: Wo kann ich das nachlesen? Unter "hilfe waffenskills" habe
ich nichts genaues gefunden.

Fuer eine Antwort dankbar
Masul

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



Re: Harte oder weniger harte Monster - was schult Waffenskills? (Darklor, 10. Okt 2006, 23:11:47):
~#! rn=Masul rt=1160212345 rg=gilden.abenteurer
~#! tid=1160212345
Was hilft is: Viel metzeln!

Darklor

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



Re: Re: Harte oder weniger harte Monster - was schult Waffenskills? (Croft, 10. Okt 2006, 23:13:33):
~#! rn=Darklor rt=1160514707 rg=gilden.abenteurer
~#! tid=1160212345
Und zu einfach duerfen die Gegner nicht mehr sein.  Daran bin ich schuld ,-)

Croft

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



Re^3: Harte oder weniger harte Monster - was schult Waffenskills? (Darklor, 11. Okt 2006, 00:24:08):
~#! rn=Croft rt=1160514813 rg=gilden.abenteurer
~#! tid=1160212345
Was hast Du angestellt?

Darklor

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



Re^4: Harte oder weniger harte Monster - was schult Waffenskills? (Croft, 11. Okt 2006, 00:47:15):
~#! rn=Darklor rt=1160519048 rg=gilden.abenteurer
~#! tid=1160212345
Etwas auf -Moerder gescrollt.

Croft

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



Lichtkugeln (Boing,  1. Feb 2008, 13:53:57):
Hallo,
die Abenteurerlichtkugeln machen jetzt auch wieder richtig Licht.
Danke an Humni fuer die schnelle Genehmigung und an Zephyr fuer
Die Mitteilung dass da was im Argen liegt.
  Boing

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



Neueste Untersuchungen des Sphaerengefueges (Zesstra, 29. Okt 2012, 21:22:29):
Werte Abenteurer,

in Folge einer zu starken Konzentration magischer Essenz (*) am vergangenen
Wochenende kam es zu einer Schwaechung des Sphaerengefueges im Bereich der
Pizza. Welche Folgen dies fuer uns alle hat, offenbart sich bislang nur
langsam.
Ein soeben bemerkter Effekt gehoert zu den eindeutig zu den angenehmeren des
Lebens - zumindest fuer euch: Die Nutzung der allgemein als Hellsichtsmagie
bekannten Kraefte erfordert weniger Finesse und geistige Reife. Zukuenftig
werden daher auch die weniger erfahrenen unter euch sich Ihrer bedienen
koennen.

(*) Die Spekulation, dass dies an der Zusammenkunft zuvieler Erzmagier zu tun
habe, entbehrt jeglicher Grundlage und stoesst in informierten Kreisen auf
breite Ablehnung.

gez.
Jenny Weissast
(Kuratorin der Gilde der Geistigen Kraft zu Taramis)

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



Re: Neueste Untersuchungen des Sphaerengefueges (Zesstra, 29. Okt 2012, 21:22:36):
~#! rn=Zesstra rt=1351542149 rg=gilden.abenteurer
~#! tid=1351542149
Haeh?

Kann mir das mal jemand uebersetzen?

Hero
(Abenteurer)

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



Re: Re: Neueste Untersuchungen des Sphaerengefueges (Zesstra, 29. Okt 2012, 21:22:45):
~#! rn=Zesstra rt=1351542156 rg=gilden.abenteurer
~#! tid=1351542149
Werter *raeusper* Hero,

die Ehrenwerte Magisterin Weissast meint damit, dass die Zaubersprueche
"identifiziere" und "schaetz" nun auch von Wesen mit weniger Lebenserfahrung
gelernt werden koennen.
An sich sagt sie auch noch viel mehr, aber das scheint jetzt zunaechst eher
fuer die in den arkanen Kuensten interessierteren Kreisen von Interesse zu
sein, bis klarer wird, welche Folgen besagte Effekte wirklich haben.

gez.
Randar Tobis
(Kurator der Gilde der Geistigen Kraft zu Taramis)

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



Schadensmagie fuer Anfaenger... (Zesstra, 30. Okt 2012, 00:05:01):
Lieber Owen,

Du hattest mich doch gebeten, Ausschau zu halten nach einem Angriffszauber
fuer Deine kleinen Schuetzlinge.
Ich bin da zwar schon vor laengerer Zeit ueber ein kleines Spruechlein
gestossen, welcher von der Wirkung vielleicht in Frage kommt. Ich hielt es
jedoch bislang gar nicht wert der Erwaehnung, denn trotz eher bescheidenem
Schaden am Gegner fiel es meinen Testpersonen so schwer, die korrekte
Manipulation der magischen Matrizes zu erlernen, dass sie effektivere Sprueche
in Angriff nahmen, bevor sie an die Beherrschung dieses Spruches denken
konnten.
Die juengsten Veraenderungen (Jenny Weissast berichtete) sorgten jedoch
kurioserweise fuer eine signifikante Simplifizierung der notwendigen astralen
Symbole. Es sollte euch nun ziemlich leicht fallen, mit dem Steinschlag
umzugehen.

gez.
Tulin
(Kurator Impetus der Gilde der Geistigen Kraft zu Taramis)

P.S. Vergesst nicht, die vielversprechendsten Abenteurer mal ins Warok zu
schicken. Du weisst ja schon...

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



Zauberspruchliste (Zesstra,  2. Nov 2012, 22:34:00):
Huhu,

ich habe auf vielfachen und berechtigten Wunsch hin die Zauberspruchliste in
der Abenteurergilde (und allen anderen Gilden, die keine eigene haben) mal
etwas aufgebohrt. Und zwar so, dass die Sprueche a) nach Lernstufe sortiert
sind und b) die Lernstufe auch mit angegeben wird.

Zesstra

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



Mist... ich konnte was lernen? Warum sagt mir das keiner? (Zesstra,  3. Nov 2012, 14:56:50):
Huhu,

damit das o.g. nicht mehr vorkommt, habe ich etwas gebastelt.
Wenn ein Abenteurer seine Stufe erhoeht und danach die Vorraussetzungen
erfuellt, einen neuen Zauberspruch zu lernen, dann bekommt er eine Meldung,
die ihn darauf hinweist.
Dies funktioniert unabhaengig davon, in welcher Gilde der Abenteurer seinen
Level erhoeht.

Zesstra

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



Re: Neueste Untersuchungen des Sphaerengefueges (Zesstra,  3. Nov 2012, 15:27:48):
~#! rn=Zesstra rt=1351542149 rg=gilden.abenteurer
~#! tid=1351542149
Liebe Abenteurer

vor kurzem erreichte uns folgende Botschaft aus Taramis:

----
Sehr geehrter Herr Owen,

Ihr habt sicherlich von den juengst von Kuratorin Weissast berichteten
Veraenderungen in den magischen Eigenschaften der Pizza gehoert.

Unsere Untersuchungen sind inzwischen weiter vorangeschritten und wir haben
festgestellt, dass es durchweg zu Veraenderungen der Lernschwierigkeiten von
Zauberspruechen der Abenteurergilde gekommen ist.

Um zu vermeiden, dass es vermehrt zu Unfaellen und Missgeschicken kommt,
wuerden wir empfehlen, die magische Ausbildung eurer Gildenmitglieder
entsprechend anzupassen.

gez.
Llysrathe
(Erzmagistra der Gilde der Geistigen Kraft zu Taramis)
----

Wir haben diese Angelegenheit geprueft und festgestellt, dass dieser Bericht
der Wahrheit entspricht. Wir haben uns entschlossen, der Empfehlung der
Zauberergilde zu folgen.

In Zukunft werden die Zaubersprueche unserer Gilde mit Erreichen der folgenden
Gildenraenge erlernbar sein:
steinschlag          1
identifiziere        3
licht                6
schaetz              8
pfeil                11
ausweichen           13
kampfschrei          16
feuerball            18
schnell              21
saeurestrahl         28

Lieben Gruss und gute Reisen,
Owen Braddon

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



Re: Re: Neueste Untersuchungen des Sphaerengefueges (Zesstra,  3. Nov 2012, 15:27:57):
~#! rn=Zesstra rt=1351952868 rg=gilden.abenteurer
~#! tid=1351542149
Huhu,

wie Owen berichtet hat, werden die Zaubersprueche der Abenteurer in Zukunft
auf etwas anderen Leveln gelehrt.
Dies dient dazu, die Sprueche besser ueber die Stufen bis knapp 30 zu
verteilen.

Bevor ihr schreit, dass damit der Anpassung der Level wirkungslos waere: die
Sprueche sind jetzt bis auf eine (unveraenderte) Ausnahme mit weniger
Stufenpunkten als frueher zu erlernen - zumeist sogar sehr deutlich.
Die Veraenderung der Lernlevel der Sprueche haette es auch ohne die leichter
erreichbaren kleinen Level gegeben.

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



Meldung ueber das Ende von schnell (Zesstra,  4. Sep 2017, 19:15:14):
Huhu allerseits...

ich habe mal einen Gildenmagier vertreten und in der Abenteurergilde dem
Spruch "schnell" eine Meldung kurz vor Ende der Wirksamkeit dieses Spruches
eingebaut.
Vielen Dank fuer den freundlich geaeusserten Wunsch. :-)

Zesstra

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



Re: Meldung ueber das Ende von schnell (Zesstra,  5. Sep 2017, 20:56:01):
~#! rn=Zesstra rt=1504545314 rg=gilden.abenteurer
~#! tid=1504545314
Na, sowas, da war noch ein kleiner Kaefer drin. Jetzt sollte es aber gehen.
;-)

Zesstra

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



