diff --git a/OLD.balance b/OLD.balance
new file mode 100644
index 0000000..f86c742
--- /dev/null
+++ b/OLD.balance
@@ -0,0 +1,7600 @@
+balance-Gruppe (Catweazle, 20. Okt 1998, 12:13:15):
+Moin!
+
+Aus aktuellem Anlass habe ich mit mal erlaubt die (leere!) Zeitungsrubrik
+'gildenbalance' durch eine neue namens 'balance' zu ersetzen. Ich hoffe es ist
+einsichtig, wozu sie gut sein soll.
+
+Yours truly,
+     Catweazle (droht immer noch :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: balance-Gruppe (Teddy, 20. Okt 1998, 12:18:58):
+~#! rn=Catweazle rt=908885595 rg=balance
+~#! tid=908885595
+Ah, das ist doch mal ne Aktion, die Rubrik sollte schon laenger gegruendet
+werden, damit wir auch mal Entscheidungen veroeffentlichen koennen.
+
+Teddy
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: balance-Gruppe (Morgoth, 20. Okt 1998, 12:20:40):
+~#! rn=Teddy rt=908885938 rg=balance
+~#! tid=908885595
+War es nicht vor laengerer Zeit mal im Gespraech, Eure Sachen oeffentlich zu
+machen und habt ihr da nicht gezetert und gejammert, das dies nicht moeglich
+sei? Ich meine bei dieser diskussioin waren Patryn, Boing, ein anderer aus dem
+Team und ich anwesend.
+M* gruebelt....
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: balance-Gruppe (Teddy, 20. Okt 1998, 12:22:12):
+~#! rn=Morgoth rt=908886040 rg=balance
+~#! tid=908885595
+Ich weiss leider nicht, was du meinst, vielleicht weil ich ja scheinbar auch
+nicht anwesend war, jedenfalls wollten wir ne Rubrik haben, in die wir
+beschluesse schreiben koennen, nicht Diskussionen.
+Ist ja hiermit erstmal gegruendet.
+
+Teddy
+P.S.: Esd war zumindest im gespraech sowas zu machen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: balance-Gruppe (Zephyr, 20. Okt 1998, 12:22:18):
+~#! rn=Morgoth rt=908886040 rg=balance
+~#! tid=908885595
+Du solltest untrscheiden zwischen unseren Diskussionen und unseren
+Entscheidungen. Die Entscheidungen sollen durchaus bekannt gemacht
+werden, aber ich (u.a.) weigere mich, saemtliche Diskussionen 
+oeffentlich zu fuehren.
+C4
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: balance-Gruppe (Morgoth, 20. Okt 1998, 12:23:36):
+~#! rn=Zephyr rt=908886138 rg=balance
+~#! tid=908885595
+Soweit ich mich erinnern kann, ging es um Antraege und Beschluesse, nicht um
+Diskussionen. Das waere ja dann hiermit erledigt.
+
+M*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: balance-Gruppe (Teddy, 20. Okt 1998, 12:24:10):
+~#! rn=Morgoth rt=908886216 rg=balance
+~#! tid=908885595
+ja, dann koennen wir ja aufhoeren darueber zu diskutieren. ;-)
+
+Teddy, muellt mal rum ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: bumis (Teddy, 20. Okt 1998, 13:52:04):
+~#! rn=Snibril rt=908891451 rg=entwicklung
+~#! tid=908866477
+Zum spendieren? ;)
+
+Teddy
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: bumis (Teddy, 20. Okt 1998, 13:55:43):
+~#! rn=Dieder rt=908891612 rg=entwicklung
+~#! tid=908866477
+Naja, nen Schuettler kann jetzt halt nichtmehr umsonst rumlaufen und seine MPs
+sparaen, er muss jetzt tatsaechlich rein MP-technisch alle 35 Kampfrunden
+tanken laufen, das ist natuerlich extrem hart, weil er dadurch auch nur noch
+70 mal krachen bis schmettern macht fuer einmal MPs tanken.
+
+Teddy
+Wer die Ironie nicht gesehen hat, sie war da ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: bumis (Alpha, 20. Okt 1998, 14:02:18):
+~#! rn=Teddy rt=908891743 rg=balance
+~#! tid=908866477
+Hmmmm...nur mal so nebenbei...mit welchen SuperShakys habt ihr geredet, die
+JEDE Runde Krachen und Schmettern? Die Bumis haben bis jetzt unsere miesen
+Spells und Waffenkuenste wettgemacht, aber sooo gut waren sie nicht in meinen
+beste Traeumen! Die Entscheidung des BalanceTeams ist da wohl aufgrund
+falscher Daten gefallen. Koenntet ihr Euch nicht nochmal genauer erkundigen,
+mit DurchschnittsShakys reden, und eine erneute Entscheidung treffen?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: bumis (Snibril, 20. Okt 1998, 14:04:56):
+~#! rn=Alpha rt=908892138 rg=balance
+~#! tid=908866477
+
+>Spells und Waffenkuenste wettgemacht, aber sooo gut waren sie nicht in 
+>meinen beste Traeumen!
+alpha, wenn du eh nicht damit umgehen kannst, was heulst du dann hier rum?
+Snibril
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: bumis (Alpha, 20. Okt 1998, 14:06:24):
+~#! rn=Snibril rt=908892296 rg=balance
+~#! tid=908866477
+Mit Bumis 'umgehen'? Mehr als beruhige machen und die Dinger auf den Gegner
+fangwerfen kann man damt dochnet.
+Alpha.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: bumis (Teddy, 20. Okt 1998, 14:27:42):
+~#! rn=Alpha rt=908892138 rg=balance
+~#! tid=908866477
+Sorry, wenn ich dich enttaeuschen muss, aber es waren keine Supershakys und
+ich war dabei.
+Es war halt nicht Nars, ich nehm ganz normale Standardmonster zum Vergleich,
+ohne allzu hohen Body und ohne Anfaelligkeiten/Resistenzen.
+
+Teddy
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: bumis (Mahatmu, 20. Okt 1998, 15:11:50):
+~#! rn=Teddy rt=908893662 rg=balance
+~#! tid=908866477
+Ach, Alpha heult immer rum. Ich hab ihm vor einem halben Jahr beigebracht,
+Bumis zu nutzen und er rafft es bis jetzt nicht.
+
+Gloin ... musste Alpha auch irgendwann mal ein paar Kampfbindings schreiben.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: bumis (Trancefear, 20. Okt 1998, 15:25:33):
+~#! rn=Mahatmu rt=908896310 rg=balance
+~#! tid=908866477
+Vielleicht sollte der Umgang mit dem Bummi *tatsaechlich* erlernbar sein,
+aehnlich wie das beim SMS ist. Mit einer umgekehrten
+Konzentrations-Verbrauchskurve - andersrum als bei manchen Gilden braucht man
+umso mehr KP je besser man das Teil beherrscht.
+
+tf
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: bumis (Hood, 20. Okt 1998, 15:35:15):
+~#! rn=Alpha rt=908892138 rg=balance
+~#! tid=908866477
+du willst dich doch nicht etwa zum durchschnitt zaehlen, alpha?
+wenn die balance anhand deiner faehigkeiten bemessen werden, dann wuerde
+aus dem bienenstachel ein vollstrecker werden...
+
+------
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: bumis (Saladin, 20. Okt 1998, 16:22:18):
+~#! rn=Trancefear rt=908897133 rg=balance
+~#! tid=908866477
+Wuerde auch fuer einen Lernskill bei den Bumerangs plaedieren. Magiepunkte
+erscheint mir doch etwas unlogisch zu sein.
+
+Saladin
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: bumis (Teddy, 20. Okt 1998, 16:24:43):
+~#! rn=Saladin rt=908900538 rg=balance
+~#! tid=908866477
+Nenn sie halt Konzentrationspunkte, du verwendest einen Teil deiner
+Konzentration auf das Werfen des Bumis
+
+Teddy
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: balance-Gruppe (Tilly, 21. Okt 1998, 02:50:56):
+~#! rn=Teddy rt=908885938 rg=balance
+~#! tid=908885595
+Moin,
+wenn tatsaechlich Entscheidungen der Balance-Team veroeffentlicht werden
+sollen, wuerde es mir zumindest sehr gefallen, wenn Begriffe wie SpellDefend,
+WC und aehnliche dort nicht auftauchen. Es stoert mich zum einen immer wieder,
+wenn Spieler damit um sich werfen (ob sie wissen, was sie sagen sei mal
+dahingestellt) und zum anderen gibt es immer noch Spieler (der groessere Teil
+hoff ich), die davon nichts wissen wollen, denen es um das Spiel geht. 
+
+ Tilly (wartet auf die ersten 'heul doch's ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: balance-Gruppe (Lyra, 21. Okt 1998, 05:55:43):
+~#! rn=Tilly rt=908938256 rg=balance
+~#! tid=908885595
+Ja Tilly, bin dafuer. Ich habe zwar mal in die Docu geschaut und kenn einge
+Begriffe, weiss aber nicht, was P_BODY=200 oder so bedeutet. Ich bin bestimmt
+nicht die einzige. Manchmal wuerde auch eine kurze Erklaerung in Klammern
+dahinter sinnvoll sein, wenn es sich anders schlecht ausdruecken laesst.
+
+Lyra, dumm aber lernfaehig
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: bumis (Tunixgut, 21. Okt 1998, 07:08:51):
+~#! rn=Saladin rt=908900538 rg=balance
+~#! tid=908866477
+Was is daran unlogisch??? Hast Du schonmal versucht, so ein Ding SO zu werfen,
+dass es zurueckkommt, wenn Du Deinen Gegner erwischt hast???
+'s Karate-Zwerchle - Viel-Werfer, trotzdem PRO Gebuehr...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: bumis (Saladin, 21. Okt 1998, 08:44:46):
+~#! rn=Tunixgut rt=908953731 rg=balance
+~#! tid=908866477
+Teddy drueckte es sehr gut aus, wenns Kp sind entfaellt damit der unlogische
+Aspekt. Trotzdem die Frage ob nicht ein skill dafuer besser waere.
+
+Saladin
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: bumis (Novastorm, 21. Okt 1998, 08:57:34):
+~#! rn=Saladin rt=908959486 rg=balance
+~#! tid=908866477
+Hmm... ich versteh nicht ganz, wie man mit einem Skill das Problem der
+Konzentration bzw. die Verbrauchbarkeit der Artillerie umgehen kann. 
+     Nova
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: bumis (Ineluki, 21. Okt 1998, 08:59:28):
+~#! rn=Novastorm rt=908960254 rg=balance
+~#! tid=908866477
+ich denke mal dass damit gemeint ist, dass Ari a) KP kosten solle b) sich
+verbrauchen solle oder c) einen SKill haben solle ... oder halt nen gemix aus
+dem ganzen oder einzelnem ...
+
+Ine* oder so.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: bumis (Mindblade, 21. Okt 1998, 20:35:04):
+~#! rn=Ineluki rt=908960368 rg=balance
+~#! tid=908866477
+Nicht ganz Ineluki, sie muesste sich trotz Skill verbrauchen!;) (->siehe
+Wurfsterne)!
+
+-----------------------------------------------------------------------------
+
+
+
+Re^15: bumis (Jasper, 26. Okt 1998, 23:19:14):
+~#! rn=Mindblade rt=909002104 rg=balance
+~#! tid=908866477
+evtl. sollte man die schreibrechte in dieser rubrik auf die mitglieder
+des balance teams beschraenken.
+
+jasper denkt.oO(oder brauchten wir noch ne schwafel-rubrik?)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^16: bumis (Teddy, 26. Okt 1998, 23:45:41):
+~#! rn=Jasper rt=909443954 rg=balance
+~#! tid=908866477
+Wieso, schwafeln wir nicht? ;)
+
+Teddy
+
+-----------------------------------------------------------------------------
+
+
+
+Re^16: bumis (Pilgrim, 27. Okt 1998, 15:02:49):
+~#! rn=Jasper rt=909443954 rg=balance
+~#! tid=908866477
+Das macht ja wohl nur Sinn, wenns eine Rubrik balance.ankuendigung
+und ne Rubrik balance.diskussion gibt ... sonst gaeistern die Reaktionen
+ja (wieder) durch alle Rubriken ...
+
+P.
+
+-----------------------------------------------------------------------------
+
+
+
+NPC-Balance (Smarte, 27. Okt 1998, 15:03:01):
+Hallo,
+soll es eigentlich auch eine NPC-Balance geben ?
+Wenn ja, dann sollte man sich mal die muehe machen und allgemein die Waechter
+anschauen und sie vergleichen (zumindest die Menschenartigen) !
+Als Beispiel moechte ich hier nennen die Elen Waechter die O.K. sind, wenn man
+sie als anfaenger angreift toeten sie einen nicht gleich.Die Samurai in FW
+sind zwar so auch O.K. aber laut dem was ich von einem Samurai verstehe
+sollten die staerker sein . Die Zwergenwaechter sind auch O.K. . So und jetzt
+kommen wir zu den Felinen (eigentlich der Grund fuer den Artikel ). Warum muss
+ein Felinenwaechter Karate koennen, Gift haben und mehr als 3 mal so stark
+sein wie jeder andere der oberen Waechter . Mich hat die erste Begegnung
+getoetet (als Wurst-Seher durch den auto attack der restlichen Waechter im
+ganzen Dorf. Muessen die so stark sein ? Und was passiert wen ein neuling die
+mal angreift ?
+
+Ach, ja mit Hilfe von Zwei Nicht-Wurst-Sehern hab ich es dann geschaft 2 zu
+plaetten und das rentiert sich dann noch nichteinmal (wat solls).
+
+
+Bis denn Smarte
+
+-----------------------------------------------------------------------------
+
+
+
+Re: NPC-Balance (Hobo, 27. Okt 1998, 15:13:30):
+~#! rn=Smarte rt=909500581 rg=balance
+~#! tid=909500581
+Schon mal dran gedacht, dass Waechter nicht unbedingt zum Metzeln aufgestellt
+werden?
+Vielleicht sollen sie ja das Dorf gegen Angriffe schuetzen. Deshalb ist es
+auch sinnvoll, wenn sie sich nicht 'lohnen'. Sonst wuerde sie ja jede WUrst
+gleich mal angreifen.
+
+
+Hobo
+
+-----------------------------------------------------------------------------
+
+
+
+Re1: NPC-Balance (Smarte, 27. Okt 1998, 15:15:31):
+Das ist O.K. das lohnen koennen wir ja von mir aus auch ausklammern , aber ich
+finde es geht ums prinzip.
+
+Smarte
+
+-----------------------------------------------------------------------------
+
+
+
+Re: NPC-Balance (Ark, 27. Okt 1998, 17:43:48):
+~#! rn=Smarte rt=909500581 rg=balance
+~#! tid=909500581
+Aeh, weinst Du jetzt, weil die doofen Waechter mal ihre Aufgabe richtig
+ausgefuehrt haben? :) Dafuer sind sie doch da. Und da halt viele verschiedenen
+Magier verschiedene Meinungen darueber haben, wie ein Ork/Elf/Zwerg etc.
+auszusehen hat, wirst Du nie ne Uebereinstimmung hinkriegen. Gut so, denn
+sonst hoer ich auf, wenn hier alle Monster auch noch durch nen Trichter
+muessen. Freiheit des Autors, jawollja :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: NPC-Balance (Wurzel, 27. Okt 1998, 18:27:39):
+~#! rn=Ark rt=909512072 rg=balance
+~#! tid=909500581
+alle zwerge sind gleich. ungefaehr so, wie alle menschen blond sind und
+alle tuerken nach knoblauch riechen und einen schnurrbart haben.
+und alle mudder sind bummelstudenten und alle elfen sind schwaechlich.
+
+oder?
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: NPC-Balance (Anatol, 27. Okt 1998, 18:30:19):
+~#! rn=Sting rt=909512931 rg=balance
+~#! tid=909500581
+Dem Muell in dieser Rubrik nach zu urteilen, scheint es wirklich keinen
+Sinn zu machen, eine Rubrik wie "Balance" unmoderiert zu lassen. Ich 
+hoffe daher auf eine Schreibrechtseinschraenkung - oder zumindest auf
+eine allgemeine Loesch- und Verlegeberechtigung des Balancegremiums.
+
+Anatol
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: NPC-Balance (Trancefear, 27. Okt 1998, 19:12:29):
+~#! rn=Hobo rt=909501210 rg=balance
+~#! tid=909500581
+Hmja was bewachen z.B. die Zwergenwaechter im "neuen" Zwergendorf? Und warum
+sind das so viele? Und warum siehts da aus wie im Zwergenknast? Der das
+gemacht hat muss ein uebler Zwergenhasser sein...
+Ok ist'n bisschen OT. Aber warum muessen (fast) alle NPCs, die man in einem
+der Startdoerfer findet, Waechter sein? Warum nicht meinetwegen "ein duenner
+Elf, ein dicker Elf" etc. statt immer wieder dieselben Waechter (uebertrieben
+gesagt hat ein typisches Dorf einen Priester einen Haendler einen Schmied und
+20 Waechter, und die dann noch in der Gildenausfuehrung, also Karateka,
+Kaempfer etc).
+
+tf
+
+-----------------------------------------------------------------------------
+
+
+
+Moderation (Catweazle, 28. Okt 1998, 00:23:10):
+Moin!
+
+Ich hab den Mitglieder des Balanceteams in dieser Rubrik 
+Loeschrechte gegeben. Ihr koennt demnach diese Rubrik als 
+moderiert betrachten. Naja, geht man davon aus, das sie 
+unnoetigen Artikel nach Muell verschieben, was sie hoffentlich
+tun werden ...
+tun werden ...
+YTC
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Moderation (Sharia, 28. Okt 1998, 06:29:06):
+~#! rn=Catweazle rt=909534190 rg=balance
+~#! tid=909534190
+danke Catty .. :-) nur bei mir klappts nedd :-)
+Sharia
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Moderation (Catweazle, 28. Okt 1998, 13:48:27):
+~#! rn=Sharia rt=909556146 rg=balance
+~#! tid=909534190
+Hmpf.
+
+Wie ich das sehe ist da die Kommuniaktion zwischen Zeitung und newsserver
+enorm mangelhaft :(
+
+YTC
+
+-----------------------------------------------------------------------------
+
+
+
+Bummis (Morgoth,  4. Nov 1998, 15:04:19):
+Hi Leute,
+jaja, ich starte mal wieder einen Re^100-Flaming-Thread.
+
+Meine kleine Ratte hat mal die neuen Bummis getestet. Die sind ja nur noch
+scheisse. Ist da auch was an der Formel geaendert worden, oder war das mal
+wieder nur das be^h^hschoene MG-Random? Wieso kann man bei 0MP ueberhaupt nix
+mehr werfen? Die Karateka machen da doch auch noch was. Kann man das nicht
+irgendwie angleichen, dass man bei <3MP schwaecher trifft? naja, zumindest
+fuer andere gilden, denn weniger als verfehlen geht wohl kaum.
+
+Fazit: Bummis sind nur noch scheisse.
+
+M*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Bummis (Bielefeld,  4. Nov 1998, 16:05:25):
+~#! rn=Morgoth rt=910191859 rg=balance
+~#! tid=910191859
+Hi!
+
+Um dann mal konstruktiv zu sein, erstmal etwas Kritik:
+Bei der Umgestaltung der Bumerangs gab es mehrere Moeglichkeiten, wobei
+sich das Balance-Team fuer die einfachste, aber auch nicht beste aller
+Moeglichkeiten entschied. Mit anderen Worten: es ginge besser, ohne dabei
+den Grundgedanken, naemlich: "Schaden in der Groessenordnung muss was
+kosten" zu gefaehrden.
+
+Zunaechst einmal stelle ich fest, dass mit einer Geschicklichkeit, wie
+Sie normale Spieler erreichen, eh kein nennenswerter Schaden verursacht
+wird. Erfahrene Spieler wie auch Magier werden mir da wohl zustimmen 
+koennen, auch angesichts der Tatsache, dass die Schaeden anders als bei
+den normalen Waffentreffern gemapped werden. Warum also die paar Abenteurer
+oder Kleriker mit 3 MP strafen fuer etwas, was eh nix bringt?
+
+Ein wesentlicher Kritikpunkt an den Bumis war, dass sie zu leicht zu 
+besorgen sind und sich nicht oder nur wenig verbrauchen. Stimmt ja auch,
+aber man haette auch hier ansetzen koennen - Bumerang muessen ja nicht
+zu 2 Exemplaren nach Reboot und einem pro Reset im Seherladen erhaeltlich
+sein, einer so und danach garnix mehr haette die Moeglichkeiten etlicher
+Spieler wohl auch eingeschraenkt. Alternativ waere wohl auch eine hoehere
+Fressrate eine empfindliche Schwaechung fuer Extrem-Benutzer von Bumis
+gewesen.
+
+Als Alternativvorschlaege habe ich nun auch wiederholt schon folgende Dinge
+gehoert:
+
+- Von den eingesetzten MP abhaengiger Schaden, aber Mindestschaden ohne
+  MP-Einsatz (so wie Karateka)
+- MP-Verbrauch erst dann, wenn mit einem Mindestschaden getroffen wird
+- Bumerang als Skill in welcher Form auch immer, also mehr Schaden bei
+  mehr Skill, oder weniger MP bei mehr Skill.
+- Bonus fuer Bumerangs, wenn die Gilde des Benutzers stimmt.
+
+So, dies sollte nur Anregung fuer das Balanceteam oder wen auch immer sein,
+sich nochmal Gedanken ueber die Bumerangs zu machen. 
+
+Bielefeld
+(AhM)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Bummis (Key,  4. Nov 1998, 17:20:51):
+~#! rn=Bielefeld rt=910195525 rg=balance
+~#! tid=910191859
+Hmm ansich stimme ich Bielefeld zur ... Nur haenge ich mich am:
+Bonus fuer Bumerangs, wenn die Gilde des Benutzers stimmt. auf ...
+
+Welche Gilde haste denn da ins Auge gefasst?
+
+Key
+
+-----------------------------------------------------------------------------
+
+
+
+bumis und allerlei gestreite + vorschlaege (Phygos,  4. Nov 1998, 17:44:40):
+trotz der tatsache das ich selber keine oder kaum bumis verwende, moecht ich
+hier auch mal ein zwei vborschlaege machen
+1) oft gehort aber sinnvoll   bumiwerfen als eigenstaendiger skill ( und zwar
+fuer jede gilde )
+2) kosten ? naja wenn`s sein muss  besser waere ein schwieriger erwerb ( wie 
+bei speziellen waffen ) waffengebrauch kostet auch keine MPs  und schliesslich
+fliegen die bumis ja nicht von alleine  waehrend z.nsp der Gobring oder der
+Todespanzer selbstaendig feuern
+3) schaden den bumis anrichten koennen  sollte sich nach stufe des werfers 
+grad der beherschung richten
+4) um ausreisser in unbekannte dauermetzelhoehen zu vermeiden, vieleicht  ( 
+ICH SAGTE VIELEICHT !!!) eine beschraenkung der wurfanzahl  pro  zeiteinheit (
+100x pro 10 minuten? ) danach meldung  dir wird der arm lahm  oder  dein arm
+ist ausgeleiert, versehentlich tritts du dir auf die finger )
+. denkt mal drueber nach
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Bummis (Nachtwind,  4. Nov 1998, 18:57:59):
+~#! rn=Bielefeld rt=910195525 rg=balance
+~#! tid=910191859
+Aaalso, ich sag mal wie ich das sehe.
+
+Es ist imho NICHT Aufgabe des Balanceteams, sich ueber
+Implementationen der Objekte diverser Magier einen Kopf zu
+machen. Noch sind wir dafuer verantwortlich. Unsere Aufgabe
+ist es, schlecht balancierte Objekte aus dem Spiel zu halten.
+Im Prinzip haetten wir wohl auch einfach Ketos nachdruecklich
+bitten koennen, die zu verbessern oder ganz abzuhaengen. Die
+"3-MP-Loesung" war mehr ein "das ist das mindeste und einfachste,
+was wir fordern, damit die Bumis dran bleiben koennen erstmal."
+Nie wuerden wir Ketos erzaehlen, dass die Bumis so und nicht
+anders aussehen muessen. Objektgestaltung ist unsere Sache nicht.
+Wir machen Vorschlaege, die andeuten sollen, wie Objekte geaendert
+werden muessen, damit sie fuer uns ok sind. Nicht mehr. Gar kein
+Problem haben wir damit, wenn Ketos sagt: "Hey, ich seh euren
+Punkt, ich hab aber ne viel bessere Idee, was haltet ihr von 
+dieser neuen Version...?" Gern kann er jederzeit die Bumis
+aendern und zur Genemigung einreichen. Hat er gute Chancen mit, 
+was mich betrifft, solange es im Rahmen bleibt. 
+Nochmal: Das Thema Bumis ist fuer uns Balance gegessen. Weder
+haben wir uns da Gedanken zu machen ueber Aenderungen, noch
+nehmen wir Vorschlaege entgegen. Zum Mitschreiben:
+Die Dinger hat _Ketos_ geproggt. Wir sehen nur zu, dass gewisse
+Regeln eingehalten werden. Was die Magier innerhalb dieser 
+Grenzen machen, ist nun wirklich ihre Sache. Im uebrigen empfehle
+ich lieber Mails an Ketos, anstatt irgendwelche sinnlosen
+Diskussionen in der mpa zu verbreiten. Vielleicht liest Ketos
+nicht mal diese Rubrik?
+
+Nachtwind.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Bummis (Mindblade,  9. Nov 1998, 23:11:05):
+~#! rn=Bielefeld rt=910195525 rg=balance
+~#! tid=910191859
+Dank Nachtwind (*grins*) kann ich mir einen ausfuehrlichen Artikel ja sparen,
+nur das mit dem Bonus fuer eine Gilde hab ich noch nicht so verstanden...
+Was meinste damit? Noch mehr Schaden? Keine MP?
+Nein jetzt mal im Ernst, solange das Tool fuer alle zugaenglich ist, sollte es
+auch fuer alle den gleichen MP-Aufwand kosten. Dass Bierschuettler damit nen
+bischen mehr Schaden machen ist ja vollkommen ok. Aber darauf noch nen Boni?
+Ich weiss, dass diese Aenderung vor allem Bierschuettler trifft, weil sie die
+"Hauptbenutzer" diese Tools sind. Die pauschalen 3 MP waren, wie Nachtwind
+schon sagte, ein Mindestmass, um es als Ari zu genehmigen. Und ich bin
+immernoch der Meinung, dass einen 3MP nicht umbringen.
+Wenn ihr Vorschlaege zu vernuenftigen Aenderungen habt, dann ab damit an
+Ketos, er kann die Bumis selbstverstaendlich nochmal vorlegen.
+
+Mind*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Bummis (Morgoth,  9. Nov 1998, 23:13:09):
+~#! rn=Mindblade rt=910653065 rg=balance
+~#! tid=910191859
+Hm, wenn Du nich schon in der Balance waerst wuerd ich ja sagen:
+Mindblade for Balance !!!
+sachlich, konstruktiv...so wie es sein sollte.
+
+M*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Bummis (Trancefear,  9. Nov 1998, 23:13:21):
+~#! rn=Mindblade rt=910653065 rg=balance
+~#! tid=910191859
+Warum nicht einfach die Lebensdauer des Bummis herabsetzen? Der trifft ja wohl
+hauptsaechlich am Kopf, also wenn da nen Helm ist, noch dazu einer aus Metall
+(wozu gibts die neuen Materialangaben?) dann nutzt sich das Ding mehr oder
+weniger schnell ab...
+
+tf
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Bummis (Key, 10. Nov 1998, 08:09:23):
+~#! rn=Trancefear rt=910653201 rg=balance
+~#! tid=910191859
+Wenn ich mich recht erinnere gingen Bumis auch mal putt ....
+Hatte ich zwar lange nichtmehr, aber damals war es mal so ....
+
+Ist das ausgebaut oder warum nimmer?
+
+Key
+
+-----------------------------------------------------------------------------
+
+
+
+Antragsdauer (Mindblade, 21. Jan 1999, 23:31:30):
+Huhu Magier!
+
+Da zwischendurch schonmal von bestimmten Magiern (nein hier werden keine Namen
+genannt) erwaehnt wurde, dass es ja allgemeine Meinung waere, das die
+Balance-Antraege bei uns "verschimmeln", haett ich doch mal gerne eure
+Meinungen dazu.
+Ich denke mal offene Kritik ist besser, als sowas hintenrum erfahren zu
+muessen. 
+Von einigen kenn ich die Meinung dazu ja schon, da sie damit nicht hinter den
+Berg halten.
+
+Also Beschwerden? Kritiken? Ich nehm sie gern entgegen!;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Antragsdauer (Ark, 21. Jan 1999, 23:43:13):
+~#! rn=Mindblade rt=916961490 rg=balance
+~#! tid=916961490
+Oooch, dauern tut das schon a bisserl, aber ich hab keine Probleme damit, da
+ich die Antraege rechtzeitig stelle, also so etwa ein paar Monate vor
+Anschluss, das sollte dann reichen :-) Ich hab' allerdings manchmal ein
+Problem, zu erkennen, welchen 'Status' sie haben, also waere ich, besonders
+bei 'kritischen' Sachen (ich will da jetzt kein Beispiel von mir bringen :-) )
+fuer Stimmungen, Meinungen, Mehrheiten, etc. aus dem Team per Mail oder so,
+dankbar. Ich hab' dann halt immer alle 2 Wochenenden durch Zephyr
+Zwischenstaende erfahren. Also, Maedels, Jungs, teilt Euch schon vor der
+endgueltigen Entscheidung mal mit, vielleicht geht man da schon bei
+aenderungswilligen Magiern vielen Diskussionen aus dem Weg.
+Just so you know ...
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Antragsdauer (Patryn, 22. Jan 1999, 01:02:40):
+~#! rn=Ark rt=916962193 rg=balance
+~#! tid=916961490
+gebt den antraegen halt dringlichkeitsstufen von 1-5 oder so mit.
+jeder magier sollte in der lage sein, dies fair den anderen magiern
+gegenueber abzuwaegen: wenn ein gebiet noch nicht so weit ist,
+duerfte man auch ein wenig warten koennen.
+
+------
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Antragsdauer (Mindblade, 22. Jan 1999, 01:43:01):
+~#! rn=Patryn rt=916966960 rg=balance
+~#! tid=916961490
+Ist 'ne gute Idee!
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Antragsdauer (Tsunami, 22. Jan 1999, 11:42:03):
+~#! rn=Mindblade rt=916961490 rg=balance
+~#! tid=916961490
+Ich habe bis jetzt in meiner kurzen Karriere als Magier zwei groessere
+Antraege gestellt und beide Male hat es, meiner Meinung nach, viieeel zu
+lange gedauert :) Ich bin desswegen aber nicht veraergert oder anderweitig
+verstimmt, da ich mir denken kann, dass die jeweiligen Mitglieder des
+Balanceteams auch noch andere Dinge zu erledigen haben (z.B. RL und so...).
+
+Zum Glueck habe ich bis jetzt in Boing einen guten Blitzableiter gefunden, um
+meine Ungeduld etwas an ihm abzulassen (*zwinker*). Boing war es auch, der
+mich bis jetzt ueber die einzelnen 'Stadien' meiner Antraege informiert hat.
+
+Ich befuehrworte diese 'Salami-taktik': wenn man gleich mehrere Dinge 
+beantragt, finde ich es praktisch, wenn man staendig informiert wird, dass nun
+dies- und dasjenige bewilligt wurde. Somit kann man es einbauen und muss nicht
+bis am Schluss warten, um dann einen riesen Brocken bewaeltigen zu muessen. 
+Das ist speziell praktisch, wenn man als Magier (leider) nicht stundenlang 
+mudden kann, sondern immer nur kurz in den Pausen ins Mud reinschauen kann.
+
+Des weiteren wuerde ich mich freuen, wenn man die einzelnen Antraege im Office
+wieder lesen koennte. So sieht man, was andere Magier gerade proggen, was 
+verhindert, dass man genau das gleiche ein zweites Mal 'erfindet'.
+
+
+ >> Tsunami
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Antragsdauer (Key, 22. Jan 1999, 16:06:53):
+~#! rn=Mindblade rt=916961490 rg=balance
+~#! tid=916961490
+Lass es mich so ausdruecken:
+Ihr seid auch nur Menschen, und handelt als Solche. 
+Da ist es klar das mal was liegenbleiben kann, oder vergessen werden kann.
+
+Aber bevor ihr was falsches denkt, ich war bisher vollkommen zufrieden ;)
+
+Aeh ausser ... also so nen paar Aufwertungen =;)
+
+Key
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Antragsdauer (Belgariad, 28. Jan 1999, 23:19:51):
+~#! rn=Tsunami rt=917005323 rg=balance
+~#! tid=916961490
+Tsunami so verhinderst du aber, dass das Rad zum 2. Mal erfunden wird.
+
+*SUCHT*
+
+-----------------------------------------------------------------------------
+
+
+
+Resistenzen in Ruestungen (Nachtwind, 17. Feb 1999, 21:46:45):
+Hi all,
+
+im Zuge einer Neubewertung der Resistenzen in Ruestungen (zum Beispiel
+die Feuerresistenz, die man durch das Tragen eines Flammenpanzers erhaelt)
+wurden am Resistenzensystem einige groessere Umstellungen vorgenommen. 
+Statt allen Ruestungstypen den gleichen Schutz zu ermoeglichen, wird jetzt 
+nach Ruestungstyp unterschieden. Panzer und Schilde koennen jetzt die 
+hoechstens Resistenzen setzen. Umhaenge, Amulett und Ringe haben
+einen merklich kleineren Maximalwert, die uebrigen Ruestungsteile dann
+noch einmal etwas weniger. Das bedeutet im Klartext: Ruestungen wie
+Flammenpanzer werden nur wenig schwaecher, Adamantschuhe z.B werden
+allerdings demnaechst merklich weniger vor Saeure schuetzen. 
+
+Ab wann wird das Ganze wirksam?
+
+Das ist ehrlich gesagt der kleine Haken an der Aenderung. Erstmal die 
+Entwarnung: Ruestungen, die ihr jetzt bereits habt, funktionieren bis zum 
+naechsten Reboot so wie bisher. Die Magier sind aufgerufen, ihre Ruestungen 
+anzupassen, tun sie das jedoch nicht bis spaetestens zum naechsten Reboot, 
+oder fuehren sie jetzt ein Update ihrer Objekte durch, ohne sie vorher 
+anzupassen, werden die entsprechenden neuerzeugten (!) Ruestungen 
+wirkungslos.
+
+Es koennte also in der Uebergangszeit bis zum naechsten Reboot in
+exotischen Einzelfaellen zu Unregelmaessigkeiten kommen. Das Gros der
+Ruestungen ist jedoch entweder angepasst oder wird dies in den naechsten
+Tagen sein. Insbesondere Morgoth hat bereits alles in die Wege geleitet
+und als erster die Umstellung vorbereitet. (Im Gegensatz zu einigen anderen,
+von denen wir hier in der Balance noch keine Nachricht haben.) Grade
+bei den Standardsachen wie Flammen- und Vampirpanzer sind als sowieso
+keine Probleme zu erwarten.
+
+Um es nochmal klar zu sagen:
+Nein, es wird keinen Reboot deswegen geben.
+Nein, es sind nicht ploetzlich alle Ruestungen wirkungslos.
+
+i.A. Balance,
+
+Nachtwind.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Lichtquellen & schwarze Loecher ==> Balance (Anatol, 15. Feb 2000, 21:38:25):
+
+Hi Mitmudder,
+Objekte, die heller als eine normale Fackel oder dunkler als normale
+Gegenstaende sind, unterliegen kuenftig einer Balance. Sie muessen 
+also von den programmierenden Magiern bei einer zentralen Stelle mit
+Ueberblick vorgelegt und dort genehmigt werden.
+
+Diese zentrale Stelle ist fuer die naechste Zeit (sofern es keine 
+Probleme gibt: fuer das naechste Jahr) - Ueberraschung ;) - Padreic, 
+der ja fuer die Ueberarbeitung des Lichtsystems hauptverantwortlich
+zeichnet und daher ohnehin den besten Einblick haben sollte. 
+
+Fuer uns Spieler heisst das in erster Linie, dass nicht nur die 
+Aenderungsvorschlaege, die das Lichtsystem selbst betreffen (und von 
+Padreic ausdruecklich erwuenscht sind!), in Padreics Briefkasten 
+landen sollten, sondern auch jene, die speziell eine Lichtquelle, 
+einen Lichtschlucker oder auch extrem/untragbar dunkle/helle Raeume
+betreffen.
+
+Denkt bitte daran, dass "Balance" weder bedeutet, dass gewichtslose 
+ultrahelle (womoeglich noch an der Ecke kaeuflich erwerbbare) ewige 
+Lichtquellen wirklich erwuenscht sind, noch dass Spieler auf Gedeih
+und Verderb schikaniert werden muessen. Vielmehr soll, auch hin-
+sichtlich des im Entstehen begriffenen "Kampfes in der Dunkelheit",
+eine Dimension im Kampfgeschehen neu geschaffen bzw. jetzt wieder
+aufrecht erhalten werden. Die ging uns ja leider in der Flut der 
+lichterzeugenden Objekte etwas verloren.
+
+Im Auftrag der Objekt-Balance, 
+Anatol
+
+
+-----------------------------------------------------------------------------
+
+
+
+Waffenaenderungen (Anatol, 10. Mai 2001, 12:04:21):
+Hallo ihr!
+Wir sind zwar noch nicht ganz fertig mit dem Fruehjahrsputz,
+doch erste Auswirkungen zeigt er bereits: Bestimmte Waffen
+wie z.B. diverse Golemarme, der Steindolch und das Schwert des
+Todesritters passten sich neuen Bedingungen an oder werden
+dies in Kuerze tun.
+
+i.A. der Balance
+Anatol
+
+-----------------------------------------------------------------------------
+
+
+
+Schwertmeisterschwert (Anatol, 16. Mai 2001, 00:48:36):
+Man stelle sich eine Waffe vor, die in den Haenden eines normalen
+Sehers mit ein wenig Uebung 40% mehr Schaden am Gegner verursacht
+als eine normale 'max-Waffe'. Weiter stelle man sich vor, dass zu
+dieser maechtigen Schlagkraft noch ein gewisser Schutz hinzukommt
+...ein Schutz, der 50% hoeher ist als der eines normalen Schildes
+je sein kann.
+
+Bei uns sind mehrere Mails und Anfragen eingetrudelt. Und bis auf 
+eine (in der der geneigte Verfasser dann auch noch *Kaempferboni* 
+fuer diese Waffe erbat) stiessen sie alle in das gleiche Horn...:
+Man moege sich doch bitte dieser Waffe annehmen.
+
+Das haben wir getan - und selten waren wir so uneins. Dennoch ist
+etwas dabei herausbekommen,  das mehr oder weniger ein Kompromiss
+aus Balance-Zielen und Tradition darstellt.  Das heisst, dass das
+Schwert des Schwertmeisters grob die Treppe hinuntergefallen ist, 
+aber  auf einer Stufe zu liegen kommt,  die ueber dem liegt,  was  
+fuer gewoehnlich genehmigt werden wuerde.
+
+Fruehjahrsputz? Nein, das gehoert eher zum Nachtragshaushalt.
+
+i.A. des Balance-Teams
+Anatol
+
+-----------------------------------------------------------------------------
+
+
+
+Tolle Balance (Starfire, 16. Mai 2001, 20:49:00):
+Das ist ja wirklich prima mit dem SMS. Jetzt kann ich gleich immer schoen
+rumideln und alle Versuche, was zu metzeln, von vornherein unterlassen. Ich
+hab alle meine Skills voll, alles auf 20 oder mehr, und mit dem SMS (mit dem
+ich nach ueber vier Monaten muehsamen Uebens "etwas" umgehen konnte), habe ich
+bei einigen Gegnern auch mal Knochen gebrochen, sonst traf ich eher "sehr
+hart". Als Katzenkriegerin, die ihrer Gilde ganz gerne treu bleiben moechte,
+hat man keine so grosse Auswahl an Waffen, die einen halbwegs konkurrenzfaehig
+machen.
+Das SMS war eine der Waffen, bei denen man lernen kann, und wir haben in
+einigen Tests rausgefunden, dass mir selbst mit dem SMS mittlere Chaoten
+ueberlegen waren.
+Tja, und nun diese tolle Abwertung. Das ist doch richtig prima. Wie sollen die
+Leute denn angeregt werden, vielleicht auch mal laenger in einer Gilde zu
+bleiben? Fuer mich ist das in geweisser Weise eine systematische Zerstoerung
+von Gilden. Erst Tanjian, die jetzt sterben wie die Fliegen, und nun das SMS,
+das fuer die Mitglieder einer Anfaengergilde fast die einzige ernstzunehmende
+Waffe war.
+Wenn schon Balance, dann vielleicht mit etwas Nachdenken. SMS abwerten, wenn
+Kaempfer es benutzen, meinetwegen. Aber nein, wir hauen einfach mal pauschal
+drauf, das ist ja auch schoen einfach...
+Was hat die Balance nun erreicht? Naja, ich hab vier Monate umsonst geuebt,
+und ich bin als Katzenkriegerin halt noch ein wenig schwaecher, und die
+Kaempfer, die ja spaetestens seit der Abwertung der Tanjis wieder
+unangefochten an der Kampfwertsptize stehen, metzeln munter weiter.
+Ich weiss ned, vielleicht sollte die sogenannte Balance mal versuchen, an ALLE
+zu denken, und nicht nur an einige. So macht man Gilden kaputt, und das ist
+glaube ich nicht ganz direkt der Sinn der Sache.
+Und ja, ich bin sauer, klar, ich bin grad wegen dem Schmarrn gestorben und hab
+eines der Dinge verloren, die mir am MG irgendwo ein Ziel gegeben haben. Und
+das mag Euch auch wurscht sein, aber ich erwarte in Zukunft etwas mehr
+Nachdenken von der Balance, und etwas mehr Fairness, und etwas mehr
+Ueberlegung in die Richtung, dass es auch Anfaengergilden gibt. So. Und nun
+werde ich versuchen, eine Waffe zu finden, mit der ich eine Weile am Leben
+bleibe.
+Alles Liebe, Star*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Tolle Balance (Montanus, 16. Mai 2001, 20:59:29):
+~#! rn=Starfire rt=990038940 rg=balance
+~#! tid=990038940
+Heul doch. :-)
+
+Die kaempfergilde heisst kaempfergilde, weil sie die besten Kaempfer sind.
+Die Zauderergilde heisst so, weil da das meiste Magiepotential dahintersteckt.
+Die Kleriker koennen am bsten heilen.
+
+Die bierschuettler koennen gut Bierschuetteln, die Abenteurer auf Abenteuer
+ausziehen, und Katzenkrieger halt katzen kriegen.
+Wo ist da das Problem?
+Weiss doch jeder, auf was er sich einlaesst, wenn er ner Gilde beitritt.
+
+Just my 2 p
+
+-Montanus. Abenteurer for ever.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Tolle Balance (Gandur, 16. Mai 2001, 21:19:29):
+~#! rn=Starfire rt=990038940 rg=balance
+~#! tid=990038940
+[ ] du weisst wovon du redest
+
+sorry, das ist eigentlich nicht meine art aber hier muss es sein.
+
+gandur
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Tolle Balance (Firehawk, 16. Mai 2001, 21:19:50):
+~#! rn=Montanus rt=990039569 rg=balance
+~#! tid=990038940
+Hmmmpf, dann muessten die Chaoten ja so richtig (und ich meine RICHTIG) Chaos
+verbreiten, also wir laufen in den Raum, dem Weghier rostet ploetzlich der
+Vollstrecker unterm Hintern weg, dem Asaniel fallen seine Buecher auf die
+Birne, das Wasserunwesen erstickt in der eigenen Fluessigkeit usw :) Ja, wir
+wissen alle wozu unsere Gilden gut sind.
+
+Firehawk -> schmarrn
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Tolle Balance (Solmyr, 16. Mai 2001, 21:20:16):
+~#! rn=Starfire rt=990038940 rg=balance
+~#! tid=990038940
+Das mit dem 'Und nun werde ich versuchen, eine Waffe zu finden, mit der ich
+eine Weile am Leben bleiben', solltest Du besser lassen :) Zu naeherem
+Verstaendnis verweise ich auf Artikel 1 derselbigen Rubrik.
+
+MfG
+Sol*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Tolle Balance (Gloinson, 16. Mai 2001, 22:09:27):
+~#! rn=Starfire rt=990038940 rg=balance
+~#! tid=990038940
+> Das SMS war eine der Waffen, bei denen man lernen kann, und wir haben in
+> einigen Tests rausgefunden, dass mir selbst mit dem SMS mittlere Chaoten
+> ueberlegen waren.
+
+Lass mich raten? Dir ist nir in den Sinn gekommen dass ein mittlerer Chaot mit
+einem SMS Dir auch ueberlegen sein koennte? Das diese Waffe sehr stark war?
+Das der Skill nur bei denen die allgemein noch nicht gut genug waren das
+Sahnehaeubchen fuer die Anwendung drauflegte (und nicht wirklich
+repraesentativ war).
+Ich erinnere mich einer Klerikerin mit Schutzhand, Messerkreis und
+Heiligenschein, die bei der Hydra immer noch ein wenig Schaden bekam.
+Grauenvoll. Tatsaechlich. Mit dem SMS konnte sie dort absolut ideln. Ich weiss
+gar nicht mehr, was der Rekord an Kopfzucht war - jedenfalls blieb die Hydra
+leider "stehen". Jaja, sind ja nur ein paar Punkte, nicht?
+
+Gloin(son) meint ... war da nicht noch eine Kristallkrone?
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Schwertmeisterschwert (Fantus, 17. Mai 2001, 00:31:34):
+~#! rn=Anatol rt=989966916 rg=balance
+~#! tid=989966916
+
+Koennt ihr dann bitte einen Schwerthamster und das Schwertbrot genehmigen ?
+Ihr koennt es gerne nach para3 stellen, wenn es nur nach Aufwand fuer sowas
+geht - Hauptsache es KRACHT! 
+
+*seufz*
+
+i.A. Darkwing
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Tolle Balance (Solmyr, 17. Mai 2001, 01:01:50):
+~#! rn=Gloinson rt=990043767 rg=balance
+~#! tid=990038940
+Der Rekord an Kopfzucht wird und wurde von einem Spieler sowieso nie
+erreicht, seit es diesen besagten Magier mit Hydra-Heil-Vorliebe gibt :)
+
+Sol*, Namen werden von der Redaktion generell nicht genannt.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Tolle Balance (Patryn, 17. Mai 2001, 01:06:01):
+~#! rn=Gloinson rt=990043767 rg=balance
+~#! tid=990038940
+na ja, wenn dus schon ansprichst: liegt das problem eher bei den klerikern,
+oder eher beim SMS? sicher, das SMS war zu stark, und manche gilden haben
+es einfach schwerer als andere in sachen "endkampfkraft", aber dashier als
+beispiel herbeizuzitieren halte ich fuer ungeschickt.
+die abwehrboni der kleriker bei der hydra sind doch grauenhaft ueberzogen,
+daran kann man _IMHO_ kaum die balance des SMS messen.
+
+------
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Tolle Balance (Solmyr, 17. Mai 2001, 01:12:56):
+~#! rn=Patryn rt=990054361 rg=balance
+~#! tid=990038940
+Ich frage mich, ob ich was verpasst habe!? Ich mein, ich habe mehrere
+Male das SMS im Kampf benutzt, jedoch keine "merkliche" Veraenderung
+feststellen koennen. Naja, vielleicht habe ich ja auch zu wenig "frufe
+*!%!*, mein SMS-Skill steigt ueberhaupt nicht! *Argh*" getaetigt, aber
+wirklich, der Skill steigt doch absolut langsam. Und wenn der auf hoher
+Prozentzahl eine maechtige Wirkung nach sich zieht, who cares!?
+Vielleicht liegt es aber auch daran, dass ich Zwerg bin, denke aber auch
+Schwerter bringens eh nicht, wenn man "Kampf mit Zaakh" nicht als Grund-
+skill beherrscht. Dann doch lieber ne vernuenftige Axt, ist eh blutiger :)
+Also fuehlt Euch aufgerufen, mal eine nette 'Ich-metzel-Dir-alles-ohne-
+Probleme-und-mit-viel-Blut-Axt' zu programmieren. Der Vollstrecker ist
+doch wohl das einzig wahre, lustige Schwert, dass auch Sinn macht :)
+
+Liebe Gruesse Sol*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Tolle Balance (Refardon, 17. Mai 2001, 01:36:43):
+~#! rn=Solmyr rt=990054776 rg=balance
+~#! tid=990038940
+>Also fuehlt Euch aufgerufen, mal eine nette 'Ich-metzel-Dir-alles-ohne-
+>Probleme-und-mit-viel-Blut-Axt' zu programmieren. Der Vollstrecker ist
+
+Koennte das nicht Sublime machen? ;)
+
+Ref.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Tolle Balance (Solmyr, 17. Mai 2001, 03:36:21):
+~#! rn=Refardon rt=990056203 rg=balance
+~#! tid=990038940
+Hmm, er wuerde gerne, hat er verlauten lassen. Nur 'koennen' ist das
+falsche Wort :) Lieber uebt er an seinem Gesellenstueck, anstatt dass er
+eine monstroes buggende Axt fabriziert, die wahrscheinlich nachher eh
+niemand gebrauchen kann. Aber vielleicht faellt Ihm ja was anderes sinn-
+volles ein :) RL-Biertrinken beispielsweise *G*
+
+Sol* <hicks>
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Tolle Balance (Elberet, 17. Mai 2001, 03:43:02):
+~#! rn=Solmyr rt=990063381 rg=balance
+~#! tid=990038940
+die frage ist, ob das sinnvoller ist ... 
+
+Elbi
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Tolle Balance (Solmyr, 17. Mai 2001, 03:44:52):
+~#! rn=Elberet rt=990063782 rg=balance
+~#! tid=990038940
+Sinnvoller als VL Aexte oder Schwerter schwingen? Vollkommen :) Weil
+dann koennen die RL-NPCS mal eine Kostprobe von meiner RL->VL->RL Sym-
+biose haben :)
+
+Sol*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Tolle Balance (Daria, 17. Mai 2001, 10:29:47):
+~#! rn=Montanus rt=990039569 rg=balance
+~#! tid=990038940
+Bierschuettler koennen Bier nicht nur gut schuetteln, sondern auch gut
+trinken.
+Just my 2 M
+Daria
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Tolle Balance (Terrorist, 17. Mai 2001, 11:09:57):
+~#! rn=Daria rt=990088187 rg=balance
+~#! tid=990038940
+Ach wie ist das schoen, tief verletzte Seelen :)
+Hmm ich melde mich freiwillig fuer die Bekanntmachungen der Balance, will auch
+so schoen liebe kleine Spieler in Ihrem Weltbild erschuettern =:)
+Und das obwohl ich absolut Recht habe ... :)
+
+Hmm also zum SMS ... ich bin zwar nichtmehr ganz auf dem Laufenden, aber mir
+scheint es, das sich im MUD doch nicht soviel geaendert hat wie ich dachte ...
+Einer der groessten Fehler die damals in den Anfaengen im MUD gemacht wurden,
+war das "Bis dahin kommt eh keiner"-Denken.
+Wenn ich mich recht erinnere war es gar nicht vorgesehen das jeder alle ZT's
+findet.
+Und wer meinte jetzt das es egal waere wenn das sms bei hochtrainierten Skill
+extrem stark ist?
+Das Problem dabei ist doch, das man den Punkt frueher oder spaeter erreicht!
+Ich habe das sms relativ weit oben gehabt, und es war nicht umsonst etwas
+abgeaendert meine Lieblingswaffe. Als Chaot.
+Dasselbe hatten wir damals mit den Wurfsternen.
+Ein paar von den Spielern haben geuebt wie bloede, und konnten mit den Dingern
+praktisch alles killen.
+Da hat wahrscheinlich auch keiner gedacht das man die auf fast 100% lernen
+wuerde ..
+
+Die Balance muss vom Maximum ausgehen, weil es frueher oder spaeter jeder
+erreicht. Und wer es nicht erreicht, und trotzdem heult ... soll ueben *g*
+Nebenbei hat das nichts mit der Gildenbalance zu tun, und die eigene Staerke
+auch nicht nur mit der Gilde.
+
+So und zum Schluss ein allgemeines: Heul doch! (C) Lug
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Tolle Balance (Ark, 17. Mai 2001, 11:26:29):
+~#! rn=Solmyr rt=990054776 rg=balance
+~#! tid=990038940
+Also, so wie ich das verstanden habe und mittlerweile auch so sehe, ist die
+Balance da, um jegliche Auswuechse nach oben hin zu begrenzen, _egal_, ob man
+dafuer jeden Raum im MG einmal betreten haben, 5 Jahre lang nur sehr gut mit
+der WAffe getroffen haben muss oder 100 Weghier metzeln muss. Dass einigen der
+Aufwand fuer eine supertolle Waffe gerechtfertigt scheint, darf nicht darueber
+hinwegtaeuschen, dass es fuer andere zur Routine wurde. Man beschneidet die
+Spitzen, um den immer hoeheren Metzelanforderungen wenigstens versuchsweise
+die Berechtigung zu entziehen. Dabei trifft man auch Spieler, die nicht in die
+Kategorie "Sowiesosupermetzler" fallen. Das einzige Gegenmittel, was mir
+einfaellt, waere, die betroffene Waffe den Gilden anzupassen, aber nicht immer
+macht so eine kuenstliche Gleichmacherei Sinn und wird einer Logik gerecht.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Tolle Balance (Wurzel, 17. Mai 2001, 12:53:47):
+~#! rn=Ark rt=990091589 rg=balance
+~#! tid=990038940
+jeden raum im mg betreten? dagegen, absolut.
+nicht auszudenken, wenn horden von spielern durch meinen workroom trampeln.
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Tolle Balance (Solmyr, 17. Mai 2001, 12:55:01):
+~#! rn=Wurzel rt=990096827 rg=balance
+~#! tid=990038940
+Ich waer dafuer mehr Spieler durchs 'jail.c' oder 'noscript.c' watscheln
+zu lassen :) Workrooms koennen wir ja auslagern...
+
+Sol*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Tolle Balance (Gloinson, 17. Mai 2001, 13:19:34):
+~#! rn=Patryn rt=990054361 rg=balance
+~#! tid=990038940
+Das Beispiel war deshalb fuer mich gut, weil die Koepfe trotz ueberzogener
+Kampfkraft noch ein paar LP so im Bereich 1-5 abzogen wenn ihr Biss gut
+ausfiel. Mit SMS kam da so gut wie gar nichts mehr. Nun kann jeder mal
+abschaetzen wieviel das bringt, erstaunt seine Ruestungen mustern und "Oha!"
+sagen. Jedenfalls jeder der es noch nicht wusste.
+
+Gloin(son)
+
+PS: Der Skill war IMHO ein Schnickschnack, weil kaum ein HLP seiner bedarf.
+
+-----------------------------------------------------------------------------
+
+
+
+ja was denn noch .. (Kieselstein, 18. Mai 2001, 10:04:34):
+kleine liste
+bumis, vs, afr, zaubi allgemein, singender speer, trs, sms, bitte um
+ergenzungen
+Balance ist vieleicht wohl der falsche Name, "Abwertung" waehre wohl
+treffender (Da fallen mir noch die Ratten ein)
+Das halbweg positive finde ich noch die neue Berechnung der "ep", das mann
+unter Balance verstehen koennte. Warum ich jedoch 50 mal den klitzel hauen
+muss um nen halbwegs anstaendigen Ring zu bekommen frage ich mich immer noch.
+Ich kann nur der Meinung beipflichten, das hinter vielen Sachen viel Uebung,
+Vergleich und Probieren steckt. 
+Diese Balance ist echt der letzte DRECK!
+Tut mir echt leid fuer die handvoll faehigen Magier die es hier noch gibt -
+Nicht den Kopf haengen lassen, Jungs (und Maedels) !
+Den Spielspass kann ich sonst in die Tonne kloppen.
+ 
+Kieselstein (Hoffend auf Vernichtung der "Balance" !)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: ja was denn noch .. (Nonne, 18. Mai 2001, 10:10:51):
+~#! rn=Kieselstein rt=990173074 rg=balance
+~#! tid=990173074
+Kannste Dir vielleicht vorstellen, dass die Balance das nicht macht, weil sie
+Dich aergern will, sondern auf lange Sicht den Spielspass aller erhalten will?
+Von Magierseite begruesse ich das. Damit habe ich es viel einfacher,
+ausgewogene NPC zu programmieren, die fuer alle eine Herausforderung
+darstellen. Wie soll ich denn ein gutes Tool/Waffe/Ruestung anschliessen,
+damit alle ein faire Chance haben, dass zu kriegen? Soll es schwierig sein,
+wird es fuer 99% der Seher unmoeglich, ist es zu einfach, schickt jeder mal
+kurz seinen Kaempfer-Zweitie, der den NPC mal kurz zappt. Nene, ich finde das
+schon ganz in Ordnung so. Auch wenn es fuer eine Weile nervig ist, nicht mehr
+zu zerstaeuben, auf lange Sicht ist das der richtige Weg.
+
+Meine Meinung
+Nonne.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: ja was denn noch .. (Catweazle, 18. Mai 2001, 10:36:24):
+~#! rn=Nonne rt=990173451 rg=balance
+~#! tid=990173074
+Hiermit moechte ich ein explizites Lob auf die Balance und die
+Balancemitglieder aussprechen.
+
+Ich seid echt arme Schweine, ihr muesst Euch alles ansehen, Euch ueberall
+auskennen, und gegebenenfalls Entscheidungen faellen, die hoechst unbeliebt
+sind.
+
+So wie ich das sehe, kriegt ihr von ueberall immer nur Euer Fett weg. Die
+Magier schnauzen rum, weil ihr Ihnen vorschreibt, wie sie ihre Sachen zu
+programmieren haben, und was leider noch viel oefter passiert, die Spieler
+hacken auf Euch rum, weil ihr ihnen wieder ein Lieblingsspielzeug weggenommen
+habt. 
+
+Ich bewundere Euer dickes Fell, Balance ist glaub ich ein Job, den ich nie
+machen wollte und ich bin froh das sich Leute gefunden haben, die diesen
+leider undankbaren Job uebernommen haben.
+
+Darum also, macht einfach weiter so, und lasst Euch nicht von den Buh-Rufen
+beirren.
+
+Yours truly,
+     Catweazle, aufstehend, beifallklatschend
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: ja was denn noch .. (Patryn, 18. Mai 2001, 11:08:47):
+~#! rn=Catweazle rt=990174984 rg=balance
+~#! tid=990173074
+och, sie schreiben magiern nicht vor, wie sie ihre objekte zu proggen
+haben, aber nach der durchwanderung der balance stellt man sich dann
+doch hin und wieder die frage: wofuer habe ich das jetzt eigentlich
+programmiert :)
+
+------
+patryn, grundsaetzlich trotzdem fuer balance.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ja was denn noch .. (Nonne, 18. Mai 2001, 11:10:23):
+~#! rn=Patryn rt=990176927 rg=balance
+~#! tid=990173074
+Man kann aber auch 'man balance' lesen und gesunden Menschenverstand walten
+lassen, dann hat man auch keine Probleme mit der Balance. So viel Erfahrung
+habe ihc mit denen noch nicht, aber bisher waren die Gespraeche sachlich und
+konstruktiv.
+
+Nonne, hat keinen Grund zur Beschwerden.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ja was denn noch .. (Morgoth, 18. Mai 2001, 11:19:40):
+~#! rn=Nonne rt=990177023 rg=balance
+~#! tid=990173074
+Bist ja auch noch nicht so alt ;-)
+Also ich kann da von ganz "netten" Flames^WDiskussionen erzaehlen, die da
+zwischen uns hin und her gingen *zwinker Boing an*
+
+Wah und jetzt bin ich alt und weich geworden und aender sogar schon Sachen auf
+Wunsch, ohne Diskussion und bevor sie von der Balance als "Gesetz"
+herausgebracht wurden ;-)
+
+M* ruestet ab
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ja was denn noch .. (Hight, 18. Mai 2001, 14:06:38):
+~#! rn=Morgoth rt=990177580 rg=balance
+~#! tid=990173074
+ich wollte nur mal kundtun dass ich caty voellig zustimme
+
+im uebrigen denke ich das die aufarbeitung von altlasten noch viel schlimmer
+is ...
+wenn ihr sachen abarbeiten muesst, die noch keiner kennt is das geschrei der
+spieler nich da ... alte "gebrauchsgegenstaende neu zu ueberarbeiten 
+duerfte da noch einiges undankbarer weil dann das geschrei noch groesser wird
+
+versucht das doch mal so zu sehen: die leute machen auch nur ihren job
+ich finde es schlimmer das solche sachen nicht gelich zu anfang bemaengelt
+wurden bzw. so lange auf halde liegen
+
+fazit: STOP CRYING !
+
+YT Hight
+
+P.S.: ja ich bin elf -> ichbenutze das sms so gut wie garnicht ... aber auch
+ich habe mehr als einen char und auch ich habe irgendwann vor langer zeit
+diesen skill gemaxt 
+also maulereien sein lassen ich ignoriers eh 
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ja was denn noch .. (Terrorist, 18. Mai 2001, 14:28:58):
+~#! rn=Hight rt=990187598 rg=balance
+~#! tid=990173074
+Naja frueher oder spaeter muss man auch Gebrauchtgegenstaende ueberarbeiten
+.... das MUD lebt immerhin und entwickelt sich weiter.
+Denk nurmal an die Materialien die es ja auch noch net allzulange gibt :)
+
+Gruesse
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: ja was denn noch .. (Terrorist, 18. Mai 2001, 14:30:01):
+~#! rn=Terrorist rt=990188938 rg=balance
+~#! tid=990173074
+Jaja Selbstreplys stinken, aber ich hab doch Alzheimer :)
+Wollt nur vorschlagen die Diskusion bis zum naechsten Objekt aufzuschieben *g*
+Dann koennen wir das naechstemal mitten drin anfangen, und net wieder von
+vorne.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: ja was denn noch .. (Mesirii, 18. Mai 2001, 14:31:01):
+~#! rn=Terrorist rt=990189001 rg=balance
+~#! tid=990173074
+Da die Objekte jetzt wohl im Wochenrhythmus ausbalanciert werden, wird die
+Diskussion wohl nicht so schnell abbrechen.
+Mesi, trauert dem SMS auch nach :(
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: ja was denn noch .. (Nizzl, 18. Mai 2001, 14:48:53):
+~#! rn=Catweazle rt=990174984 rg=balance
+~#! tid=990173074
+schonmal dran gedacht, dass die jungs und maedels das freiwillig machen? :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ja was denn noch .. (Patryn, 18. Mai 2001, 14:49:37):
+~#! rn=Nizzl rt=990190133 rg=balance
+~#! tid=990173074
+ich glaub, wir machen das hier alle mehr oder weniger freiwillig ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ja was denn noch .. (Terrorist, 18. Mai 2001, 14:50:05):
+~#! rn=Patryn rt=990190177 rg=balance
+~#! tid=990173074
+Ich werde gezwungen!
+Kaempf Du mal gegen eine ausgewachsene Sucht an! ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ja was denn noch .. (Boing, 18. Mai 2001, 14:50:09):
+~#! rn=Nizzl rt=990190133 rg=balance
+~#! tid=990173074
+Schonmal dran gedacht wo das Mud stehen wuerde, wenn hier niemand was
+freiwillig machen wuerde?
+  Boing
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ja was denn noch .. (Nizzl, 18. Mai 2001, 14:50:51):
+~#! rn=Boing rt=990190209 rg=balance
+~#! tid=990173074
+nein. wo denn?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ja was denn noch .. (Hight, 18. Mai 2001, 14:51:44):
+~#! rn=Nizzl rt=990190251 rg=balance
+~#! tid=990173074
+/connect mud.turithil.org
+
+da oder drunter ,o)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: ja was denn noch .. (Anacrion, 18. Mai 2001, 15:02:49):
+~#! rn=Kieselstein rt=990173074 rg=balance
+~#! tid=990173074
+Lieber Kieselstein!
+
+\wille
+Wenn ich Deinen Artikel ueber die Balance lese, dann fange ich ja an, mich zu
+Schaemen, ein MG-Spieler zu sein... Warum? Weil ich damit in die gleiche
+Kategorie falle wie jemand, der einen Artikel fabriziert wie den, auf den ich
+gerade antworte.
+
+Wenn Du der Meinung bist, dass es gerechtfertigt ist und den Spielspass
+erhaelt, wenn jeder mit nem Zaptool rumrennt, so wird es mir an dieser Stelle
+wohl nicht gelingen, Dich zu desillusionieren.
+
+Doch bitte sehe davon ab, Leute die hier wertvolle Zeit opfern, um das MG fuer
+die Allgemeinheit einen besseren Ort zu machen, mit Nomen wie 'letzten Dreck'
+zu bedenken. Zum einen wuerdest Du Dich auch nicht freuen, Deine Arbeit mit
+unqualifizierten Argumenten und zudem noch despektabler Wortwahl
+herabgewuerdigt zu sehen, zum anderen glaube ich, dass die wenigsten einzelnen
+Entscheidungen der Balance widersprechen (ausgenommen evtl. im MASS der
+Abwertung, gell Patryn ;-) ).
+
+Wenn du also in Zukunft Deinen Unmut entweder in gepflegterer Form von Dir
+geben wuerdest oder aber sofort die hoffentlich vorhandenen grauen Zellen
+aktivierst und Dir ueberlegst, ob das entsprechende Objekt nicht vielleicht zu
+stark war .. DAS wuerde helfen ... auch der Arbeitswilligkeit der vielen
+freiwilligen.
+
+Anac* - hofft das Kieselsteine in der Minderheit sind.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: ja was denn noch .. (Solmyr, 18. Mai 2001, 15:22:05):
+~#! rn=Anacrion rt=990190969 rg=balance
+~#! tid=990173074
+Hmm, vielleicht solltest Du ab jetzt mit dem Titel 'Anacrion - Gottes Wort und
+Paladin aus langjaehriger Ueberzeugung' rumidlen.
+
+Sol* *ironie aus*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ja was denn noch .. (Ark, 18. Mai 2001, 17:22:14):
+~#! rn=Patryn rt=990176927 rg=balance
+~#! tid=990173074
+Ach, im Zweifel schadet eine Voranfrage sicher nicht. Dann aergert man sich
+nachher auch nicht. Sollte man, wenn man Projekte mal gesteuert hat oder auch
+mitgemacht hat, eigentlich kennen und koennen. Ansonsten hier der Hinweis :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ja was denn noch .. (Kieselstein, 19. Mai 2001, 07:05:12):
+~#! rn=Ark rt=990199334 rg=balance
+~#! tid=990173074
+Schoen das ich hier viele Stellungnahmen finde was meinen Artikel betrifft.
+Es ist nicht so das ich mir nicht denken kann das ein "Balance-Magier" einen
+harten Job hat, jedoch renne ich nun auch schon etwas laenger durchs MUD und
+habe bis dato immer alles hingenommen, weil ich eigentlich davon ausgehe das
+bei jeder Aktion sich irgendwer sich was dabei gedacht hat.
+Bei fuer mich persoenlich positiv wie bei negativen Aktionen.
+Bin eigentlich wirklich nicht der Typ der rummault, jedoch platzt auch mir mal
+irgendwann der kragen.
+Das war halt gestern. 
+Ich finde es halt nur tottraurig das ich mittlerweile wirklich kein
+Tool/Rue/Waf bei Anfragen mehr empfehlen kann, weil wenn es zuviele benutzen
+wird es ueber kurz oder lang abgewertet. 
+Fehler in der Programmierung von Tools/Rue/Waf werdet Ihr wohl auch ohne mich
+finden. Das stundenlange austesten der Kaempfergilde, ich will gar nicht alles
+erwaehnen was ich mit Zardoz alles ausdiskutiert habe, haette ich mir sparen
+koennen.
+Gut, dann mach ich mal "STOP CRYING" und habe nur noch 2 Anmerkungen.
+1. Hinter guten Tools/Rue/Waf steckt auch VIEL Arbeit von Spielern, vergesst
+das nicht.
+2. Bezug Wo waehren wir wenn ... Haben nicht eine Menge Spieler/Magier damals
+den MUD-Rechner finanziert ? sonst waehren wir NIX !
+ 
+Kieselstein (gegen Balance!)
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ja was denn noch .. (Bambi, 19. Mai 2001, 10:05:42):
+~#! rn=Kieselstein rt=990248712 rg=balance
+~#! tid=990173074
+Zunaechst will ich vor meiner Antwort klarstellen, dass Du Dich nicht
+durch meine Antwort angegriffen fuehlen solltest...
+
+***
+Ich finde es halt nur tottraurig das ich mittlerweile wirklich kein
+Tool/Rue/Waf bei Anfragen mehr empfehlen kann, weil wenn es zuviele benutzen
+wird es ueber kurz oder lang abgewertet. 
+***
+
+Zunaechst kommt es einmal darauf an, _wem_ Du etwas empfehlen willst. Leider
+ist es viel zu oft so, dass kleine Spieler (ich meine an dieser Stelle
+Spieler < Level 20) mit Ausruestung rumlaufen, die sie _eigentlich_ gar nicht
+bekommen koennen, beispielsweise irgendwelche Para-Ausruestung. Das hat unter
+anderem zur Folge, dass sie "gute" und fuer sie "angemessene", weil durch
+etwas Aufwand selbst beschaffbare Ausruestung nicht holen oder etwa haben
+wollen. Das hat in erster Linie nichts mit Abwertung zu tun, allerdings sind
+dann leider viele Spieler der Meinung, man muesse eben max-Ausruestung haben.
+Da diese Spieler aber eigentlich nie den Aufwand sehen, den man hat, um
+solche Ausruestung (erst recht auf ihrem Level) zu holen und da sie den
+Besitz und die Benutzung von Max-Zeugs gewoehnt sind, entsteht der Eindruck,
+dass es normal sei, mit eben solchem rumzulaufen. Es ist aber _eigentlich_
+ueberhaupt nicht normal, _ueberhaupt_ unbegrenzt Objekte mit Stat-
+Verbesserung zu besitzen, daher finde ich Aussagen bezueglich der minderen
+Qualitaet (?) von Drom-Ringen doch etwas befremdlich. _Vielleicht_ sollte
+"Spieler" sich mal ueberlegen, was fuer geiles Zeugs er/sie/es im Inv hat,
+auch wenn das Zeugs nicht das Beste vom Besten vom Besten ist.
+
+***
+1. Hinter guten Tools/Rue/Waf steckt auch VIEL Arbeit von Spielern, [...]
+[...]
+Kieselstein (gegen Balance!)
+***
+
+Ich stimme Dir zu, dass Spieler viel zum Mud beitragen, das man Arbeit nennen
+kann und das produktiv ist und das Mud verbessert. Es wuerde mich wundern,
+wenn Du einen Magier mit ausreichender Erfahrung oder ein Mitglied des 
+Balance-Teams findest, das das Gegenteil behauptet.
+Daher wundert es mich, dass Du so gegen die Balance gehst, da gerade die
+Mitglieder dieser Balance viel Arbeit zum Wohle aller ins Mud stecken.
+
+MfG, Bambi.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ja was denn noch .. (Deepblue, 19. Mai 2001, 10:46:43):
+~#! rn=Kieselstein rt=990248712 rg=balance
+~#! tid=990173074
+> Kieselstein (gegen Balance!)
+
+Und wozu soll das fuehren? In 2 Jahren gibt es dann das Super-Blitzschwert mit
+WC 10000, wo Du zum Weghier gehst - toete - vernichtet - weiter oder eher
+vermutlich garnicht mehr zu dem "Weichei" Weghier gehst, weil der ist ja dann
+langweilig.
+Da kann man gleich jedem Spieler nen Zaptool geben...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ja was denn noch .. (Gloinson, 19. Mai 2001, 12:09:35):
+~#! rn=Deepblue rt=990262003 rg=balance
+~#! tid=990173074
+Vielleicht (!) hat Kieselstein noch nie in einem dieser MUDs mitgespielt in
+denen die Werte sozusagen nach oben offen sind weil es keinen schert. Um dann
+mal mitzubekommen wie sehr die Spieler kotzen, weil das Insiderwissen um
+gewisse Gegenstaende ganze hunderte von Prozenten an Kampfkraft ausmachen.
+Mal ehrlich - der ganze alte Kram der in bestimmten Dingen weit ueber Max
+hinausgeht, der ist doch auch nur durch Mund-zu-Mund-Propaganda
+weitergegangen. "Ha, ich hab hier was tolles" sagt Kieselstein. Geht effektiv
+ueber die festgelegten Grenzwerte hinaus, kann ich nur empfehlen. Und was ist
+mit dem, der es nciht hoert, der sich nie den Aufwand gemacht hat _sowas_ zu
+finden? Der kaempft eben nur mit halber Kraft. Ja, er wird oft auch damit
+gluecklich sein - eventuell aergert er sich, dass XYZ ja doch viel besser ist
+als er ohne dass er es wirklich erkennen kann warum - und warum kann XYZ nicht
+gluecklich damit sein so "gut" oder "schlecht" wie alle anderen zu sein?
+Ich finde diese uebermaxten Gegenstaende auch furchtbar langweilig. Weil sie
+dafuer sorgen dass nur noch diese Gegenstaende genommen werden. Oder wie z.B.
+ein 23 Kaempfer neulich zu mir sagte: "Wer nimmt denn schon noch was ausser
+der Kristallkrone?". Tja.
+
+Gloin(son), ruehrt in der eigenen Meinung herum
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: ja was denn noch .. (Mesirii, 19. Mai 2001, 12:26:33):
+~#! rn=Gloinson rt=990266975 rg=balance
+~#! tid=990173074
+Das Problem der hoeheren Kampfkraft ergibt sich ja genauso, wenn man die
+Gilden betrachtet. Wer sich die Muehe macht und in eine Gilde eintritt,
+deren Maxlevel wirklich aufwaendig (nix skripten!) zu erreichen ist, sollte
+auch mit hoeherer Kampfkraft belohnt werden. Aber das sollten im Schnitt
+nur wenige sein (daher finde ich die Anzahlbegrenzung fuer MaxGildenLevel
+bei einigen Gilden auch eher vorteilhaft (5 Generaele reichen doch dicke
+fuer den Trveshaufen *G*). Genauso sollte es imho bei solchen Items sein.
+1. Unique (begrenzte Anzahl) 2. Skill der moeglichst nicht skriptbar sein 
+sollte. 3. Rotierend auf Zeitbegrenzungs oder Abnutzungsbasis, und ausserdem
+natuerlich pro Uptime jeder nur einmal und nodrop/neverdrop!. Dann haette
+jeder mal die Chance an diese > Max Uniques zu kommen, auch die Leute, die das
+nicht in der ersten Minute nach dem Reboot/Crash schaffen.
+Ausserdem sollte imho wirklich mal betrachtet werden, wie sich die Gildenboni
+auf manche Items auswirken (Spielermitwirkung), dann koennte man das ganze
+sogar ueber Multiplikatoren anpassen, denn die Max-Items sollen ja fuer sich
+selbst sprechen und nicht noch durch Gildenfaehigkeiten verstaerkt werden, was
+bestimmt nich im Sinne der Erschaffer ist.
+Daher fand ich z.B. das SMS fuer nen Chaoten sehr brauchbar (einmal pro
+Kampfrunde hart bis maximal kbk und das wars), bei nem Tanjian bzw. Kaempfer
+dann doch uebertrieben.
+Mesi
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ja was denn noch .. (Ark, 19. Mai 2001, 13:25:29):
+~#! rn=Kieselstein rt=990248712 rg=balance
+~#! tid=990173074
+Hm, und nicht so tolle Waffen, in Spielerkreisen als "Nichtmaxwaffen"
+vielleicht bekannt, sind dann nicht mehr den Aufwand wert. Gut, heisst das
+fuer mich, ich kann mir den Aufwand sparen? Also nur noch Feuerblitzaexte mit
+maximalem Schaden, Explosionsspeere, die einhaendig fuehrbar sind, oder
+Saeuredolche, die dem Traeger die doppelte Anzahl von Angriffen ermoeglichen?
+Wenn das die Massgabe ist, dann stelle ich das Programmieren von Waffen ein.
+Bessere gibt es dann ja immer und auf schlechtere spuckt jeder mit Level 1,
+weil er von Sehern tolle Waffen in die Hand gedrueckt bekommt. Wenn ihr
+letzteres etwas einstellen wuerdet, waere der Anspruch der nachwachsenden
+Spieler nicht ins Bodenlose gewachsen.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ja was denn noch .. (Amaryllis, 19. Mai 2001, 13:27:44):
+~#! rn=Ark rt=990271529 rg=balance
+~#! tid=990173074
+Insbesondere der letzte Satz verdient besondere Aufmerksamkeit :)
+Aber da die Zahl der "weiblichen" Mudder steigt, bleibt Arks Hoffnung wohl
+unerfuellt :)
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ja was denn noch .. (Mesirii, 19. Mai 2001, 13:28:06):
+~#! rn=Ark rt=990271529 rg=balance
+~#! tid=990173074
+Warum dann nicht ne Level/FP Begrenzung wenn die Einschraenkung durch das
+Geschick nicht ausreicht? So nach dem Motto, du kleine Wurst traust Dich
+nicht diese Waffe zu zuecken. Oder Mit Deiner Erfahrung probierst Du diesen
+Speer lieber nicht aus..." sollte doch mit nen paar Mudlibaenderungen getan
+sein oder ?
+Dasselbe gilt fuer Ruestungen.
+Mesi
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: ja was denn noch .. (Mesirii, 19. Mai 2001, 13:29:44):
+~#! rn=Mesirii rt=990271686 rg=balance
+~#! tid=990173074
+Kurzer Nachtrag: Ihr wisst doch genau, dass man durch Appelle nix erreicht,
+also Peitsche :). Da faellt mir ein, dass man bei diesem Thema doch eine
+Runenschwertfunktionalitaet mit einfliessen lassen kann. *grins Ark an*
+Mesi
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: ja was denn noch .. (Ark, 19. Mai 2001, 13:31:06):
+~#! rn=Mesirii rt=990271686 rg=balance
+~#! tid=990173074
+Macht man als vorausblickender Magier eh *Balance schiel* Aber da gleichzeitig
+KLs und ZT Listen/Loesungen in kurzer Zeit auch das Problem loesen koennen ...
+naja, ich schweife ab ;^)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ja was denn noch .. (Artea, 19. Mai 2001, 13:34:05):
+~#! rn=Ark rt=990271529 rg=balance
+~#! tid=990173074
+Koenntet ihr in die MaxWaffen nicht einfach Checks auf Attribute, Level oder
+so einbauen?
+Artea-unbedeutener Neuling mit MaxWaffen
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: ja was denn noch .. (Ark, 19. Mai 2001, 13:35:19):
+~#! rn=Artea rt=990272045 rg=balance
+~#! tid=990173074
+Wie gesagt, kann jeder Magier schnell machen. Aber, was sind Maxwaffen? :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: ja was denn noch .. (Mesirii, 19. Mai 2001, 13:39:24):
+~#! rn=Ark rt=990272119 rg=balance
+~#! tid=990173074
+Maxwaffen sind die, die die Balance genehmigen muss (bzw. die die sie aus
+balanciert - schoenes Wort :) ). Hmm zum Thema Para-Zeugs faellt mir ein,
+dass man ja Seher sein muss um ranzukommen, warum dann nicht die Nutzung
+auf Seher beschraenken. Und allgemein, koennte man die Weitergabe so ein
+schraenken, dass man selbst den EK des NPCs haben muss, wenn man dessen
+Ausruestung benutzen moechte (waer zwar ziemlich hart, aber wuerde durch
+greifen).
+Mesi
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ja was denn noch .. (Darkwing, 19. Mai 2001, 13:40:06):
+~#! rn=Kieselstein rt=990248712 rg=balance
+~#! tid=990173074
+Hallo ? Die Balance besteht hauptsaechlich aus Spielern. Total beschweuert
+oder ? Leute die sich selber abwerten, sich ihr Spiel kaputtmachen... und dann
+nehmen sie da auch noch Leute, die die _richtig_ guten Sachen kennen. Denk mal
+scharf darueber nach.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: ja was denn noch .. (Ark, 19. Mai 2001, 13:44:41):
+~#! rn=Mesirii rt=990272364 rg=balance
+~#! tid=990173074
+Wer sagt jetzt, dass unbedingt nur NPCs solche Waffen besitzen (oder dass sie
+Quest-/Miniquestbelohnungen sind). Dann koennen ja auch noch mehrere Monster
+solche Waffen haben. Ein bisschen Schubladendenken ist das, "Maxwaffen kommen
+von Maxmonstern" :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ja was denn noch .. (Liara, 19. Mai 2001, 13:59:52):
+~#! rn=Kieselstein rt=990248712 rg=balance
+~#! tid=990173074
+1. Die Abwertung betrifft jeden Spieler gleich.
+
+2. Nach jeder Abwertung gibt es ne neue 'beste' oder 'zu empfehlende' Waffe.
+Wenn es Dir an Flexibilitaet fehlt, um Deine Gewohnheiten zu aendern, dann
+solltest Du Dich besser irgendwo eingraben. ;-) 
+
+LZ
+
+P. S.: Wenn Du mir nun erzaehlen willst, dass die anderen zur Verfuegung
+stehenden Waffen aber nicht so stark sind wie die jeweils abgewerteten, dann
+haste 1. oder 2. nicht verstanden. 
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: ja was denn noch .. (Varlarion, 19. Mai 2001, 14:00:56):
+~#! rn=Ark rt=990272681 rg=balance
+~#! tid=990173074
+Natuerlich "braucht" man als High-Level-Seher die MaxAusruestung, denn man
+"muss" ja jeden neuen NPC, der natuerlich zaeher, fieser und staerker ist, als
+alles bisher dagewesene, sofort toeten, man "muss" ja den EK haben und evtl.
+die noch bessere MaxAusruestung, die dieser NPC bei sich traegt.
+Fuer viele hier scheint genau dieses Denken und Verhalten den absoluten
+Spielspass zu bringen. Klar, dass diesen Leuten der Spass genommen wird, wenn
+ihre Lieblingsspielzeuge abgewertet werden. 
+Ich frage mich nur, ob man da nicht ganz woanders ansetzen muss. Vielleicht
+sind die bestehenden NPCs tatsaechlich hart genug und man koennte aufhoeren,
+diese Ruestungsspirale weiter nach oben zu drehen.
+Was das Verhalten angeht, immer nur MaxAusruestung an "kleine Spieler"
+weiterzugeben, kann ich nur sagen, dass da etwas passieren muss. Wenn ich
+einem Lvl 20 Spieler kurz nach dem Reboot einen FlaPa anbiete und der mich
+auslacht, weil der "nicht gut genug" ist, komme ich mir doch leicht verarscht
+vor. Und wenn mich derselbe Spieler kurze Zeit spaeter fragt, wo
+beispielsweise das Neandertal ist, muss ich mich doch fragen, was passiert,
+wenn dieser Spieler Seher wird. Er wird in eine der "starken" Gilden eintreten
+und zu einem weiteren Metzler, weil er es von den "grossen" so gelernt hat,
+dass es Ziel des Spiels ist, immer haertere Gegner zu besiegen.
+Ich muss hier deutlich sagen: ich habe nichts gegen Metzler, wer seinen
+Spielspass aus eben diesem Verhalten zieht, fuer den ist es ok. Ich finde es
+nur schade, dass dieses Verhalten hier oft als das "einzig wahre" angesehen
+und dieser Gedanke an den "Nachwuchs" weitergegeben wird. Das fuehrt zu
+kleinen Spielern, die zwar den Weg zwischen Hochebene und Port Vain nur mit
+Mueh und Not finden, aber ohne SMS nicht aus dem Haus gehen wuerden und mit
+Lvl 15 uebers Forschen und Questen jammern und selbiges als voellig
+ueberfluessig und laestig ansehen und deswegen nichts ohne KL machen (wo auch
+immer sie die her haben...).
+
+[Alle hier angefuehrten Vorkommnisse sind reine Beispiele, die ich aber
+aehnlich erlebt habe, wer sich jetzt auf den Schlips getreten fuehlt, ist
+selber schuld]
+
+Varl*, 2 Muenzen in die Runde werfend
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Tolle Balance (Wargon, 19. Mai 2001, 15:31:02):
+~#! rn=Patryn rt=990054361 rg=balance
+~#! tid=990038940
+Wobei vielleicht darauf hingewiesen sein sollte, dass die Boni nicht mit
+Hinblick auf die Hydra so abgestimmt wurden (zumindest nicht von mir). Dass
+die Kombination gerade bei der Hydra so gut ausfaellt, hat sich erst im
+nachhinein herausgestellt.
+  Wargon
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: ja was denn noch .. (Swantevit, 19. Mai 2001, 16:05:11):
+~#! rn=Gloinson rt=990266975 rg=balance
+~#! tid=990173074
+Also eins faellt mir allerdings auf: Alle reden immer von den Spitzenwerten
+("Zaptool", "...vernichten...", "...hunderte von % Ueberlegenheit...").
+
+Kann mir mal einer erklaeren, warum das SMS dann auf ganzer Linie abgewertet
+wird und nicht nur nach oben gekappt?
+
+Oder habt ihr das etwa gemacht, in diesem Falle Asche auf mein Haupt. Ich bin
+keiner, der Statistiken macht, hab aber schon den Eindruck, dass es deutlich
+schwaecher ist, in meinen Wurstbereichen, wohlgemerkt.
+
+Da stimmt was nicht an der Argumentation, Folks.
+
+Swante, kann "etwas" mit dem SMS umgehen
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ja was denn noch .. (Strohalm, 19. Mai 2001, 18:06:31):
+~#! rn=Ark rt=990271529 rg=balance
+~#! tid=990173074
+Hmmm, wie waers wenn man ein Mindestlevel als Voraussetzung fuer bestimmte
+Waffen und Ruestungen einfuehrt, dann waere schonmal das Problem der
+Blechdosen-Level-1-Spieler mit Bumm-Und-Kaputt-Waffe geloest, und
+"schlechtere" Ruestungen und Waffen wuerden wieder mehr genutzt werden.
+
+Haelmchen
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: ja was denn noch .. (Strohalm, 19. Mai 2001, 18:07:26):
+~#! rn=Ark rt=990272119 rg=balance
+~#! tid=990173074
+Hmmnja, naechstes mal les ich erst weiter ;)
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: ja was denn noch .. (Wurzel, 19. Mai 2001, 18:29:52):
+~#! rn=Strohalm rt=990288446 rg=balance
+~#! tid=990173074
+die antwort ist auf den ganzen thread bezogen, nur zufaellig auf den letzten
+artikel.
+eigentlich ist genug gesagt worden ueber die notwendigkeit von balance, das
+brauchen wir sicher nicht mehr zu diskutieren. natuerlich kommt es vor, dass
+das balanceteam mal an der einen oder anderen stelle ein wenig ueber das ziel
+hinausschiesst, aber das halte ich fuer unvermeidbar. immerhin sind das auch
+nur menschen, keine automaten.
+was spricht eigentlich dagegen, dass ein kleiner spieler auch mal ne tolle
+ausruestung hat? das ist mir noch nicht klargeworden in der diskussion. dass
+er sich das zeug nicht selbst besorgen kann ist logisch, aber wenn er es
+geschenkt bekommt hat sich jemand die muehe gemacht... und kann dann meiner
+meinung nach selbst entscheiden, was er damit anfaengt. fuer mich kein grund
+zu jammern.
+ein punkt, der mir zu denken gibt, ist folgender: wenn es keine wirklich
+herausragenden gegenstaende mehr gibt, wird die frage nicht mehr lauten "was
+ist die bessere waffe fuer diese gelegenheit", sondern "was ist leichter zu
+bekommen". und das halte ich nicht fuer wuenschenswert. mag sein, dass das
+sms zu gut war fuer den schwierigkeitsgrad, mit dem es zu holen war. bei
+laengeren uptimes wurde es teilweise jedenfalls schon angeboten wie saures
+bier... das ist sicher nicht wuenschenswert. ueber die methode, damit dann
+umzugehen, mag man streiten. mir persoenlich waere eine limitierung der zahl
+lieber gewesen als eine abwertung, aber es wurde eben anders entschieden.
+am besten faende ich persoenlich eine hoehere zahl von _verschiedenen_ guten
+ausruestungsteilen, die aber alle ohne ausnahme nur in beschraenkter zahl
+erhaeltlich sein sollten. wuerde die uniformitaet zurueckdraengen. man stelle
+sich das mal bildlich vor... heerscharen von kaempfern, die mit einer eher
+albernen knallbunten kristallkrone rumlaufen, und nur weil die anderen teile
+eben meist schlechter sind, was die schutzwirkung angeht.
+
+die wurzel allen uebels
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: ja was denn noch .. (Solmyr, 19. Mai 2001, 19:06:44):
+~#! rn=Wurzel rt=990289792 rg=balance
+~#! tid=990173074
+So kann das ja nu' nich weitergehn *seufz* ! Vergesst alle Eure RL-Aufgaben,
+Eure Arbeit, Eure Familie, Freundin, Essen, Trinken, alles was dazu ge-
+hoert, bleibt vor der Daddelkiste sitzen und legt eine 48h Mudschicht ein,
+um das Chaos hier zu beseitigen! Unterstuetzt die (faehige!) Balance und
+mailt Eure Vorschlaege sofort an den Balance Team Leader (Name ist irgend-
+wie weggelaufen).
+Ach ja, wer nicht freiwillig bleibt, da gibts Mittel und Wege, jemanden
+am Stuhl zu "fesseln", ob nu Seile oder Sekundenkleber, ist Eure Ent-
+scheidung. Ich leg mich derweil schoen in den Park in die Sonne und komme
+wieder, wenn das hier alles wieder im Reinen ist.
+
+Gruss Solmyr *ironie off*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: ja was denn noch .. (Wurzel, 19. Mai 2001, 19:49:28):
+~#! rn=Solmyr rt=990292004 rg=balance
+~#! tid=990173074
+im reinen? was ist das? wahrscheinlich meinst du einen ganz anderen ort.
+frueher mal, als ihr alle noch fluessig wart, nannte man das "im eimer".
+heutzutage bezieht sich die ortsbestimmung eher auf den teil der anatomie,
+den man so selten sieht, weil man meist darauf sitzt.
+btw, in den park und in die sonne darfst du nur mit notebook und gsm-modem.
+falls du mit den kosten klarkommst, natuerlich.
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Corak, 19. Mai 2001, 21:15:17):
+Ich werde fuer meine Gedanken mal das SMS heranziehen, da dieser Gegenstand ja
+bisher der am heftigsten diskutierte (aus meiner Sicht) war.
+
+1. Meine Gedanken zum SMS vor und nach der 'Angleichung'
+
+Das SMS hat einen relativ hohen Schaden erzeugt, dieser war jedoch rein
+'mechanisch' (keine Feuer- oder aehnlicher Elementarschaden).
+
+Der Skill war interessant, obwohl er sehr langsam stieg, auch wenn die
+Blockrate meiner Meinung nach zu hoch war (sollte bei maximalem skill
+vielleicht alle 2 Runden, hoechstens, mal blocken).
+
+Allgemein habe ich das SMS trotz seiner Faehigkeiten eher selten benutzt, da
+ich meistens Waffen verwendet habe die mit Zusatzschaeden arbeiteten
+(Feuerschwert, Eisschwert, etc.).
+
+Nach der Ueberarbeitung ist das SMS fuer mich annaeherd wertlos, da ich damit
+einen geringeren Schade erzeuge als mit 'herkoemmlichen' Waffen, fuer die ich
+entweder einen geringen oder zum Teil garkeinen Aufwand betreiben muss um sie
+zu erhalten (z.B. das Feuerschwert).
+
+2. Meine Gedanken einer sinnvollen Alternative die vielleicht mehr Spieler
+zufriedenstellt
+
+Es waere meiner Meinung nach wesentlich sinnvoller es zu erschweren an sehr
+gute Gegenstaende dranzukommen als sie abzuwerten, da ich hier nicht mehr
+einen Sinn darin sehe in den Schacht zu gehen um mir ein Schwert zu holen,
+dass im Vergleich zum Aufwand es zu holen im Nutzen nicht entspricht.
+
+Wenn die Balance oder Spieler allgemein meinen, es sei zu leicht solche Sachen
+zu erhalten, waere es doch sinnvoller die Monster zum Beispiel zu Staerken
+oder allgemein die Moeglichkeit solche Gegenstaende zu erhalten zu erschweren
+(oder den Schacht z.B. einfach mal ein Stueck laenger zu machen).
+
+Wenn aber stattdessen die Gegenstaende abgewertet werden, dann besteht fuer
+Spieler eingentlich auch kein Anreiz mehr in den Schacht oder zu aehnliche
+:Metzelorte, (denn der Schacht ist _definitiv_ kein Forschungsgebiet! *g*) zu
+schauen, womit der Ort dann ueberfluessig werden wuerde, was ja auch nicht
+Sinn der Sache sein kann, oder?
+
+Corak
+
+-----------------------------------------------------------------------------
+
+
+
+Re: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Anoris, 19. Mai 2001, 21:34:23):
+~#! rn=Corak rt=990299717 rg=balance
+~#! tid=990299717
+Den Weg erschweren? Gut aber das SMS wird so oft verschenkt...
+
+Wie waere es wenn einfach nur der Charakter das SMS benutzen kann,
+der es ermetzelt hat?
+
+- Anoris
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Corak, 19. Mai 2001, 21:47:16):
+~#! rn=Anoris rt=990300863 rg=balance
+~#! tid=990299717
+Naja, wenns es wesentlich schwerer wird es ueberhaupt zu bekommen, dann sollte
+es auch wesentlich seltener Verschenkt werden, oder?
+
+Corak
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Varlarion, 19. Mai 2001, 21:48:03):
+~#! rn=Corak rt=990301636 rg=balance
+~#! tid=990299717
+Glaubst Du das wirklich?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Corak, 19. Mai 2001, 22:01:36):
+~#! rn=Varlarion rt=990301683 rg=balance
+~#! tid=990299717
+Ich habe bisher noch niemanden gesehen, der z.B. wandelbare Elementarschwerter
+verschenkt.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Anacrion, 19. Mai 2001, 22:02:08):
+~#! rn=Corak rt=990302496 rg=balance
+~#! tid=990299717
+Ich .. hab auch schon wandelbare SCHILDE verschenkt ...
+
+Anac*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Bielefeld, 19. Mai 2001, 22:02:10):
+~#! rn=Corak rt=990302496 rg=balance
+~#! tid=990299717
+Koennte daran liegen, dass Du keine Frau bist :)
+
+-Bielefeld . o O (verlegt das wer?)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Anacrion, 19. Mai 2001, 22:06:29):
+~#! rn=Bielefeld rt=990302530 rg=balance
+~#! tid=990299717
+Allerdings nicht an Wuerste (ausgenommen eigene Zweities ;-) ).
+
+Anac*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Firehawk, 19. Mai 2001, 22:10:49):
+~#! rn=Anacrion rt=990302789 rg=balance
+~#! tid=990299717
+Also fassen wir zusammen:
+Schwerer an die Sachen ranzukommen hindert einen nicht sie verschenken (gut
+hier wurden ein paar schoen falsche Beispiele genannt, aber gut).
+Da is die Idee mit dem nur selber benutzen besser (der Geist der Waffe
+verweigert Dir den Dienst weil Du ihn nicht selbst ueberwunden hast oder so).
+Es sollte aber reichen wenn man zumindest mitgeholfen hat, es waere ja fies
+wenn 3 Leute im Team kaempfen und der Zauberer ist der einzige der das Schwert
+benutzen darf weil er den letzten Schlag hatte *fiesgrins*.
+
+Firehawk, holt sich sein Zeugs fuer gewoehnlich selber.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Deepblue, 19. Mai 2001, 22:18:18):
+~#! rn=Corak rt=990299717 rg=balance
+~#! tid=990299717
+Aha, das SMS ist jetzt schwaecher als andere Waffen mit zusatzschaden, die
+ohne grossen Aufwand erhaeltlich sind. Sind diese Waffen nicht vielleicht auch
+zu stark? Balance, tu was ! <duck>s
+
+-----------------------------------------------------------------------------
+
+
+
+balance (Pertinaxe, 19. Mai 2001, 22:22:31):
+Mein Hauptskill wird demnaechst sein, mit meinem Rollstuhl den Mitspielern
+ueber die Fuesse zu fahren.
+Ich weiss nicht, die wievielte Abwertungskampagne das ist, die ich erlebe.
+Die Ursachen sind immer diesselben, die Bekaempfungsversuche ebenfalls, das
+Ende vom Lied sind noch ausgefeiltere Skripts, noch abgefahrerne Trigger.
+Ich haette zwar diverse Loesungsansaetze, aber bei dem scroll verzichte ich
+vorlaeufig drauf. Das Hamsterhaeuschen dreht sich immer schneller, die Hamster
+passen sich an und verwenden am Ende das Fett aus den Kugellagern um
+Sprengstoff daraus zu machen.
+Ohne gnadenlos restriktive Abruestung laesst sich das nicht mehr in den Griff
+kriegen.
+Das Drachenkillen war frueher mal eine echt gefaehrliche Sache, heute skripten
+doch manche da 20 mal am Tag durch wenns denn unbedingt sein muss.
+Solange die Waffenproduzenten ihren Spass an immer neuen noch abgefahreren
+Varianten, die NPC-Bauer sich drauf einstellen und die Spirale noch mehr
+andrehen, wird das nix. Zumal sie programmtechnisch immer nur eine Seite vor
+den Verfolgern, also den Spielern sind.
+Nur noch gnadenlose Restriktion hilft da. Dann gibt es eventuell eben keinen
+praktisch killbaren Drachengott o.aehnliches mehr. Diejenigen, die als
+NPC-Programmiere ihren Spass damit haben, treiben den Wahnsinn genauso vorran.
+Ergo: Blutsaugerschwert nur noch fuer denjenigen, der sich das selber auch
+erkaempfen kann,
+Wenn im team erkaempft, gehoert es dem, der den Kill gemacht hat.
+Das das funktioniert, zeigt doch die Einschraenkung des "Ring der Winde".
+Kinner, gnadenlos abruesten ist das einzige was noch geht.
+Perti
+
+-----------------------------------------------------------------------------
+
+
+
+Re: balance (Wurzel, 20. Mai 2001, 03:58:47):
+~#! rn=Pertinaxe rt=990303751 rg=balance
+~#! tid=990303751
+das mg ist kein spiel, das man irgendwann "gewonnen" hat. man kann immer
+weiter machen, und das ist ja auch ein gewisser reiz. trotzdem kommt fuer
+fast alle irgendwann der zeitpunkt, wo der rollstuhl das richtige ist...
+insofern bist du da nicht einzigartig. und das hat mit abwertungen nichts
+zu tun. die ruestungsspirale gab es schon, bevor ueberhaupt jemand an das
+morgengrauen gedacht hat, und du kannst sie nur dann abschaffen, wenn jede
+weiterentwicklung eingestellt wird. willst du das?
+gnadenlose restriktion? haben wir schon lange. mit schoener regelmaessigkeit
+werden die balanceregeln erweitert und auf weitere dinge erstreckt, bald
+wird der zeitpunkt kommen, an dem man ohne genehmigungsverfahren nur noch
+details schreiben darf. ursache ist klar: kreativitaet muss eingeschraenkt
+werden. jedenfalls fuer alles, was nicht standard ist, weil man fuer mehr
+oder weniger intelligente items auch mehr oder weniger intelligente
+anwendungen finden kann. und sowas stoert natuerlich die ruhe...
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: balance (Anacrion, 20. Mai 2001, 06:07:50):
+~#! rn=Wurzel rt=990323927 rg=balance
+~#! tid=990303751
+Also den ersten Satz hast Du glaub ich aus einem meiner Artikel geklaut ;-)
+
+Mit dem Rest allerdings muss ich sagen, stimme ich aeusserst wenig ueberein.
+Ohne mit Begruendungen wie Realismus zu kommen, sehe ich die Relation zwischen
+aelteren Regionen und neueren (also den Monstern und der Ausruestung darin)
+nicht mehr gegeben. 
+
+Selbstverstaendlich wollen die meisten Magier die tollste Ausruestung und die
+tollsten Monster geproggt haben, damit entweder
+a) Ihr Ranking bei Rochus sich verbessert
+b) Ihr Ego bestaetigt wird
+c) Es ihnen was gibt, dass zu tun.
+d) Eine beliebige Kombination aus a) b) und c).
+
+Ich moechte an der Stelle nicht pauschalieren, es gibt Magier, die nicht in
+diese Kategorie fallen, genannt seien an dieser Stelle Feuerwehr, Ark,
+Silvana, Zardoz oder Toeter, deren Gegenden beweisen, dass man auch ohne die
+'tollsten' Monster und die 'tollste' Ausruestung Spass und Stimmung erzeugen
+kann. (Die Spieler, die durch AdT mit KL durchrennen tun mir leid, und auch
+wenn Ark Kerben von mir hat moechte ich diese Quest nicht missen - Anm. d.
+Red.).
+
+Leider ist es so, dass, wenn man sich unterschiedlichen Gegenden des MGs
+anguckt, einige wenige Gegenden mit Ausruestungsgegenstaenden jenseits dessen
+glaenzen, was anderswo zu holen ist. Mit diesen Ausruestungsgegenstaenden ist
+es wiederum moeglich, dass Monster, die nie dazu gedacht waren, alleine
+bezwungen zu werden, in wenigen Minuten vor einem Spieler im Staub liegen.
+Dafuer gibt es dann tolle neue Monster auf die wieder neuere noch tollere
+Monster folgen nur um auch wieder im Zuge der Spirale von einzelnen bezwungen
+zu werden.
+
+(Korrigiert mich wenn ich falsch liege, aber vor ca. 1 Woche hat z.B. Darkwing
+nur mit Unterstuetzung eines Zaubererzweities Nars kleingehauen.)
+Anti-Feuer-Ringe sind durch massive Weghiermetzelei schon so haeufig geworden,
+dass die Spieler gleich 3 mitnehmen um durch schnelles Wechseln einer
+Ueberhitzung zuvorzukommen. Dadurch werden dann allerdings wieder diverse
+Feuerebenen zum Kinderspiel. Ausgenommen gewisser Monster wie z.B. Surtr,
+versteht sich. Aber auch deren Zeit wird kommen oder sie werden schnell
+aufgewertet.)
+
+Wenn ich mir die Elfenwaechter im Glockenwald angucke und die in der
+Eiselfenfestung .... also ich kann ein Heer von 200 Gardewaechtern schicken
+und denke, dass 20 Eiselfenwaechter locker gewinnen duerften. Und ich glaube
+auch nicht, dass 300 Gardis den Zwergenangriff abwehren koennten.
+
+Wenn Du das unbedingt 'Kreativitaet' nennen willst: Es sei Dir gegoennt.
+Meiner Meinung nach spiegelt sich Kreativitaet bei Monstern und Gegenden
+allerdings NICHT in der Anzahl der Nullen bei WC, AC und HitPoints wieder.
+
+Es mag Magier geben, die Kreativ sind und einfach ihren Monstern eine kleine
+'Vitaminspritze' verpassen, sollten sie zu oft gehauen werden. Ich erinnere da
+an einen gewissen Nekromanten, dessen Gefilde ein nichtsahnender Seher mit
+einem einfachen 'unt ruine' betreten kann (die er im uebrigen selten
+verlaesst, wenn der Befehl nicht aeusserst bewusst eingegeben wurde). Dieser
+Nekromant war, nachdem er in kuerzerer Zeit mehrfach ohne groessere Gegenwehr
+einem Team aus Kaempfern, Klerikern und Magistern vielerlei
+Spezialisierungsrichtungen zum Opfer viel ploetzlich nicht mehr zu treffen und
+befoerderte das halbe Team zu Lars. Ist das die 'kreative' Antwort auf die
+Ruestungsspirale ?
+
+Waere es nicht viel sinnvoller, die _zahlenwerte_ der Ueberitems einfach zu
+beschneiden? Wuerde doch auch der Kreativitaet beim Schreiben der Monster zu
+gute kommen, wenn man sofort die richtige Zahl Nullen findet, weil man weiss
+wieviel Schaden die Spieler machen (koennen). Ist es der Kreativitaet so
+hinderlich, nicht die 5te Null an die LP-Zahl des Monsters haengen zu duerfen
+weil die NPC-Balance das zu hart findet oder das Schwert halt nicht Hitfunc,
+DefendFunc und Mehr_als_max_WC haben darf?
+
+Ich bin vielleicht nicht der repraesentative Spieler, da ich
+Ausruestungsbeschaffung aeusserst laestig finde und mir lieber neue Gegenden
+angucke, als meinen 5000ten Gardewaechter, Paraork zu hauen oder irgendwelche
+von Morgoths Daemonen zu verhauen.
+
+Doch ich glaube, dass ich in einem mit den meisten Metzlern uebereinstimme:
+Man will eine _Herausforderung_ beim metzeln.  Eventuell findet man diese im
+erreichen der magischen 25 in Form eines goldenen Drachentoeterordens, auch
+wenn man im Parabaum nicht mehr weiss, wo man die Knochen der 25
+Hoellendrachen unterbringen soll, die man waehrend der vergangenen 25 Resets
+in den Staub getreten hat. Meistens jedoch findet man diese in Gegnern, die
+man eben NICHT 'einfach mal so' wegplaettet. Durch immer staerkere Waffen und
+Ruestungen verschwinden diese Herausforderungen und es muessen immer wieder
+neue her.
+
+(Korrektur: neue _und bessere_ Waffen und Ruestungen)
+
+Waere es nicht viel schoender, wenn die Herausforderungen ADDITIV anstatt
+SUBSTITUTIV waeren? Ich erinnere mich noch, damals zu dritt beim
+Hoellendrachen ... und was fuer nen Bammel haben wir gehabt ... und heute ...
+da huepft man kurz alleine den Baum hoch, gibt dem Alten eins auf die Muetze
+und sieht zu, dass man schnell die anderen 5 Drachen abgehakt bekommt.
+
+In Addtition zu einer grossangelegten Ausruestungsabwertung (Mir schwebt der
+Feuerkarateka genauso wenig als Zielzustand vor wie Toeter und Zardoz damals
+bei der Staerkeberechnung der Kaempfergilde die AntiXXXXX[1]-Vollruestung mit
+XXXXX[2] vorgeschwebt ist.) koennte man evtl. folgendes tun:
+
+a) Eine Anzahl von ... sagen wir grob 200 ... fuer das MUD repraesentativen
+Monstern nehmen und allen von diesen Monstern verursachten Schaden und ihnen
+zugefuegten Schaden nach Gilden sortiert loggen.
+b) Diese Zahlen ermoeglichen es, die Gildenstaerke objektiver zu vergleichen.
+c) Aus diesen Zahlen koennte man eine Art 'Inflationsrate' berechnen. (Die
+Daten der letzten Uptime im Vergleich zu den Anfangsdaten) und die
+Monsterstaerken beim clonen mit einem entsprechenden Faktor multiplizieren.
+Man koennte auch verschiedene Branchenindices erstellen fuer z.b.
+untote/daemonen, engel, feuerwesen .... jegliche Balanceentscheidungen
+bezueglich einzelner zu starker Waffen wuerden auch die ohne diese Waffen
+unspielbaren Gegner binnen 1 oder 2 Uptimes automatisch abwerten ....
+
+Soviel zu meinen Gedanken und Vorschlaegen
+
+Anac*
+
+[1] Ersetze beliebige nichtphysikalische Schadensart, die meisten sind
+abgedeckt
+[2] Ersetze beliebige Kombination aus nichtphysikalischer Schadensart (siehe
+[1]) und des dem betreffenden Kaempfer am besten liegenden Waffentyps
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: balance (Darkwing, 20. Mai 2001, 10:42:26):
+~#! rn=Anacrion rt=990331670 rg=balance
+~#! tid=990303751
+Huhu Anacrion,
+
+Bevor diese Nars-Geschichte noch weiter ausartet... ich wollte nur Anatol ein
+wenig aergern, da er gerade die letzte einfache Rolle hinter sich hatte - da
+kam mir so ein gewisser Trichter gerade recht.
+
+Nunja, immerhin bist DU voll drauf reingefallen :-)
+
+Darkwing, mit einem "Nars ist ne Lusche!"-Faehnchen wedelnd ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4954: Hach... nu is was drin, inner MPA. (Anacrion, 20. Mai 2001, 16:29:40):
+~#! rn=Bielefeld rt=990340824 rg=megaschmarrn
+~#! tid=982328278
+Hallo Darkwing :-)
+
+Weil ich nur diverse Logs zur Verfuegung hatte, schrieb ich auch 'Korrigiere
+mich jemand, falls ich mich irre'. 
+
+Ich glaube dennoch, dass mein Artikel nicht den geringsten Hauch an Validitaet
+verliert, auch wenn Du Nars NICHT alleine schaffst - was ich im uebrigen
+herzlich begruessen moechte.
+
+Ich denke jeder kennt genug Beispiele, wo einstmals gefaehrliche Monster zu
+einer Soloangelegenheit weniger Minuten wurden.
+
+Anac*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ja was denn noch .. (Patryn, 20. Mai 2001, 18:47:06):
+~#! rn=Ark rt=990199334 rg=balance
+~#! tid=990173074
+im zweifel...yo. das rattenblut zb betrachtete ich als altlast und war
+durchaus nicht gegen eine abwertung. nur der umfang scheint mir etwas
+zu gross...und allen spielern wohl auch ;)
+dann gabs noch diverse andere sachen, bei denen man mir wohl nicht so
+recht glaubte, dass sie so schwer zu holen sind, dass mir die
+gewuenschten zahlwerte etwas schlank erschienen.
+nun ja, ich kann eigentlich damit leben, ich hab ja nicht geschrieben dass
+ich deshalb balance bloed finde und finde die arbeit auch wichtig.
+deshalb muss ich trotzdem nicht alles toll finden, was da entschieden
+wird, ich muss mich lediglich dran halten, und das tue ich.
+
+------
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Fehler im System? (Pilgrim, 20. Mai 2001, 19:00:21):
+@(Balance et al.),
+
+Hi ... hier mal meine paar Gedankengaenge zur Balance und insbes. zum 
+(immer wieder auftretenden) 'Abwerten' von Waffen, Ruestunge usw.).
+
+a) Ab einer bestimmten Groesse (und eines  bestimmten Alters) eines 
+   MUDs ist eine 'Balance' unvermeidlich und notwendig; zumindest 
+   solange, wie es Magiern erlaubt ist 'frei' Ausruestung und NPCs zu 
+   programmieren und nicht nur auf einen Pool von Standardobjekten 
+   zurueckzugreifen, deren Details man nur abaendert. 
+b) Sinn und Zweck der Balance ist es, den langfristigen Spielspass 
+   fuer alle (bzw. den ueberwiegenden Teil) der Spieler (das schliesst
+    Magier ein) aufrecht zu erhalten oder wiederherzustellen. 
+    [Sollten Eingriffe des Balanceteams den Spielspass fuer den 
+    Grossteil der Spieler/Magier (massiv) verringern, kann man davon 
+    ausgehen, dass diese Aenderungen unsinnig sind.] 
+
+Wodurch zeichnet sich nun langfristiger Spielspass aus? 
+1) durch ein faires Spiel fuer alle 
+2) durch Herausforderungen, deren Bewaeltigung dem Spieler eine Form 
+   von Befriedigung verschaft (schliesst das Programmieren durch Magier 
+   mit ein) 
+3) durch fortwaerende und kreative (nicht langweilige) Erweiterung bzw. 
+   Weiterentwicklung des MUDs 
+4) durch einen fairen und 'gesitteten' Umgang der Spieler mit-
+   (untereinander) - schliesst Magier mit ein ... an dem Wort 'gesittet' 
+   moege man sich nicht stoeren, mir viel kein anderes ein ... 
+5) ... vielleicht gibts da noch mehr, aber fuers erste reicht das wohl.
+
+Was kann man nun machen, um den langfristigen Spielspass zu sichern? 
+Tja, ich glaube nicht, dass es da ein simples Patentrezept fuer gibt; 
+sicher duerfte nur eins sein: die sog. Ruestungsspirale muss 
+unterbrochen - zum Teil sogar zurueckgeschraubt - werden.
+
+Jeder versteht, dass diese SuperItems zwar dem Besitzer (kurzfristig) 
+ne Menge Freude bereiten und auch der progende Magier i.d.R. Recht 
+stolz auf sein Werk ist ... leider bringen solche Items - wenn sie 
+nicht ganz genau auf bereits bestehende Sachen abgestimmt sind - das 
+ganze spielerische Gelichgeweicht das MUDs auseinander. 
+
+Was naehmlich passiert ist folgendes: 
+a) Bestimmte NPCs/Waffen/Ruestungen oder Regionen werden immer wieder
+   angepasst - nicht gerade das, wass Spieler und Magier lieben ... 
+   und wenn man das nicht macht, ist das in der Regel auch nicht besser.
+   Denn alle Items (usw.) dieser Regionen sind dann ja auch viel leichter 
+   zu haben ... schliesslich konnte man ja vor 2 Jahren nicht wissen, 
+   was es heute alles so gibt ... 
+b) Man stezt gleich alle moeglichen Resistenzen ein, hohe Werte fuer
+   Lebens- und Kampfkraft ... baut noch nen paar dynamische Schweinereien
+   ein ... und verpasst diesem/r Supermonster/Superregion gleich noch 
+   ein SuperItem ... damit es sich fuer Spieler ueberhaupt 'lohnt', die 
+   ganze Quaelerei auf sich zu nehmen ... 
+Auf jedenfalls dreht man sich im Kreis, oder besser auf ner Spiral (der 
+Ruestungs- spirale) immer weiter nach oben. Die Konseqenz ist, dass 
+insbes. neue und mittlere Spielerlevel stark benachteiligt sind ... 
+mitunter der Nachwuchs ganz weg bleibt und das MUD sozusagen Vergreisst
+... oder sonstwas ... auf jedenfall geht der Spielspass den Bach runter.
+
+O.K. ... soweit nix neues. Was koennen wir also tun?
+
+Nun zwei Dinge sind meines Erachtens wichtig: 
+
+1) SuperItems muessen in Ihrer Nutzbarkeit und Ihrer Anzahl stark 
+(viel staerker als bisher) beschraenkt sein. Es sollte generell kein
+Item geben, dass _nur_ gut ist; jede SuperFaehigkeit sollte durch 
+irgendwelche SuperNachteile relativiert werden. 
+
+Magische Waffen und Ruestungen - z.B.- sollten generell beim Tragen/
+Fuehren/Kaempfen MPs kosten oder MAX-MP herunter setzen. Wenn ich z.B. 
+ein FeuerSchwert hab', sollte es fuer den Vorteil 'Feuerschaden' 
+neben der logeischen 'Anfaelligkeit gegen Wasser oder Eis' allein 
+schon zum mit sich Herumtragen von Zeit zu Zeit FeuerSchaden beim 
+Besitzer herbeifuehren ... bzw. Ihn x MP's kosten gerade diesen Schaden
+zu verhindern - das Schwert also magisch in Schach zu halten. 
+Oder so aehnlich ... Magische KapmfItems z.B. koennten durchaus mal den 
+Fluchwillen ausschalten (falls man keine MP's hat, um das zu verhindern), 
+da sie 'einfach weiterkaempfen wollen' - selbst bis in den Tod ihren 
+Besitzers ... oh, da gibt es viel schoene Sachen ... wo ein Magier seine 
+ProgrammierFantsien ausleben kann ;-) 
+
+2) SuperItems sollten generell nur in begrenzter Anzahl da sein. Sie 
+sollten z.B. nicht von jeder Rasse/Gilde gleichgut zu nutzen sein ... 
+auch ueber die Weitergabe sollte man gut nachdenken ... Das Horten 
+von SuperItems sollte prinzipell nicht moeglich sein - bzw zumindest 
+geloggt werden, damit Magier das zumindest wisssen (und den entsprechenden
+Spieler bei Unmutsaeusserungen der anderen Spieler verpetzen 
+koennen -haehae- ;-) ).
+
+Oft wird gesagt ... ja, das SuperSchwert X ist ja sooo schwer zu 
+bekommen, da muss man erst 4.123.397 Monster fuer killen, oder ... 
+ja, die SuperRuestung Y ist ja nur [1/random(20.234.321)]*supgergut,
+alle anderen sind ja nur mittelmaessig. ... 
+Tja, leider aendert sich unser MG viel schneller, als machen denken
+und was vor einem Jahr nur 'ner Horde Highst Level Playern moeglich
+war, kann heute schon jeder verwunschen Frosch und unser MG ist auch 
+viel stabiler, als viele denken ... mit den langen up-Zeiten sammeln 
+sich auch Items mit geringen Wahrscheinlichkeiten ganz schoen an ... 
+D.h., diese Beschraenkungen reichen m.E. nicht aus.
+
+Was auch noetig ist, sind definitive Schranken fuer Ruestungs- und 
+Angriffswerte! Ja ... das gefaellt niemandem ... ist aber die _einzige 
+Chance_ zu garantieren, dass ein einmal gesetzter Schwierigkeitsgard 
+auch in Zukunft erhalten bleibt. Kein Spieler sollte jemals ueber eine 
+best. Kampfkraft herauskommen koennen! 
+
+(Im Prinzip war das ja auch immer schon so gedacht ... es gab zu Begin 
+Regeln ala maximale Lebensenergie, maximale Kraft, maximale 
+Magiepunkte sowie Maximalswerte fuer Waffen und Ruestungen. Dann kamen 
+die 'Ausnahmen' ... erst eine, dann zwei ... langsam nahmen die 
+Ausnahmen ueberhand, wurden zur Regel; also hat man die Balance 
+eingefuert ... um Ausnahmen zu genehmigen ... leider hat die Balance 
+nie darauf geachtet, sich eine feste, nicht mehr zu aendernde 
+Maximalkampf- und Abwehrkraft von Spielern zu setzen und die 
+genehmigten Items konsequent - und ohne Ausnahmen - danach zu 
+genehmigen. Das ist Folge der Tatsache, dass man hier danach strebt(e), 
+die Kampfkraft von Items zu begrenzen, anstatt die von Spielern ... 
+also ein Fehler im System!) 
+
+Die Balance muss also dafuer sorgen, dass sich SuperItems z.B. nicht 
+so kombinieren lassen, dass Spieler gewisse Werte ueberschreiten 
+koennen ... also wenn (SuperHose+SuperRuestung+SuperRing) einen 
+Spieler zu gut schuetzen wuerden, muss verhindert werden, das er die 
+drei Dinge gleichzeitig tragen kann. 
+
+Fuer einen Spieler ist das nat. sehr unbefriedigend ... aber ne 
+andere Loesung seh' ich nicht. Noch viel unbefriedigender sind 
+naehmlich andauerndes Abwerten von Items oder Aufwerten von NPCs. 
+Und ... warum machen wir uns die Muehe, HitPoints und Spellpoints 
+im Spieler (rassenabhaenging) zu begrenzen, wenn wir das dann 
+mit Items sowieso wieder umgehen ... ?
+
+Pilgrim
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Fehler im System? (Padreic, 20. Mai 2001, 19:46:40):
+~#! rn=Pilgrim rt=990378021 rg=balance
+~#! tid=990378021
+Das MorgenGrauen ist schon lange kein reines Questmud mehr, sondern ein Mud in
+dem Metzler, Forscher und Quester in einer mehr oder minder friedlichen
+Koexistenz nebeneinander leben. Manche NPCs werden von Forschern und Questern
+sicherlich nie gekillt werden koennen und einige NPCs die fuer einen Forscher
+vielleicht richtig schwer zu killen ist, stellt fuer einen HLP Metzler kein
+Problem da. Doch wo ist das Problem?
+Niemand faengt hier als HLP an und steigert sich in seiner Kampfkraft nach und
+nach und erlebt alle Gebiete irgendwann mal als schwierig, auch alte
+tendenziell "schwache" Metzelgebiete. Doch was spricht gegen neue, immer
+schwierigere Gebiete mit neuen Items die natuerlich auch staerker sind, als
+ein Gardischwert. Allein die Tatsache das man damit die alten Gardis "zu
+leicht" umhaut ist fuer mich kein echter Grund, auf Dauer metzelt man als HLP
+dann dort eh nicht mehr (Lug bestaetigt die Regel :o). Trotzdem verlieren die
+Gardis kein bisschen von ihrer Existenzberechtigung, denn irgendwann auf dem
+Weg zum HLP-Metzler wird man auch diese mal als Herrausforderung gesehen
+haben. Ich glaube ein lebendiges sich weiterentwickelndes Mud _braucht_ ein
+gewisses Mass an Ruestungsspirale um wirklich interessant zu bleiben.
+Wenn ich drei Jahre im MG gepaust habe und zu den neuesten haertesten NPCs
+mitgehen kann ohne mich auch darum zu kuemmern was es an neuer Ausruestung
+gibt, dann ist das fuer mich kein Traumzustand, sondern der Anfang vom Ende
+des MG, denn wir brauchen auch fuer alte hohe Spieler noch neue Anreize.
+Die Balance brauchen wir in meinen Augen um sicherzustellen, das die
+Ruestungsspirale nicht ausufert und das das Verhaeltnis zwischen Qualitaet und
+Aufwand einer Waffe in einem gesunden Verhaeltnis steht. (Wenn Spieler sich
+nackt eine Topausruestung besorgen, dann stimmt naemlich wirklich was nicht).
+Die Abwertungen der letzten Zeit betrachte ich zum Grossteil als Altlasten,
+die insbesondere auf neue Gildenfaehigkeiten wie Waffenskills zurueckzufuehren
+sind.
+
+Pad*
+
+P.S.: Ich kann mich noch gut erinnern, das Patryn auf ner Party mal sagte:
+Sobald der erste den Rattenskill auf 80% hat, muss ich den abwerten, er ist zu
+gut. Das ganze ist also eher ein Fall der zeigt, das auch die Balance mal
+etwas verschlafen kann. Ob die Korrektur nun zu stark war oder nicht, ist eine
+andere Sache. Korrektur war jedoch auf alle Faelle noetig.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Fehler im System? (Anacrion, 20. Mai 2001, 19:53:37):
+~#! rn=Padreic rt=990380800 rg=balance
+~#! tid=990378021
+Nette Argumentation ... leider hat sie eine Luecke:
+
+Wenn HLP A mit HLP-Waffe B auf HLP-Metzelgebiet C in allen aelteren Gebieten
+die 'schwereren' Monster einfach mal umknockt, und dann evtl. noch die
+Nicht-Ganz-so-HLP-aber-immerhin-supergut-Waffe dieser Monster einfach mal
+weitergibt, ueberspringen die neuen Spieler einfach mal schnell die
+Entwicklungsstufen, in denen z.B. der Gardewaechter oder der Tempeldrache eine
+Herausforderung ist.
+
+Desweiteren eliminieren diese supertollen HLP-Items aus anderen Gegenden
+jegliche Balance in existierenden Gebieten ....
+
+Anac*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Fehler im System? (Pilgrim, 20. Mai 2001, 21:58:31):
+~#! rn=Padreic rt=990380800 rg=balance
+~#! tid=990378021
+>  Doch was spricht gegen neue, immer
+> schwierigere Gebiete mit neuen Items die natuerlich auch staerker sind, als
+> ein Gardischwert. Allein die Tatsache das man damit die alten Gardis "zu
+> leicht" umhaut ist fuer mich kein echter Grund,
+Gegen neue Gebiete spricht nix ... auch nicht gegen schwere ... aber auch neue
+leichtere Gebiete finde ich nicht schlecht ... wenn jedoch die Anzahl
+der verfuegbaren SuperItems steigt, tendiert man bei der Programmierung
+eher zu schwrigen Gebieten ... ob das besser ist, weiss ich nicht.
+
+Aber warum sollten neue Items 'natuerlich staerker' sein ... das versteh ich
+nicht ... neu, anders, interessant, nuetzlich, saerker auf einem bestimmten
+Gebiet ... ja, ber einfach nur staerker ... wofuer?
+Wofuer braucht jemand ne Waffe, um alte Gardis ... die er auch schon so
+relative einfach umgehauen hat noch ne neue Waffe, mit der das noch etwas
+besser geht? Nein, was die Person sucht ist ja auch keine Waffe, um Gardis
+noch schneller zu plaetten, sondern um das fiese Obermonster zu killen, an dem
+er sich bis jetzt immer die Zaehne dran ausgebissen hat ... und dafuer mag
+_eine_ neu Waffe auch ganz sinnvoll sein ... nur ich seh' wiederum keinen
+Grund, warum dann diese Waffe auch gegen 10 andere Obermotze so gut sein soll?
+Das ist doch total langweilig.
+Das fuert zu einer Verarmung ... was sich bei lange up-zeiten leicht sehen
+laesst ... durch ermetzeln und verschenken nimmt das verhaeltniss von
+superwaffen zu normalwaffen immer mehr zu ... auch bei spielern, die sich eine
+solche waffe gar nicht 'leisten' koennten ...
+
+> Ich glaube ein lebendiges sich weiterentwickelndes Mud _braucht_ ein
+> gewisses Mass an Ruestungsspirale um wirklich interessant zu bleiben.
+Jein ... wenn einfach nur neue UniversalSuperItems dazukommen, die andere
+aelter UniversalNichtmehrganzsoSuperItems abloesen, nicht ...
+Ein MUD muss immer herausfordernt bleiben ... fuer alle, ja ... 
+
+> (Wenn Spieler sich
+> nackt eine Topausruestung besorgen, dann stimmt naemlich wirklich was
+nicht).
+Wenn die Haelfte der Newbies nach 40 Tagen up mit SuperItems rumlaueft stimmt
+doch auch was nicht ... (wobei Newbis auch durch Nicht-HLPs ersetzen kann).
+
+> Die Abwertungen der letzten Zeit betrachte ich zum Grossteil als Altlasten,
+> die insbesondere auf neue Gildenfaehigkeiten wie Waffenskills
+zurueckzufuehren
+> sind.
+Ja ,,, sag ich ja ... aber es werden neue Gildefaehikeiten, neue Items, neue
+WasWeissIch dazukommen ... und neue Anpassungen (Abwertungen) noetigmachen ,,,
+immer und immer wieder ... und das liegt am System. Im Endeffekt ist halt
+die Frage, was einem besser gefaellt ... zuerst der Kreativitaet (oder
+manchmal auch einfach nur dem Ruestungswahn) seinen Lauf zu lassen und dann,
+wenn das Ding zusehr reinschlaegt, abzuwerten ... oder vor dem Anschluss
+einzuschrenken um dann seine Krativitaet einzusetzen, ...
+
+Pilgrim
+*.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Fehler im System? (Varlarion, 20. Mai 2001, 23:07:28):
+~#! rn=Pilgrim rt=990388711 rg=balance
+~#! tid=990378021
+Ich kann mich deiner Meinung nur anschliessen. Vor allem, was neue Gebiete
+angeht, sollte man auch mal an Spieler kleinerer und mittlerer Level denken,
+anstatt weitere Super-NPCs mit 8 Angriffen die Runde, Resistenzen bis zum
+Abwinken und irgendwelchen Super-Items im Gepaeck zu basteln. Auch auf
+niedrigerem Schwierigkeitsgrad kann man seiner Kreativitaet freien Lauf
+lassen.
+Als positives Beispiel moechte ich hier mal Tillys Innutitdorf nennen,
+sicherlich auch kein Gebiet fuer den Anfaenger, aber ein rundherum schoenes
+Gebiet, wo Forschen wie Metzeln eine Menge Spass machen, auch ohne, dass es
+dort die Super-High-End-Waffe gibt, mit der man Super-High-End-NPC einfach so
+wegzappen kann. Dafuer gibt es dort schoene Spielzeuge [*], Details, die einen
+einfach mal zum Schmunzeln bringen und interessante NPCs, mit denen man sich
+unterhalten kann, bevor man sich den Erstkill "abholt" ;)
+
+[* gemeint sind hier Dinge, die einfach nur Spass machen]
+
+Klar muss sich das MG weiterentwickeln, aber muss das wirklich so aussehen,
+dass auf Super-NPC X Super-Waffe Y und darauf Super-Gilde Z folgt?
+So, jetzt schreibt schoen eure Antworten, die da besagen, wie toll ihr seid
+und was fuer einen Quatsch ich erzaehle, aber ich stehe zu der Meinung, dass
+die Ruestungsspirale ruhig mal gestoppt werden sollte.
+
+Varl*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Catweazle, 21. Mai 2001, 09:05:03):
+~#! rn=Corak rt=990299717 rg=balance
+~#! tid=990299717
+> Es waere meiner Meinung nach wesentlich sinnvoller es zu erschweren an sehr
+> gute Gegenstaende dranzukommen als sie abzuwerten, [..]
+
+Kurzer Einwand dazu, das ist genauso sinnlos, wie eine ultralangsame
+Lernkurve. 
+Wer genug Zeit hat, hat auch bei der langsamsten Lernkurve die
+Stats/Faehigkeiten auf Maximum. Das heisst in ein bis zwei Jahren, hat jeder
+der eine Waffe/Ruestung/Tool benutzt die maximale Wirkung. Es macht nur sinn
+mit dem maximalen Wert zu rechnen. 
+
+Ebenso kann man gute Gegenstaende so unerreichbar machen wie nur moeglich, bei
+genuegend langer Uptime (und wir sind leider staendig fuerchterlich lange up)
+gibt es doch wieder 100 clones des Supergegenstandes.
+Einzige Loesung dabei waere Uniqueness oder zumindest begrenzte Anzahl von
+Clones.
+
+YTC
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Anacrion, 21. Mai 2001, 09:08:51):
+~#! rn=Catweazle rt=990428703 rg=balance
+~#! tid=990299717
+Ich muss sagen, dass ich die idee mit vielen Uniques prinzipiell gut finde ...
+richtig schoen viele ... und alle mit anderen Faehigkeiten ... am besten jede
+Waffe mit WC<170 bei zweihaendern unique machen ... dann kann man auch ein
+paar mehr davon unterbringen.
+
+Also prinzipiell ...
+
+Anac* sagt: Tod der Standardsuperduperausruestung.
+
+P.S. Manche Items, wie z.B. Narya gehoeren meiner Meinung nach allerdings
+einfach nur geloscht, weil zu gut.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Anacrion, 21. Mai 2001, 09:09:51):
+~#! rn=Anacrion rt=990428931 rg=balance
+~#! tid=990299717
+WC>170 ;-)
+
+Aber duerfte wohl klar sein
+
+Anac* - korrigierend
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Padreic, 21. Mai 2001, 09:45:04):
+~#! rn=Anacrion rt=990428991 rg=balance
+~#! tid=990299717
+Ich habe noch nicht erlebt das jemand auf Seher unbedingt einen Kriegshamster,
+Panzer der Gier oder magische Robe verschenken wollte. Genausowenig hab ich
+100 Sonnenszepter irgendwo rumfliegen sehen. Die Gebiete sind auch schon in
+die Jahre gekommen, aber dennoch laeuft dort nicht "mal eben so" jemand
+alleine durch. Vielleicht auch eine Frage der Konzeption der Gebiete.
+Es ist eine Frage wie ausbalanciert die Gebiete mit ihren Gegenstaenden sind
+und genau _dazu_ brauchen wir meiner Meinung nach eine Balance. Alles an den
+Katas zu messen ist da denke ich der falsche Ansatzpunkt. Gebiete muessen gut
+ausbalanciert sein und sie bringen das mud vorran. Sind sie es nicht geht der
+Schlag halt nach hinten los und die Balance muss und sollte einschreiten.
+
+Pad*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: ja was denn noch .. (Ark, 21. Mai 2001, 11:03:34):
+~#! rn=Wurzel rt=990289792 rg=balance
+~#! tid=990173074
+Ich nehme das als Anlass, mal ein paar gildenspezifische Sachen zu schreiben
+... langfristig ;^)
+Begruendungen dafuer lasse ich mir einfallen, keine Angst.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: ja was denn noch .. (Terrorist, 21. Mai 2001, 14:36:39):
+~#! rn=Ark rt=990435814 rg=balance
+~#! tid=990173074
+Uiui wie in altenm Zeiten ;)
+
+Hmm also zu dem Thema verschenken von Max rues oder wasweissich ...
+Ich muss gestehen das ich mit Level 3 von ein paar guten Freunden sehr gut
+ausgerustet wurde, dennoch hatte ich Probleme mit z.B. Gardewaechtern.
+Und das obwohl man damals mit Level 3 alle ZT's haben konnte (Mir fehlten noch
+10-15 oder so).
+Max rue heisst noch lange nicht das man Levelunabhaengig ist.
+Aber ich gebe denen Recht die dagegen sind.
+Ich habe lange auf den Seher zugearbeitet, um dann endlich von Khidar meine
+erste Schattenruestung zu bekommen :)
+Die hat er naemlich nur Sehern gegeben *g*
+Die Art von Khidar fand ich prima. Aber soetwas laesst sich nicht erzwingen.
+Ich bin selbst ein schlechtes Beispiel dafuer gewesen.
+Die singenden Speeren waren oftmals mein, und ich entschied wer sie bekam.
+Kanns das sein?
+Das kommt frueher oder spaeter bei beschraenkten Waffen raus ...
+Ich weiss nicht mehr genau wie es mit dem VS gehandhabt wird, glaube mich aber
+zu erinnern das er regelmaessig bei dem Besitzer verschwindet ... naja kein
+Prob, man holt sich den ersten, und den 5., den kann man im Notfall in einem
+Zweitie unterbringen ..
+ImEndeffekt sorgt man dafuer das die Balance wieder ausgeheblt wird.
+Man laesst 10 gute Teile zu, in der Annahme das 10 Leute sie benutzen.
+In Wirklichkeit haben aber nur 3 diese Teile, schon schreit jemand zu recht
+rum.
+
+
+Hmm oeh .. wer meinen Faden geklaut hat soll sich schleunigst melden ;)
+Achja, was ich eigentlich nur sagen wollte war:
+Man kann noch soviel probieren zu erzwingen, letzendlich wird von den aktiven
+bestimmt wie ausgewogen etwas ist.
+Also hackt net auf den Mags und der Balance rum, sondern packt euch mal selbst
+an die Nase.
+IHR seid es doch die das Spiel bestimmen, andere versuchen es etwas zu leiten,
+aber nicht mehr.
+
+Eine Loesung fuer diese ganze Misere wird es nie geben, ausser auf eine
+unmenschliche Art die keinen spass mehr bringt.
+
+Gruesse
+
+
+P.S.: Damals war alles besser! ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Patryn, 21. Mai 2001, 14:40:22):
+~#! rn=Catweazle rt=990428703 rg=balance
+~#! tid=990299717
+noch eine loesung: alle ruestungen und waffen nutzen sich ab...hatten wir
+das nicht schon mal? :)
+sehr gute ruestungenund waffen lassen sich nur schwerlich oder gar nicht
+reparieren, lautet dann das motto.
+
+------
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Terrorist, 21. Mai 2001, 14:42:56):
+~#! rn=Patryn rt=990448822 rg=balance
+~#! tid=990299717
+Danke das Du was geschrieben hast, sonst haette ich nen Selbstreply machen
+muessen ;)
+
+Diese Vorschlaege von wegen nur der der den NPC toetet erhaelt XYZ find ich
+etwas daneben ...
+Das ist doch ein Spiel in dem man zusammen spielt, und warum sollte ich XYZ
+nicht mal eine Freude machen duerfen?
+Wenn mir ein Zauberer Waffe Z gut besorgen kann, und ich ihm Umhang Y, ist es
+doch eher positiv?
+Auch wenn ich nicht mit ihm im Team laufen will, aus irgendeinem Grund.
+
+Hmm abnutzung ... urgs :)0
+
+Gruesse
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Amaryllis, 21. Mai 2001, 14:45:38):
+~#! rn=Terrorist rt=990448976 rg=balance
+~#! tid=990299717
+Die Teams wurden ja z.B. auch aus dem Grund eingefuehrt, da es ja immer mehr
+NPCs gibt, die Mitglieder einer bestimmten Gilde einfach nicht treffen und
+darum auch nie umlegen koennen.
+Ob diese mit dem Argument "bist eben in der falschen Gilde" oder "jede Gilde
+hat halt Gegner, gegen die sie nicht ankommt" leben koennen bzw. mit der
+Tatsache, den ach so erwaehnten EK nicht zu bekommen, weiss ich nicht :)
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Karic, 21. Mai 2001, 14:50:30):
+~#! rn=Corak rt=990302496 rg=balance
+~#! tid=990299717
+hab ich mal ne zeitlang gemacht..*zuck*
+
+wer brauch schon schwerter?
+
+karic
+p.s: der aufwand ist keine rechtfertigung fuer zu starke waffen/ruestungen..
+wenns zu stark ist..isses zu stark .
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Catweazle, 21. Mai 2001, 14:52:14):
+~#! rn=Patryn rt=990448822 rg=balance
+~#! tid=990299717
+Hm, ich glaube falls man tatsaechlich Abnutzungseffekte einfuehren wuerde (was
+wohl nie passieren wird :-), dann gaebe es auch in kuerzester Zeit die
+Moeglichkeit diese Abnutzungeseffekte - auf welche Art auch immer - wieder
+rueckgaengig zu machen.
+Damit muesstest Du dann doch wieder mit Maximalwerten rechnen. 
+Schoenes Beispiel uebrigens, denk kurz drueber nach, das ist angewandte
+Ruestungssspirale.
+
+YTC
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Patryn, 21. Mai 2001, 14:58:32):
+~#! rn=Catweazle rt=990449534 rg=balance
+~#! tid=990299717
+ich nachdenken? noe :)
+trotzdem, oder gerade deshalb, sehe ich das anders *g*
+ein schmied, der alles auf teufel komm raus repariert waere dann halt
+nicht erlaubt. und wenn man was tolles reparieren will, kann man sich
+durchaus einen teuren schmied vorstellen, der nur schwer erreichbar ist
+oder dir auch selbst ans leder will und obendrein unverschaemt viel fuer
+seine dienste verlangt.
+
+------
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Catweazle, 21. Mai 2001, 15:03:57):
+~#! rn=Patryn rt=990449912 rg=balance
+~#! tid=990299717
+Da nehme ich mit Leichtigkeit Bezug auf meine vorhergehenden Artikel:
+schwer erreichbar -> irrelevant
+unverschaemt teuer -> irrelevant
+dir auch selbst ans leder will -> ist mir nicht ganz klar (?)
+waere dann halt nicht erlaubt -> Ein Hoch auf die Balance :-)
+
+YTC
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Patryn, 21. Mai 2001, 15:10:32):
+~#! rn=Catweazle rt=990450237 rg=balance
+~#! tid=990299717
+das wort irrelevant ist irrelevant :)
+ich sehe sehr wohl immer den bezug zum aufwand und bin schon deshalb gegen
+fixe maxwerte. damit macht man sichs etwas zu einfach...
+
+------
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Pilgrim, 21. Mai 2001, 15:11:34):
+~#! rn=Catweazle rt=990449534 rg=balance
+~#! tid=990299717
+> Hm, ich glaube falls man tatsaechlich Abnutzungseffekte einfuehren wuerde
+(was
+> wohl nie passieren wird :-),
+Noe, denn Abnutzungseffekte sind bloed und schrenken nur den Spielspass
+ein ... da koennen wir auch Hunge und Durst einfuehren .. ;-)
+
+ABER: Die beste Waffe aus dem besten nichtmagischen Material habe
+die Staeke X ... jede Waffe mit Staerke Y>X muesste somit
+(teilweise) Magisch sein ... und magische Wafen zu fuehren/tragen
+ohne magische Faehigkeiten zu haben (MP) oder diese zu beeinflussen
+(max_MP verringern) halte ich auch fuer bloed ... wuerde
+man allein sowas einfuehren wuerde niemen mit 10 solcher Items
+rummlaufen, weil er nur noch 0 MPs hat ... z.B. Und wenn er
+sowieso schon wenig MPs hat (RAsse/Gilde), dann kann er eins solche
+Waffen halt nicht fuehren oder voll ausnutzen!
+
+Pilgrim
+(und wuerde es eine automatische Rechstschreibhilfe geben,
+koennte auch ein Legasteniker wie ich ohne Typos posten ;-))
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Terrorist, 21. Mai 2001, 15:15:39):
+~#! rn=Pilgrim rt=990450694 rg=balance
+~#! tid=990299717
+Uff das waere aber ein sehr tiefer Einschnitt ...
+Ich bezweifle das der den Spielspass erhoeht :)0
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Pilgrim, 21. Mai 2001, 15:16:08):
+~#! rn=Patryn rt=990450632 rg=balance
+~#! tid=990299717
+> ich sehe sehr wohl immer den bezug zum aufwand und bin schon deshalb gegen
+> fixe maxwerte. damit macht man sichs etwas zu einfach...
+Ja ... das kann man so machen ... nur muss man dann halt alle
+halbe Jahre ueberpruefen, ob der Aufwand (der mitunter durch die neu
+hinzugekommen Items/Gilde/Faehigkeiten) immer noch das Ergebnis (die
+Waffe) rechtfertigen ... i.d.R. wird man dann anpassen, sprich
+abwerten (Waffe) oder Aufwerten (NPC) muessen ... das ist uebrigens fuer den
+Magier/die Balance einfacher ... ;-) nur fuer den Spieler und fuer magier, die
+viel und ausgewogen programmieren ist das halt auch viel unschoener ... 
+
+Pilgrim
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Pilgrim, 21. Mai 2001, 15:17:12):
+~#! rn=Terrorist rt=990450939 rg=balance
+~#! tid=990299717
+> Uff das waere aber ein sehr tiefer Einschnitt ...
+> Ich bezweifle das der den Spielspass erhoeht :)0
+Aeh, was?
+
+Pilgrim
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Wurzel, 21. Mai 2001, 15:17:22):
+~#! rn=Pilgrim rt=990450694 rg=balance
+~#! tid=990299717
+jawohl. hunger und durst. etwas worauf wir alle schon lange warten...
+wenn ich mich (frueher, als ich sowas noch gemacht habe :) in ein neues
+mud eingeloggt habe, habe ich erstmal ne halbe stunde  gewartet,
+wenn dann die message "Du hast Hunger" oder aehnliches kam, folgte ein
+schnelles "ende". und tschuess.
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Anacrion, 21. Mai 2001, 15:18:59):
+~#! rn=Wurzel rt=990451042 rg=balance
+~#! tid=990299717
+Wir reden von Ausruestung.
+
+
+also wenn Ausruestungsverschleiss den Spielspass verrringert, mussten die
+Zauberer durchgaengig heulen in der Ecke kauern.
+
+Tun sie nciht. Nicht durchgaengig.
+
+Anac* heult.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Terrorist, 21. Mai 2001, 15:19:05):
+~#! rn=Wurzel rt=990451042 rg=balance
+~#! tid=990299717
+Und was ist mit Jahreszeiten?
+Ahh vor allem erstmal Tag und Nacht :)
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Terrorist, 21. Mai 2001, 15:19:53):
+~#! rn=Anacrion rt=990451139 rg=balance
+~#! tid=990299717
+Zauberer heulen nicht durchgaengig?
+Seit wann nicht mehr?
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Rumata, 21. Mai 2001, 15:20:19):
+~#! rn=Terrorist rt=990451145 rg=balance
+~#! tid=990299717
+Ich einnere mich an ein Mud in man Fackeln nur in geschlossen Beuteln
+transportieren konnte, weil es ja auch nachts regenet...
+Rum
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Catweazle, 21. Mai 2001, 15:20:27):
+~#! rn=Pilgrim rt=990450968 rg=balance
+~#! tid=990299717
+Sehr schoen.
+Du hast ganz hervorragend die Notwendigkeit eine Balance erlaeutert, ich
+haetts nicht besser beschreiben koennen. 
+ YTC :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Gloinson, 21. Mai 2001, 18:25:15):
+~#! rn=Catweazle rt=990449534 rg=balance
+~#! tid=990299717
+Sicherlich wird es diese Moeglichkeiten geben. Nur dass Du, wenn das gut
+gestaltet ist (z.B. mit Pause) Du nicht wegen jedes Punktes sofort losrennen
+wirst/willst. Und damit sinkt die getragene Durchschnittsruestung doch wieder.
+Zumal bessere Ruestungen "teurer" (wie auch immer, ob man nun Stahlbleche aus
+der SSP abholen muss, Knochen im Neandertal sammelt oder Wolle suchen geht) zu
+reparieren sein sollten und ergo nicht jeder Spieler mit dauerhafter
+Maxruestung herumlaufen wird.
+
+Gloin(son)
+
+PS: Mit Hunger und Durst hat das ueberhaupt nix am Hut.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Ark, 21. Mai 2001, 18:42:12):
+~#! rn=Terrorist rt=990448976 rg=balance
+~#! tid=990299717
+Uebrigens, diese Einschraenkung wurde in einem Item von mir von der Balance
+vorgeschlagen und auch von mir umgesetzt, ist also durchaus nicht so weit
+hergeholt. Ich habe es auch halbwegs vernuenftig begruendet *finde ich :-)*
+Das Item wurde uebrigens noch nie benutzt, aus Angst glaube ich :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Wurzel, 21. Mai 2001, 18:44:51):
+~#! rn=Ark rt=990463332 rg=balance
+~#! tid=990299717
+sind eh lauter weicheier hier :) manchmal frage ich mich, wieviel unbenutzte
+schaetze noch im verborgenen liegen...
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Ark, 21. Mai 2001, 18:45:01):
+~#! rn=Pilgrim rt=990450694 rg=balance
+~#! tid=990299717
+Was ist eigentlich schon magisch? Bei AD&D sind es die schoenen +1 Waffen, die
+man ab Stufe 5 nicht mehr haben mag :-) Hier isses etwas schwieriger. Ist
+maximale WC schon eine magische Waffe? Oder erst Zusatzfaehigkeiten?
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Wargon, 22. Mai 2001, 19:44:22):
+~#! rn=Wurzel rt=990451042 rg=balance
+~#! tid=990299717
+Man koennte natuerlich den Spiess entsprechend umdrehen und die Kneipen
+abschaffen; fuer ne Uebergangszeit heisst es dann
+> bestelle <was zu essen>
+Aber Du hast doch gar keinen Hunger.
+
+:)
+  Wargon
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Mupfel, 23. Mai 2001, 00:48:24):
+~#! rn=Wurzel rt=990451042 rg=balance
+~#! tid=990299717
+Auf den Artikel hab ich gewartet. Danke, QWurzel, danke, danke...
+
+-mupfel-
+PS: alternativ haettest Du auch Deinen Klassiker "einatmen-ausatmen" posten
+koennen, aber vielleicht das naechste mal.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ein paar Gedanken zum Thema abwerten und moegliche Alternativen (Pilgrim, 23. Mai 2001, 13:07:10):
+~#! rn=Mupfel rt=990571704 rg=balance
+~#! tid=990299717
+Also ... ich hab DIE Loesung gegen ueberalterung gefunden ...
+Alle Charakter muessen altern ... alle werde geboren, koennen als Baby
+nur durch die Gegend getragen werden, als Kinder kaum ne passende
+Ruesustung finden (ok, von den Zwergen vielleich), dann hat man
+etwas Zeit ... und mit zunehmendem alter wird der Char halt wieder
+schwecher und dann stirbt man (->und weg isser ... ) ...
+So werden auch Namen wieder frei, oder man fuert sowas wie
+Soundos der XIII. ein ...
+
+/dream(off)
+
+Pilgrim
+
+-----------------------------------------------------------------------------
+
+
+
+Dieses Mud stirbt! (Tsunami, 30. Mai 2001, 02:42:34):
+Leute, Leute, Leute!
+
+ich habe mich mal durch den Wust von Artikeln gewaelzt. Was bis jetzt nicht
+zur Sprache gekommen ist, von Magierseite her aber den meisten Frust
+verursacht, ist die Tatsache dass die Balance sehr, sehr, sehr traege
+arbeitet.
+
+Balance hin oder her, wenn sie die Antraege nicht innert nuetzlicher Frist
+abarbeitet erzeugt das Unmut. Aus meiner Erfahrung (sowie was mir andere
+Polar-
+magier berichtet haben) dauert so eine durchschnittliche Genehmigung (oder 
+Ablehnung) 3-6 Monate.
+
+Das ist schlicht unzumutbar!!
+
+Das neue Gebiet ist nun also fix und fertig, x Testspieler durchgejagt, 
+Forscherpunkte eingetragen (bei Rikus geht das im Schnitt 1-2 Tage nach
+Antrag)
+allfaellige zusaetzliche XP fuer superstarke NPCs werden auch flugs
+eingetragen
+aber dann muss man auf die Balance warten und warten und warten...
+
+Und nein, es ist praktisch unmoeglich, ein Gebiet zu planen, die (noch
+unprogramierten) Objekte der Balance vorzulegen und dann mit der Gebiets-
+programmierung zu beginnen. Viele neue Ideen entstehen erst waehrend man
+am entwickeln ist, oder wenn das Gebiet fertig ist.
+
+Ich weiss, jeder hier hat auch noch ein RL aber ich finde, nein ich verlange,
+dass jemand, der fuer die Balance arbeitet, dies auch gewissenhaft und im 
+Rahmen der Vorgaben erledigt. Sprich, mehr als eine Woche sollte die Balance
+nicht benoetigen, um dem betreffenden Magier eine Entscheidung zu schicken.
+Falls ein Objekt besonders diskussionsintensiv ist (ich sag nur 2-hand Messer)
+sollte wenigstens nach einer Woche eine Mail verschickt werden mit dem
+Hinweis,
+dass dieses Objekt nicht sofort beurteilt werden kann. Dann weiss man 
+wenigstens, woran man ist.
+
+Aber so wie die Balance zur Zeit gehandhabt wird, ist in meinen Augen eine
+Frechheit.
+
+Viele potentielle Magier ueberlegen es sich nun zweimal, ob sie den ganzen
+Aerger auf sich nehmen wollen und in diesem Mud progammieren sollen.
+Und ich spreche hier aus Erfahrung.
+
+Summa sumarum: dieses Mud stirbt langsam, da vielversprechender Nachwuchs
+ausbleibt. Er wird wegen der langsam arbeitenden Balance und den ganzen \
+Regelmentierungen schlicht vergrault.
+
+Ich bin noch nicht sehr lange Magier hier, aber vor zwei Jahren war alles noch
+viel leichter und spassiger. Es gab ein paar Richtlinien, der gesunde 
+Menschenverstand war die Balance (das waren noch Zeiten!) und wenn was
+angeschlossen wurde, dass "way over" war, wurde es halt redimensioniert.
+
+Ich fuer meinen Teil bin total frustriert.
+
+Unendlich langes Warten auf Balance Entscheide (mit denen ich eh nicht
+einverstanden bin) und jede Woche neue Gremien haben mir die Lust, noch etwas
+neues zu proggen, gruendlich verdorben.
+
+Ich frag mich echt, was das ganze hier noch soll :((
+
+Tsunami, ziemlich frustriert.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Dieses Mud stirbt! (Kieselstein, 30. Mai 2001, 02:47:02):
+~#! rn=Tsunami rt=991183354 rg=balance
+~#! tid=991183354
+Haette es besser nicht sagen koennen ...
+ 
+Kieselstein
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Dieses Mud stirbt! (Mesirii, 30. Mai 2001, 03:14:58):
+~#! rn=Tsunami rt=991183354 rg=balance
+~#! tid=991183354
+Das Problem der extrem langen Bearbeitungszeit scheint generell
+vorzuliegen, ich habe nicht erst von Tsunami davon gehoert, sondern
+auch schon von vielen anderen Magiern. Vielleicht waere es ja sinnvoll
+in dieser Hinsicht etwas mehr Transparenz in die Arbeit der Balance zu
+bringen (wenigstens in Hinsicht auf die Magier, die wissen moechten,
+ob und wann ihre Sachen bearbeitet werden und wie lange dies dauert
+bzw. wie so eine Entscheidungsfindung ablaeuft).
+
+Ausgetestet sollten die Sachen doch eigentlich schnell sein, mit nem
+entsprechenden Testie die Objekte nutzen den eigenen gesunden
+Menschenverstand dazu und die umfassende Mudkenntnis, die den
+Balancemitglieder ja zu eigen sein sollte. Dann diskutiert man kurz
+darueber (bzw. der Tester sagt seine Meinung und der Rest bildet sich
+daraus eine) und dann sollte eine Entscheidung schon fallen, diese
+kann ja auch unter Vorbehalt ausgesprochen werden.
+
+Generell ist halt die Frage zu beantworten, woran es liegt, dass die
+Entscheidungen solange dauern. Ist die Balance ueberlastet ? Ihr Zweck
+sollte es doch sein, Sachen, die ueber den normalen Regeln liegen, zu
+bewerten. Sind das jetzt schon so viele? Oder ist bei den
+Balancemitgliedern einfach keine Zeit vorhanden, dann sollte
+vielleicht doch wieder mehr auf das Urteil der RMs
+(RM!=anschliessender Magier) vertraut werden.
+
+Ich bin jedenfalls ziemlich traurig, dass zur Zeit soviele Leute dem
+MG gefrustet den Ruecken kehren, was aber nicht verwundern
+sollte. Eigentlich sollte das hier ein Spiel sein, dass uns allen auf
+die eine oder andere Weise Spass macht (den definiert zwar eh jeder
+anders...). D.h. man sollte Dinge zum Teil nicht so eng sehen.
+
+Mesi
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Dieses Mud stirbt! (Foobar, 30. Mai 2001, 05:11:12):
+~#! rn=Mesirii rt=991185298 rg=balance
+~#! tid=991183354
+Mir persoenlich ist es (noch) scheissegal, wie lange die Balance braucht, um
+ein Objekt zu bearbeiten.
+
+Ich halte es nur fuer aeusserst schade, wenn faehige Magier mit dem Gedanken
+spielen, dem MG den Ruecken zu kehren, weil es "irgendwo" hakt.
+
+
+Der Balance muss ich ankreiden (meiner Meinung nach), nach den von Tsumami
+beschriebenen Umsstaenden wirklich etwas langsam zu sein. Tsunammi allerdings
+muss sich die Frage gefallen lassen, warum er nicht schon fruher mal
+nachgehakt hat (was er, wie ich insgeheim glaube getan hat). Alles in allem
+ein IMHO klassisches Kommunikationsproblem, von dem es hier viel zu viele
+gibt.
+
+
+Aber wie soll man das beheben? Tsunami bitte ich, weiterhin einige der besten
+Gebiete des MG zu programmieren, und ich kann nur hoffen, dass die Balance in
+Zukunft neue Gebiet bzw. was auch immer ein wenig schneller bearbeitet.
+
+Mir ist klar, dass die Balance hier recht schlecht wegkommt, ich will auch
+keineswegs deren Arbeit ins Unreine ziehen, aber das "Aber" was den bisherigen
+Artikeln innewohtn muss sie sich wohl oder uebel gefallen lassen.
+
+Gruss,
+
+     Foobar
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Dieses Mud stirbt! (Padreic, 30. Mai 2001, 09:19:30):
+~#! rn=Foobar rt=991192272 rg=balance
+~#! tid=991183354
+Ich denke die Ursache dieses Problems, liegt bereits in der Konzeption. Im
+Prinzip wird bei jedem Antrag erstmal solange gewartet bis jeder der sieben
+Spieler zumindest die Gelegenheit hatte, sich dazu zu aeussern. (Man
+korrigiere mich wenn ich was falsches sage). Die Wahrscheinlichkeit das von
+sieben Leuten gerade einer weg ist, keine Zeit oder schlichtweg im mom. keinen
+Bock auf Balance hat, ist dabei natuerlich ziemlich gross.
+Jeder hat mal einen Haenger, nur kann man einer Einzelperson da wesentlich
+leichter auf die Fuesse treten, weil dort klar ist DU bist es schuld und nu
+mach doch mal endlich. Theorethisch kann das Balanceteam aber auch
+Entscheidungen faellen ohne das sich jeder geaeussert hat, was jedem einzelnen
+sugeriert: Es laeuft ja auch ohne Dich, Du musst ja nicht unbedingt.
+Eigentlich ist dies ein Phaenomen das so in jeder groesseren Gruppierung die
+ich kenne mit der Zeit auftritt, sobald der Anfangselan der Leute verschwunden
+ist. Die einzige Loesung die ich dafuer kenne und die schon seit langem von
+einigen Magiern gefordert wird, ist eine Regelung ala "Wenn sich zwei Wochen
+lang keiner der Balance mehr zum Thema gemeldet hat, gilt der Antrag als
+genehmigt.". Extrem lange und aufwendige Antraege sollte man da dann ruhig
+rausnehmen, in diesem Fall koennte aber auch innerhalb der ersten zwei Wochen
+eine Antwort kommen ala, das dauert noch X Monate.
+Leider ist dies nur ein Traum und wird wohl so nicht kommen...
+
+Pad*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Dieses Mud stirbt! (Solmyr, 30. Mai 2001, 10:13:54):
+~#! rn=Kieselstein rt=991183622 rg=balance
+~#! tid=991183354
+Naja, anstatt das Mud stirbt, waere 'das Mud waechst' zutreffender :)
+
+Sol*, aber sonst gleicher Meinung
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Dieses Mud stirbt! (Wurzel, 30. Mai 2001, 11:44:20):
+~#! rn=Solmyr rt=991210434 rg=balance
+~#! tid=991183354
+schon immer hat es leute gegeben, die mehr oder weniger frustriert aufgehoert
+haben. es ist um jeden einzelnen schade, wie ich finde. aber das ist nichts
+neues, immer wieder gibt es auch wellen von aufhoerern.
+das allein der balance zuschieben zu wollen ist sicher falsch.
+natuerlich sind zeiten von mehreren monaten nicht akzeptabel. auf
+der party habe ich mit etlichen leuten gesprochen, die davon ziemlich
+frustriert waren.
+wer mich kennt, weiss dass ich "um die balance herum" entwickle, also sachen,
+die nicht genehmigungspflichtig sind. sei es, weil sie nicht besonders toll
+sind, aber vor allem, weil sie nicht ueberall einsetzbar sind, sondern nur
+in meinen gebieten. warum erzaehl ich das? nun, ebenfalls auf der letzten
+party kam die idee auf, sowas etwas zu verallgemeinern, d.h. manche magier
+tauschen sich da aus und erzeugen objekte, die wechselseitig einsetzbar
+sind. an der einen oder anderen stelle gibt es das auch schon. mit anderen
+worten: eine alternativ-mudlib ist dabei zu entstehen.
+moment... ist das nicht eigentlich aufgabe der allgemeinen mudlib? hier
+entstehen inselloesungen, nur weil die balance schlaeft?
+ich moechte mich nicht der meinung anschliessen, dass dieses mud stirbt.
+ich habe schon muds sterben gesehen, das sieht etwas anders aus (noch).
+aber sinnvoll ist das, was wir tun, schon lange nicht mehr. man macht eben
+das, was geht. und mit der balance geht eben fast nichts.
+auch wenn ich mich wiederhole: balance ist sinnvoll und notwendig, vom
+prinzip her. die art, wie sie momentan im morgengrauen funktioniert, ist
+aber nicht in ordnung. da sollten wir was dran tun. das mindeste ist, die
+bearbeitungszeiten auf eine woche zu verringern, im komplexen fall auch mal
+zwei oder drei wochen. ich nehem nicht fuer mich in anspruch, das mg gut
+zu kennen, dafuer spiele ich zu selten. aber die leute, die sich angeblich
+ach so gut auskennen, muessten doch in der lage sein mit wenigen blicken zu
+erkennen, ob etwas passt oder nicht. die qualitaet der entscheidungen laesst
+sich ja unter anderem daran erkennen, wie oft etwas im nachhinein noch
+abgewertet wird/werden muss. und das nach sechs monaten der pruefung?
+ich denke, im zweifelsfall sollte eher einer schnellen entscheidung der
+vorzug gegeben werden, nachbessern muss man ja oft genug sowieso.
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Dieses Mud stirbt! (Amaryllis, 30. Mai 2001, 12:13:08):
+~#! rn=Wurzel rt=991215860 rg=balance
+~#! tid=991183354
+Das Problem der Kommunikation gibt es uebrigens nicht nur mit der Balance,
+sondern auch allgemein, sogar unter Magiern. :)
+Nundenn, auch ich habe aus diesem Grund bisher nur Objekte programmiert, die
+so lasch sind, dass sie der Balance nicht beduerfen - der andere Grund ist
+aber sicherlich, dass es mittlerweile eigentlich schon quasi _alles_ irgendwo
+gibt - da fallen einem wenig neue Sachen ein, die fuer Spieler interessant
+sein koennten, weil gut, aber auf der anderen Seite ueberhaupt ne Chance
+haetten, durch die Balance zu kommen.
+
+Das einzige Objekt, was ich gerne programmiert haette, musste uebrigens nicht
+bei der Balance, sondern bei einem anderen Gremium beantragt werden - und da
+hab ich bis heute noch keine offizielle Antwort *g* (ist jetzt auch schon nen
+Jaehrchen her oder so).
+
+Insofern kann ich das gut verstehen, wenn Leute aufgrund dieser Tatsachen
+frustriert irgendwann das Handtuch schmeissen oder nur noch billigen Krempel
+programmieren, um das ganze zu umschiffen.
+
+Gruss,
+Ama*
+
+
+PS: Das sollte jetzt keine Anschuldigung an irgendwelche Gruppen sein, da ich
+selbst nicht weiss, wie man das besser loesen koennte. Das Problem ist eben
+schon uralt.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Dieses Mud stirbt! (Karis, 30. Mai 2001, 12:27:28):
+~#! rn=Amaryllis rt=991217588 rg=balance
+~#! tid=991183354
+Also, jetzt muss ich mich dann doch mal fragen, wozu die
+Balance nun eigenlich gut ist. Achja.. ich beziehe mich da
+auf die Balance, die fuer Waffen und Ruesten zustaendig ist.
+Ich habe in mehr als einem Gespraech mit den zustaendigen
+Leuten eigentlich immer nur einen Tenor gehoert:
+'die werte fuer xyz sind einfach moerderisch, die muessen gesenkt werden'
+Mir gehts net darum, dass was abgewertet wird... egal.
+Mir gehts einzig und allein darum, wie festgestellt wird, wie
+ein x-beliebiges Objekt zu bewerten ist.
+Ich dachte eigentlich immer, die Balance-Leute laufen mit den Sachen
+da draussen rum und probieren die aus. Kann aber eigentlich
+nicht sein, weil die Argumentation ja immer lautete,
+'die Werte' (welche auch immer das seien) sind zu stark.
+Nachdem man nun ueber diese Werte ja alles ausrechnen kann,
+(wurde mir von viiiielen Leuten so erklaert), frage ich mich, warum dann
+7 (is das so richtig?) Leute das unabhaengig voneinnader (?)
+nachrechnen muessen??? ICh dachte, dass es fuer sowas
+Taschenrechner gaebe....
+Also muesste es doch ein leichtes sein, irgendwelche Maximalwerte
+festzulegen. Und fuer die Leute, die zu faul sind, die
+komplette Kombinatorik per Hand durchzurechnen, kann
+man ja auch durchaus ein kleines Prograemmchen bauen.
+Und dann ist da noch das Argument: jaaaa, wir wissen ja noch nicht,
+wie das Teil a mit den Teilen b,c und d zusammen funktioniert!
+Auch hier verweise ich wieder auf 'die Werte'. Kann man alles
+berechnen. Und die Taktiken von irgendwelchen Leuten kann man
+auch so erfassen. Mit Maximalwerten einfach alles erschlagen.
+UNd schwupps, schon kann jeder Magier selber bestimmen,
+ob sein Teil nun zu stark ist oder nicht.
+Aber bestimmt hab ich wieder irgendwas nicht richtig verstanden.
+
+Karis
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Dieses Mud stirbt! (Wurzel, 30. Mai 2001, 12:38:29):
+~#! rn=Karis rt=991218448 rg=balance
+~#! tid=991183354
+stimmt. da hast du was nicht richtig verstanden.
+aber in die abgruende der psychologie der menschlichen eitelkeiten moechte
+ich hier auch nicht einsteigen... das machen wir mal in ruhe bei einem
+schoenen kuehlen bier :)
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Dieses Mud stirbt! (Humni, 30. Mai 2001, 13:24:56):
+~#! rn=Wurzel rt=991219109 rg=balance
+~#! tid=991183354
+Nur kurz zur Erlaeuterung: 
+Es gibt ,Maximalwerte' fuer Standard-Ruestungen und Waffen. Aber die kann ich
+nicht einfach so einsetzen, sondern dafuer muss ich ab nem gewissen Wert (der
+auch festgelegt ist) die Balance fragen.
+Vielleicht koennte man dafuer ne Loesung finden, aber das geht nicht so
+einfach....mir faellt gerade jedenfalls keine ein.
+Aber: Was ist, wenn mir nicht einfaellt ,Ha, die Schadensart mit dem Waffentyp
+und der Staerke gibts noch nicht!' sondern mir was wirklich interessantes
+einfaellt, ein Amulett, das vor Blindheit schuetzt, ein Ring, der Gift
+abwendet, ein Teleporterstab, was weiss ich...
+Das kann die Balance dann nur genehmigen oder eben nicht, das hat keinen
+,Wert', den man mit nem Taschenrechner ueberpruefen kann.
+
+Und ja, ich hab bisher auch nur Kram geproggt, der recht simpel war, eben weil
+ich keinen Bock auf diese Bearbeitungszeiten hatte. Ob sie stimmen, kann ich
+nicht bestaetigen...
+
+CU Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Dieses Mud stirbt! (Ark, 30. Mai 2001, 13:35:45):
+~#! rn=Tsunami rt=991183354 rg=balance
+~#! tid=991183354
+Vielleicht liegt es einfach nur an der Menge der Items?! Warum muss jeder so
+viele Items schreiben, die oberhal der Grenze liegen? Damit wird diese wieder
+ad absurdum gefuehrt. Ich werde zumindest versuchen, mehr "normale" Items zu
+schreiben. Man moege mich bei Bedarf zitieren :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Dieses Mud stirbt! (Morgoth, 30. Mai 2001, 13:36:31):
+~#! rn=Ark rt=991222545 rg=balance
+~#! tid=991183354
+Wie gut, dass Du das Wort "versuchen" eingebaut hast ;-))
+
+M*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Dieses Mud stirbt! (Ark, 30. Mai 2001, 13:41:23):
+~#! rn=Morgoth rt=991222591 rg=balance
+~#! tid=991183354
+Deshalb meinen Artikel bitte aufheben :)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Dieses Mud stirbt! (Nachtwind, 30. Mai 2001, 13:45:59):
+~#! rn=Karis rt=991218448 rg=balance
+~#! tid=991183354
+@karis:
+Die Programmierung im MG ist im krassen Gegensatz zu anderen muds
+mehr oder weniger vollkommen "frei". Jeder Magier kann eigene
+Objekte (Waffen, Ruestungen, NPCs) programmieren, die jede Funktion
+der Mudlib ueberschreiben und sein Objekt voellig ungewoehnliche
+und unberechenbare Dinge tun lassen. Jeder Magier kann eine Waffe
+programmieren, die nur an ungraden Tagen gut zuschlaegt, zusaetzlich
+bei allen NPCs mit einem "x" in Namen Feuerschaden macht, nur in den
+Haenden von elfischen Katzenkriegern richtig gut reinhaut und bei
+Zwergen zweihaendig ist. Das Ganze laesst sich dann noch vielleicht
+mit anderen Objekten im mud kombinieren und erreicht dann noch ganz
+andere Regionen. Von der Kombination mit Gildenfaehigkeiten und 
+Sonderboni fuer Gilden ganz zu schweigen.
+Wenn Du das fest und objektiv und allgemeingueltig nur mit Hilfe eines
+Taschenrechners in kuerzester Zeit einschaetzen kannst, bist Du
+sofort alleiniger Verantwortlicher fuer Objektbalance. Und
+Gildenbalance auch, was das betrifft.
+
+Nachtwind.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Dieses Mud stirbt! (Karis, 30. Mai 2001, 14:01:42):
+~#! rn=Nachtwind rt=991223159 rg=balance
+~#! tid=991183354
+Gerade Du hast mir erklaert, dass die Maxwerte zum abschaetzen
+der Guete einer Waffe dienen, Nachtwind. Und es sollte
+ja moeglich sein, diese Maxwerte aus dem Code herauszufinden. Weil da
+irgendwo ja stehen muss: if (Tag == ungerade) then Schaden *= 2; 
+Tja, und da steht er dann, Dein MaxSchaden. 
+Sicherlich ist es schwierig, die komplette Kombinatorik abzutesten.
+Insbesondere, wenns dann noch um
+Sonder/Gilden/xyz-Boni/Zuschlaege/Abzuege/wasweissich
+geht. Aber willst Du mir ernsthaft erklaeren, dass ausgerechnet diese Aufgabe
+von 7 Leuten, die hier (behaupte ich mal) zum Spass spielen, schneller und
+gewissenhafter erledigt werden kann als von einer Maschine?
+Nichts gegen Balance - Tools wie Humnis Teleporterstab lassen sich
+nicht mit simplen Werten erfassen, hier ist eine Balance wirklich
+gefragt. Und, nur um das nochmal klar und deutlich zu sagen,
+damit sich hier niemand vo mir auf den nichtgetragenen Schlips
+getreten fuehlt: fuer viele Sachen ist die Balance notwendig. Aber
+nicht fuer Sachen, die sich berechnen lassen. Und je komplexer die Berechnung,
+desto 
+sinnvoller waere der Maschineneinsatz.
+
+Karis
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Dieses Mud stirbt! (Boing, 30. Mai 2001, 14:03:33):
+~#! rn=Ark rt=991222545 rg=balance
+~#! tid=991183354
+Du bringst es auf den Punkt. Tsunami hat fuer seine Gladiatorenschule
+etwa 60 (!) Items auf einen Schlag beantragt. Davon wurden 55 in angemessener
+Zeit bearbeitet, der Rest waren Faelle, die entweder sehr schwer zu
+beurteilen waren oder komplexe Grundsatzdiskussionen ausloesten (die
+zum Teil immer noch laufen). Natuerlich kann das keine Entschuldigung
+fuer die wirklich extrem lange Bearbeitungsdauer gerade beim 2-Hand-Messer
+sein, allerdings ist es bestimmt nicht im Sinne der Magier, wenn wir
+in Zukunft einfach ablehnen und uns keine Gedanken mehr darueber machen,
+wie man ein Item irgendwie doch noch 'genehmigbar' bekommt. Hier jetzt
+auf das Balance-Team einzuschlagen und quasi zu behaupten wir wuerden
+nur schlafen finde ich im hoechsten Masse unangebracht.
+Ausserdem: Was soll dieser Artikel (der ausloesende natuerlich, nicht der
+von Ark) ueberhaupt in einer Spielerrubrik? Fuer mich sieht das absolut
+nach Stimmungsmache und Anti-Balance-Hetze aus. Von einem RM sollte man
+da mehr erwarten koennen.
+  Boing
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Dieses Mud stirbt! (Nonne, 30. Mai 2001, 16:16:59):
+~#! rn=Boing rt=991224213 rg=balance
+~#! tid=991183354
+Hallo Leuts,
+
+das Reply auf Boing ist Zufall...
+
+Ich habe auch schon ein paar Sachen bei der Balance eingereicht und muss
+sagen, dass ich eigentlich nicht klagen kann. Wenn man
+Koorperationsbereitschagt zeigt und auch ein wenig Einsicht in die
+Notwendigkeit hat, kann man mit den Leuten aus der Balance eigentlich gut
+diskutieren und auch zu einer Loesung kommen.
+
+Eine andere Sache ist das mit der Zeit: Natuerlich dauert das alles, aber wenn
+man die Anzahl der Items sieht, die bearbeitet werden muessen, kann man das
+auch nachvollziehen. Den einzelnen aergert es natuerlich, dass er/sie so lange
+warten muss, aber man muss halt sehen, dass es auch andere Magier gibt, die
+etwas beantragen.
+
+Vielleicht kann man sich auch vorher schon mal ueberlegen, was ueberhaupt eine
+Chance hat und nicht schon mal 20% auf die Werte schlagen, in der Hoffnung,
+dass das Tool nach der Balance immer noch exorbitant gut ist. Dann fangen
+naemlich die langen Diskussionen an.
+
+Vielleicht waere auch eine Moeglichkeit, die Balance zu vergroessen
+(vielleicht 10-12 Leute) von denen dann 5 Leute, aber mindesten 2 Magier und 2
+Spieler zustimmen muessen? Dann haetten die Leute die Moeglichkeit, die Arbeit
+zu teilen, oder es kann mal einer eine Auszeit nehmen.
+
+Irgendwem den schwarzen Peter zuzuschieben, bringt uns einer Loesung
+jedenfalls kein Stueck naeher. Die Balance braucht Kooperationsbereichtschaft
+von Seiten der Magier und keine Sprueche wie: Wenn ich da 10% rausnehmen,
+passt das alles nicht mehr zusammen, ich pack meinen Krempel und schliess es
+im Mud XYZ an. Genauso brauchen die Magier moeglichst schnell Feedback.
+Einerseits wegen der Motivation, andererseits moeglich schnell ueber
+Alternativen nachzudenken.
+
+Und zum Schluss: Geht mal ein bisschen netter mit einander um, das macht
+vieles einfacher (c:
+
+Nonne.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Dieses Mud stirbt! (Hight, 30. Mai 2001, 17:45:13):
+~#! rn=Karis rt=991218448 rg=balance
+~#! tid=991183354
+Mahlzeit ...
+
+Ich versuche mich kurz zu fassen und das ganze moeglichst ohne grossen bezug
+auf den thread zu machen, da ich sont dem sinn des artkiels wiederspreche.
+
+korrigiert mich wenn ich flasch liege aber ist das nicht eine sache die NUR
+die balance mitglieder und die magier was angeht ?
+
+bin ebenfalls der meinung das die spieler (zumindest zu nem grossen teil)
+absolut kein einblick in die arbeit der balance haben. karis ich will ja nich
+meckern aber so wie sich das liest hast du kein plan von der materie und
+beziehst dich in deinem artikel auf das geheule von anderen. 
+
+kurz und knapp: grimborn tu was du so gerne tust und verschieb das alles nach
+rubrik balance (sowas in der art wirds ja hoffentlich geben)
+
+gruss Hight
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Dieses Mud stirbt! (Hight, 30. Mai 2001, 17:48:15):
+~#! rn=Hight rt=991237513 rg=balance
+~#! tid=991183354
+oki oki ich gebs zu ich bin ploede is ja rubrik balance ... 
+
+macht die rubrik fuer spieler unzugaenglich und was das balanceteam zu
+verkuenden hat nach bekantmachungen schrieben 
+
+hight
+
+p.s.: das ist durchaus ernstgemeint
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Dieses Mud stirbt! (Grimmborn, 30. Mai 2001, 17:50:02):
+~#! rn=Hight rt=991237695 rg=balance
+~#! tid=991183354
+Hmm, mich hats ja gejuckt den thread nach "gejammer" zu verschieben, aber dann
+waeren hier wahrscheinlich Traenen geflossen, und mein Rechner ist doch nicht
+wasserdicht...
+
+Grimmborn der Atheist
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Dieses Mud stirbt! (Anatol, 30. Mai 2001, 20:37:04):
+~#! rn=Tsunami rt=991183354 rg=balance
+~#! tid=991183354
+
+Hallo Tsunami,
+also zunaechst sei Dir gesagt: Es tut mir leid, sollte das Team der
+Objektbalance Dir nicht schnell genug auf Antraege reagieren. Und ich
+gestehe ein, dass es in manchen Faellen vom beantragenden Magier 
+tatsaechlich ein ungesundes Mass an Geduld und Nervenstahl erfordert.
+Ich denke, ich spreche da fuer alle meine Kollegen.
+
+Was eben das 'zweihaendige Messer' angeht, ueber das Du Dich aktuell
+gerade aufzuregen scheinst... mit Verlaub, ich fuehle mich von Dir
+ziemlich verkohlt. Denn kurz nach Anschluss der Gladiatorenschule - 
+Du erinnerst Dich an den Antragswust, mit dem Du uns gut eingedeckt
+hattest, ja? - fiel das Messer natuerlich relativ schnell auf, denn
+es soll ja keine zweihaendigen Messer geben, nicht wahr... Und mit
+Verlaub, Tsunami, Du wurdest darauf angesprochen, man hat Dir gleich
+gesagt, dass das Messer so nicht bleiben wird und dass eine grund-
+saetzliche Frage innerhalb der Balance (die Problemstellung erging
+zwischenzeitlich an die Erzmagier (huhu ihr ;)) und zurueck) geklaert
+werden muesse, bevor halbwegs endgueltig etwas zur Zweihaendigkeit
+des Messers gesagt werden koenne. Man verstaendigte sich mit Dir,
+nicht sofort unter die Genehmigungsgrenze zu gehen und DANN, wenn der
+Rattenschwanz geklaert ist, auf den neuen Wert zu setzen, sondern das
+Messer vorerst zu belassen und es als "neu beantragt" zu verzeichnen.
+
+Drei Dinge fallen mir dazu ein:
+
+a) Ich weiss das da oben sehr genau. Denn Dein Gespraechspartner war ICH.
+
+b) Es war ein Fehler, das Messer so zu lassen, auch wenn niemand hat
+   absehen koennen, dass diese Einhand/Zweihand-Geschichte so ewig 
+   lange dauert. In Zukunft werde zumindest ich versuchen, regelgemaess
+   den Pruegel auszupacken und umstrittene Objekte fuer die notwendige
+   Zeit aus dem Spiel zu nehmen.
+
+c) Nimm das naechste mal wirklich "mail balance". Dann schonst Du Nerven.
+   Deine, die des Balance-Team und die der "Unbeteiligten".
+
+Anatol
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Dieses Mud stirbt! (Tsunami, 30. Mai 2001, 23:51:53):
+~#! rn=Boing rt=991224213 rg=balance
+~#! tid=991183354
+von Boing:
+
+>Fuer mich sieht das absolut nach Stimmungsmache und Anti-Balance-Hetze aus.
+>Von einem RM sollte man da mehr erwarten koennen.
+
+
+Ich habe mich genauso verhalten, wie es sich fuer einen rechtschaffenen RM 
+gehoert. Und ich muss sagen, ich haette mehr  erwartet von den "Betreibern"
+dieses Muds (also Boing).
+
+Mein Gedankengang:
+
+- dieses Mud liegt mir sehr am Herzen!
+
+- Kein einziger aktiver Polarmitarbeiter hat zur Zeit Lust etwas Neues fuer
+  dieses Mud zu erstellen (incl. der RM).
+
+- Als RM Polar ist es meine Aufgabe, die Ursache dieses Problems aufzudecken
+  und zu beheben falls moeglich. Nun, es hat sich herausgestellt dass vor
+  allem das lange Warten auf den Bescheid der Balance zu sehr viel Frust
+  gefuehrt hat. (Andere wichtige Faktoren sind die immer neuen "Bewilligungs-
+  gremien" die in letzer Zeit wie Pilze aus dem Boden geschossen sind).
+
+- Beim Lesen der durchaus konstruktiven Artikel in Bezug auf meinen habe ich
+  gelernt, dass auch einige andere Magier hier aufgehoert haben, Objekte
+  zu erzeugen, die bewilligungspflichtig sind, da sie es leid sind, auf die
+  sehr langsam arbeitende Balance zu warten. Das Problem ist wirklich ernst.
+
+- Nochmals von Boing: "Hier jetzt auf das Balance-Team einzuschlagen und
+  quasi zu behaupten wir wuerden nur schlafen finde ich im hoechsten Masse
+  unangebracht." 
+  Hmm. Offensichtlich ist dies leider der Fall. Wenn wir nicht informiert
+  werden, dass da bei euch heisse und komplizierte und langwierige
+  Diskussionen stattfinden, muessen wir annehmen, dass nix passiert.
+  Klassisches Kommunikationsproblem.
+
+- Die Hauptursache wurde also gefunden, die Problemloesung ist, das Problem 
+  beim Namen zu nennen, damit Loesungen gefunden werden (neue Zusammensetzung
+  der Balance, kleiner, schlanker, effizienter). 
+
+- Wenn man nicht ueber Probleme redet werden sie nie geloest. Und jeder macht
+  die Faust im Sack, bis mal wieder ein paar Leuten der Kragen platzt und
+  genau das will ich vermeiden.
+
+- Aus persoenlichen Gespraechen mit Balanceteam-Mitglieder weiss ich, dass
+  einige Mitglieder selber nicht zufrieden sind, dass alles so schleppend
+  geht, das Problem ist also tatsaechlich vorhanden und wird sogar von der
+  Balance selber eingestanden.
+
+- Also habe ich einen Artikel in der MPA abgesetzt. In der Hoffnung es tut
+  sich *sehr* bald etwas, da die Situation meiner Meinung nach untragbar
+  ist.
+  
+- Was ich von den Balancemitgliern erwartet haette war nicht "Tsunami du bist
+  boese und gemein und alle hacken auf uns rum" sondern konkrete
+  Loesungsvorschlaege. z.B. Redimensionierung der Balance auf weniger 
+  Mitglieder, Mitglieder muessen haeufig online sein oder sie verlieren ihren
+  Posten, Magier werden besser informiert, wo ihre Antraege zur Zeit stehen.
+
+- Was Anatol vorgeschlagen hat war mal wieder typisch Anatol und bedarf
+  keinen weiteren Kommentar.
+
+- Mit Tilly als neuem Chef sehe ich einen Lichtstreifen am Horizont.
+
+
+Tsunami. Hoffend auf Besserung.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Dieses Mud stirbt! (Croft, 30. Mai 2001, 23:54:41):
+~#! rn=Tsunami rt=991259513 rg=balance
+~#! tid=991183354
+Was immer noch nicht die Frage beantwortet, was das in einer fuer
+Spieler lesbaren Rubrik soll?
+Gruss Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Dieses Mud stirbt! (Tsunami, 30. Mai 2001, 23:58:34):
+~#! rn=Croft rt=991259681 rg=balance
+~#! tid=991183354
+Croft: tipp mal "rubriken" ... einzige Rubrik wo balancetechnische
+Angelegenheiten reinpassen ist "balance".
+
+Die Balance setzt sich hauptsaechlich aus Spielern zusammen, die koennen
+magier.x nicht lesen.
+
+Und ich finde (meine Meinung) dass das eine sehr wichtige Angelegenheit ist
+und deshalb einem breiten Publikum zugaenglich gemacht werden muss. 
+
+Sonst passiert eh nix. Ich weiss das aus Erfahrung (leider).
+
+Tsunami.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Dieses Mud stirbt! (Anacrion, 30. Mai 2001, 23:58:36):
+~#! rn=Croft rt=991259681 rg=balance
+~#! tid=991183354
+Um ehrlich zu sein: Ich finde es gar nicht so schlecht, wenn kaum was
+genehmigungspfliechtiges geproggt wird und IMHO sollten Dinge, die
+genehmigungspflichtig sind, hoechst selten sein ... insbesodendere nicht 60
+stueck in nem kleinen gebiet .. 
+
+Vielleicht stehe ich mit der meinung mit Ark iallein in einer Ecke und die
+tobende MAsse steht in der anderen, aber was solls ...
+
+Idie Anzahl der von mir geproggten Balancepflichtigen  Elemente werden sich
+zumindest in sehr kleinem Rahmen halten und ich finde nicht, dass das schlimm
+ist  .. muss denn jede waffe gleich ein zweihaendiger max-3-sonderschaden-typ 
+mit integriertem skill, sonderattack und verteidigungsfunktion sein ?
+
+Anac*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Dieses Mud stirbt! (Amaryllis, 31. Mai 2001, 00:02:50):
+~#! rn=Anacrion rt=991259916 rg=balance
+~#! tid=991183354
+> muss denn jede waffe gleich ein zweihaendiger max-3-sonderschaden-typ
+> mit integriertem skill, sonderattack und verteidigungsfunktion sein ?
+
+Ja, wat mut dat mut :) Zumindest, wenn man so guggt, was von Spielern so als
+Standard bevorzugt wird - der Rest wird eh nur zu Geld gemacht :)
+Und was noch erschreckender ist: das ist schon seit langem selbst fuer "kleine
+Wuerste" gang und gebe... aber den Thread hatten wir ja erst :)
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Dieses Mud stirbt! (Anacrion, 31. Mai 2001, 00:03:34):
+~#! rn=Amaryllis rt=991260170 rg=balance
+~#! tid=991183354
+Da ist wohl die Balance zu lasch.
+
+Anac* - NICHT schmarrend
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Dieses Mud stirbt! (Croft, 31. Mai 2001, 00:04:14):
+~#! rn=Tsunami rt=991259914 rg=balance
+~#! tid=991183354
+Tut mir leid das es keine passenden Rubriken dafuer gibt die Balanceteam
+und Magier lesen koennen.  Aber dem kann man sicherlich abhelfen wenn
+man die mpa anfassen will.
+Sicher ist es wichtig sowas einem breitem Publikum zugaenglich zumachen,
+aber das sind imho nur das Balanceteam selbst und Magier.
+Wenn es ein Kommunikationsproblem ist hilft es meinen Erfahrung nie es
+an eine zu grosse Glocke zu haengen.  Das schafft nur noch mehr Frust.
+Gruss Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Dieses Mud stirbt! (Patryn, 31. Mai 2001, 00:07:13):
+~#! rn=Croft rt=991260254 rg=balance
+~#! tid=991183354
+was genau bezweckst du mit dem kleinlichen beharren auf
+mpa-kinkerlitzchen? es reicht, wenn einer nebenher anmerkte, dass das
+in der mpa eher schlecht aufgehoben war, auch wenn ich das anders sehe.
+du musst dem jetzt nicht noch stundenlang um den bart quatschen,
+das thema ist eigentlich ein anderes.
+
+------
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Dieses Mud stirbt! (Tsunami, 31. Mai 2001, 00:18:46):
+~#! rn=Anacrion rt=991259916 rg=balance
+~#! tid=991183354
+Anacrion, du hast keine Ahnung! Wenn du Einblick in meinen Sourcecode haettest
+und mal schauen wuerdest, wie viele Raeume+Details die Gladiatorenschule hat
+und wieviele Objekte dort angeschlossen sind, dann wuerdest du staunen.
+Bei der Rechnung Anzahl Objekte:Raeume stehe ich sehr gut da im Vergleich mit
+anderen Gebieten...
+
+Und es waere ja noch schoener wenn man ploetzlich eine Limite haette wieviele
+"genehmigte Objekte" pro Gebiet man proggen darf. Dann wuerde sich noch der
+letze hier verbleibende programmierende Magier verdruecken. 
+
+Und zu eurer Information: wie setzen sich diese 60 Objekte denn zusammen?
+
+Erstens, in der Gladiatorenschule befinden sich ueber 196 Objekte (Objekte,
+nicht NPCs).
+
+Zweitens, von diesen 60 beantragten Objekten waren die meisten sehr, sehr,
+sehr einfach, d.h. z.B. der "drauhauf-Faktor" P_WC war 1-5 Punkte ueber dem
+von der  Balance irgendwann mal willkuerlich festgelegten Wert. Oder der
+Schutzfaktor einer Ruestung war 1-5 Punkte ueber dem von der Balance
+irgendwann mal willkuerlich festgelegten Wert. Nichts weltbewegendes also.
+
+Von den 26 Waffen waren nur 5 wirklich knifflig, da sie entweder
+Sonderfunktionen wie Todesstossbonus aufweisen oder halt sehr problematisch
+(2-hand Messer) waren.
+
+Von den 96 Ruestungsteilen waren nur 5 wirklich knifflig, die Teile von der
+Kraeuterhexe. 8 weitere waren mittelschwierig da sie Resistenzen hochsetzen.
+
+von den 60 Objekten waren ingesamt 2 wirklich knifflig, das 2-hand Messer
+eines davon.
+
+Wenn ich die Zahlen nun anschau muss ich lachen. Von den 60 Objekten bleiben
+noch 2 wirklich knifflige ueber. Der Rest koennte man in einer Woche
+erledigen.
+
+Ist uebrigens eine gute Taktik, vom eigentlichen Problem abzulenken und mit
+dem  Finger zurueck auf den zu zeigen, der das Problem angesprochen hat.
+
+Wie ich im letzen Artikel aufgefuehrt hatte, bin ich nicht der einzige der 
+frustriert ist.
+
+Tsunami.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Dieses Mud stirbt! (Anacrion, 31. Mai 2001, 00:22:37):
+~#! rn=Tsunami rt=991261126 rg=balance
+~#! tid=991183354
+Hab ich finger gezeigt ?
+
+Nein ....
+
+Und ich wollte auch nciht ablenken ... jedoch finde ich, dass es viel zu viele
+viel zu gute items gibt. 
+Und dass die balance schneller sein koennte, wenn sich alles so zugetragen
+hat, wie vonb dir beschrieben.
+
+Anac*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Dieses Mud stirbt! (Gloinson, 31. Mai 2001, 00:54:25):
+~#! rn=Tsunami rt=991261126 rg=balance
+~#! tid=991183354
+Meine gaaanz private Meinung ist, dass Du den typischen MPA-Brei mal fuer eine
+Woche ignorieren solltest um etwas abzukuehlen ... aber das nur nebenbei.
+Alles andere habe ich in Schmarrn gesagt :)
+
+Gloin(son)
+
+-----------------------------------------------------------------------------
+
+
+
+hmm (Jakscha, 31. Mai 2001, 02:01:20):
+*Achtung Tatterwurst meldet sich zu Wort*
+Ist ja alles ganz schoen und gut, aber wieso muessen 7ben Leute zu jedem
+Gegenstand nen Kommentar abgeben? Kann man da die Bereiche nicht teilen? Also
+(Achtung Beispiel) 2 Spieler + 2 Magier fuer Waffen (Diskussionen und Fragen
+ueber das Thema bei anderen Balancern nicht ausgeschlossen, aber diese 3,4,5
+koennen halt alleine entscheiden) und genauso welche Abstellen fuer
+Sonstiges... geht mir nur um die Aufteilung der Entscheidungsgewalt innerhalb
+der Balance (von der ich natuerlich keinen Plan habe, aber kam aaarg so rueber
+als wuerde jeder immer was dazu sagen wollen, was ich mir wirklich nicht
+vorstellen kann). Ebenfalls frage ich mich wieso muessen Magier *duck* immer
+so super Gegenstaende programmieren (jo, Herausforderung, Seher ins Gebiet
+ziehen....), ich finde das es fuer viele Dinge die es im MG gibt auch noch
+Variationen geben sollte. Als Extrembeispiel!! (ist wohl nen schlechtes)
+koennte es ja nen zweites SMS geben, anderer Ort, andere Taktik es zu holen
+(zB ein SMS Verschnitt der fuer Chaoten leichter zu holen ist als fuer andere
+Gilden (seufz, ok das ist fast unmoeglich, oder? ich meine keine gilde tut
+sich in para-o so leicht wie die Chaoten). Anderes Beispiel ist der schon
+erwaehnte Zauberhut. So wuerde auch den Spielern die Moeglichkeit gegeben sich
+"individueller" einzukleiden.
+
+aah so, hoffe ihr habt so halbwegs verstanden was ich damit gemeint habe.
+tatterwurst hat nicht von allem nen plan, aber in meinen augen sind das gute
+vorschlaege.
+
+und bitte, ignoriert ae ae oder gross-kleinschreibung, norm. ist alles klein
+und ae oe aber diesmal bin ich irgendwie durcheinandergekommen.
+
+hasta luego Jakscha
+
+-----------------------------------------------------------------------------
+
+
+
+Re: hmm (Orktoeter, 31. Mai 2001, 09:16:37):
+~#! rn=Jakscha rt=991267280 rg=balance
+~#! tid=991267280
+Die Antwort auf Jakscha ist zufaellig, da es aktuell der letze Artikel in
+dieser Rubrik ist.
+
+Die Balance in mehrere Teams aufzuteilen und die Gesamtzahl der Mitarbeiter
+aufzustocken erscheint nach dem bisher gelesenen sinnvoll. Wenn das geschieht
+waere es gut, wenn jeder aus dem Balanceteam in 2 oder 3 der neuen Gruppen
+ist, so das nicht nach einiger Zeit die Gruppen Sachen genehmigen, die andere
+Gruppen ablehnen wuerden, sondern die Balance als ganzes in etwa konsitent
+ist.
+
+Alternativ koennte man als Magier ja tatsaechlich mal ueberlegen, ob man nicht
+der Ruestungsspirale mal etwas weniger Vorschub leisten moechte und weniger
+genehmigungspflichtige Sachen proggt. Wenn ich da lese das Tsunami in seinem
+Gebiet mehrere Waffen beantragt hat, die (knapp) ueber dem eigentlichen
+Maxwert liegen, dann kann man den Wert dieser Waffen ja schon fast wieder als
+neuen Maxwert betrachten und der naechste Magier der eine besondere Waffe
+proggen moechte wird wollen, das diese dann noch mehr Schaden macht als die
+bisherigen....
+
+Ich weiss noch, das es frueher als es die ganzen Gilden und die
+Sonderfunktionen noch nicht gab feste Obergrenzen fuer Waffenklassen gab. Wenn
+ich das in einem Artikel richtig gelesen habe, ist es heute so, das es quasi
+zwei Obergrenzen gibt: Eine bis zu der man genehmigungsfrei proggen kann und
+eine weitere bei der die Balance ihr OK geben muss. Wenn es letzere so (noch)
+nicht gibt, sollte man die dringend einfuehren. Was dann noch Sonderfunktionen
+der Waffen anbelangt -> Balance 
+
+Was ich da oben fuer Waffen gesagt habe gilt auch fuer Ruestungen etc.
+
+OrkT.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: hmm (Bendeigid, 31. Mai 2001, 09:32:07):
+~#! rn=Orktoeter rt=991293397 rg=balance
+~#! tid=991267280
+Das hast du, um es mal kurz zu sagen, NICHT richtig verstanden.
+Es gibt auch heute noch MAX-Werte, die allerdings bei einigen Magiern als
+Minimum angesehen werden, bei dem sich ein HLP noch danach umguckt.
+Tsu redete allerdings NICHT von diesen (harten!) MaxGrenzen, sondern von den
+(mehr oder weniger) willkuerlichen festgelegten Grenzwerten fuer die Balance.
+Diese unterscheiden sich DEUTLICH von den Maxwerten (sie sind kleiner... wer
+haette das gedacht?) und sind nur dafuer da, fuer eine gewisse Ausgewogenheit
+zwischen "normalen" Sachen und "guten" Sachen in einem Gebiet zu sorgen. 
+Es soll ja mal rein zufaellig in einigen Gebieten dazu gekommen sein, dass
+fast nur Dinge haarscharf unter den MAXwerten geproggt wurden und (fast) nix
+im mittleren Bereich. Deswegen seid ihr Spieler auch so verwoehnt und meckert,
+wenn das mal angepasst wird.....
+Um da den MAGIERN, nicht den Spielern(!) den Spass zu verderben und auch mal
+anderen Magiern die Chance zu geben, auch ein oder zwei an den Maxwerten
+ausgerichtete Sachen proggen zu koennen, die vielleicht auch mal ein Spieler
+anguckt, DARUM wurde die Balance eingefuehrt.  
+Ich weiss, fuer die Ausgewogenheit in vor allem neuen Gebiete zu sorgen ist
+eigentlich Aufgabe der RMs, aber leider leider lag genau da der Bock im
+Garten...
+Soviel zur Auklaerung.
+Um den Flamewar mal fortzusetzen:
+
+Mich stoert die Moeglichkeit, dass Spieler wie T* oder sonstwer Level groesser
+100 erreichen koennen massiv. ich kann naemlch mit so grossen Zahlen nicht
+umgehen. Reicht das als Begruendung?
+
+:) Ben, den letzten teil nicht ganz ernst meinend, den ersten aber sehr wohl
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Dieses Mud stirbt! (Padreic, 31. Mai 2001, 09:47:10):
+~#! rn=Boing rt=991224213 rg=balance
+~#! tid=991183354
+Das Dir nichts weiter zu dem Thema einfaellt als Tsunami der hier ein sehr
+ernstes Thema anspricht, als Nestbeschmutzer zu bezeichnen finde ich sehr sehr
+Schade. Du warst lange Zeit der Chef der Balance und als solcher fuer den
+Missstand, der hier von nahezu _allen_ aktiven Magiern angeprochen wird, fuer
+die langen Bearbeitungszeiten sagen wir mal, zumindest politisch
+verantwortlich. Vielleicht solltet ihr lieber endlich mal darueber nachdenken
+konzeptionelle-Konsequenzen daraus zu ziehn um das Problem in den Griff zu
+kriegen, anstatt das Problem aus der Welt reden zu wollen.
+Wie waere es denn fuer jeden Antrag grundsaetzlich einen verantwortlichen zu
+bestimmen und nach einer gewissen diskussionslosen Zeit automatisch das
+Verfahren und den aktuellen Abstimmungsstand rauszusenden?
+
+Pad*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Dieses Mud stirbt! (Boing, 31. Mai 2001, 10:03:55):
+~#! rn=Padreic rt=991295230 rg=balance
+~#! tid=991183354
+Wie Du aus meinem Artikel vom 14. Mai in der Rubrik bekanntmachungen
+ersehen kannst, HABE ich bereits Konsequenzen aus dem durchaus vorhandenen
+Missstand gezogen. Ich war mir sehr wohl im Klaren darueber, dass ich
+aufgrund von Zeitmangel nicht mehr genug Zug in das Balance-Team bringen
+kann, deswegen bin ich zurueckgetreten und Tilly ist neuer Chef. Diese
+Entscheidung traegt schon jetzt Fruechte. Insofern ist diese Diskussion
+eigentlich schon wieder veraltet.
+  Boing
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Dieses Mud stirbt! (Apollonia, 31. Mai 2001, 10:08:06):
+~#! rn=Padreic rt=991295230 rg=balance
+~#! tid=991183354
+Auch wenn ich selbst bisher nichts mit der Balance zu tun hatte und nicht
+wirklich aus eigener Erfahrung sprechen kann, muss ich jetzt doch das ein oder
+andere zu dem Thema loswerden...
+
+Ich habe bei dem ein oder anderen Magier mitbekommen, wie Antraege behandelt
+wurden. Und ich kann da nun wirklich nicht behaupten, dass die Bearbeitung
+exorbitant lange gedauert haette oder die Werte extrem heruntergeschraubt
+worden waeren. In einem Fall wurde ein Item sogar von der Balance aufgewertet,
+man stelle sich das mal vor.
+
+Padreic, ich bin nicht der Meinung, dass Boing Tsunami hier als
+Nestbeschmutzer hinstellt, wohl aber Tsunami die Balance allgemein als
+Hemmschuh klassifiziert, was sie definitiv nicht ist. Okay, es mag sein, dass
+es in Einzelfaellen zu extrem langen Bearbeitungszeiten kommt, kann ich nicht
+wirklich beurteilen, weil's mir noch nicht passiert ist. Und selbst wenn, waer
+das kein Grund fuer mich, mich derartig aufzuregen und zu proklamieren, dass
+dadurch das Mud stirbt. Es ist _natuerlich_ frustrierend, wenn man monatelang
+auf eine Antwort warten muss, aber im Fall dieses Messers kann ich dazu aus
+meiner Sicht nur sagen, dass die Regeln klar besagen, dass Messer nun mal
+einhaendig zu sein haben. Soll man der Balance nun vorwerfen, dass sie den
+Antrag trotzdem diskutiert haben, anstatt von vornherein zu sagen 'Neee,
+gibt's nicht, basta!'??
+
+Wir investieren hier alle unsere Zeit, obwohl wir (hoffentlich) noch ein Leben
+ausserhalb des Muds haben. Das gilt fuer Spieler wie fuer Magier. Und ich kann
+mir sehr gut vorstellen, dass es alles andere als einfach fuer die
+Balancemitglieder ist, Waffen etc. einigermassen ausgewogen zu halten, bei der
+Groesse, die dieses Mud nun mal mittlerweile hat.
+
+Was meiner Meinung nach hier oft genug fehlt, ist der gesunde
+Menschenverstand. Man kann ja auch von vornherein abklaeren, ob eine Waffe
+etc., die man zu proggen beabsichtigt, so ueberhaupt ne Chance hat, durch die
+Balance zu kommen. Das erspart einem Magier unnoetige Arbeit. Und der Balance
+ebenfalls. Mit ein bisschen Kooperationsbereitschaft von beiden Seiten geht
+alles viel besser.
+
+Tatsache jedenfalls ist, die Ruestungsspirale gibt es, wird es auch weiterhin
+geben und das macht die Balance definitiv erforderlich. Vielleicht mag die ein
+oder andere strukturelle Veraenderung sinnvoll sein, aber pauschal die Arbeit
+der Balance als 'Dreck' oder aehnliches zu bezeichnen, wie es hier schon der
+ein oder andere getan hat, halte ich fuer extrem kurzsichtig.
+
+Apo*
+(auch noch Arbeit fuer die Balance habend)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Dieses Mud stirbt! (Padreic, 31. Mai 2001, 10:51:32):
+~#! rn=Apollonia rt=991296486 rg=balance
+~#! tid=991183354
+Ich glaube niemand versucht hier ernsthaft die Balance als "Dreck" zu
+beschimpfen, auch Tsunami nicht. Es geht derzeit auch nicht um inhaltliche
+Entscheidungen. Ich bin da zwar sicher nicht immer einer Meinung mit der
+Balance, aber inhaltlich halte ich ihre Arbeit fuer voellig in Ordnung. Es
+geht schlichtweg um Form und Dauer einiger Antraege. Ich kann mich aus eigener
+Erfahrung noch an Genehmigungszeiten von nem halben Jahr fuer den
+Paraschlachthof entsinnen und das waren 2-3 nich wirklich soooo besonders
+harte Gegenstaende. Die Tatsache das Nonne und Du soetwas noch nicht hatten,
+heisst noch lange nicht, das es nicht vorkommt und auch nicht unbedingt das es
+an den Magiern selbst liegt, denn dafuer haben _zuviele_ dieses Problem.
+Davon das man sich ein halbes Jahr Zeit laesst, werden die Entscheidungen auch
+nicht besser, denn ich denke nicht das man ueber ein Thema so lange wirklich
+sinnvoll mit immer neuen Aspekten diskutieren kann (das schafft ja nicht mal
+der Bundestag). Im Prinzip geht es darum, eine Organisationsstruktur zu
+schaffen, so dass Antraege nicht mehr so endlos lange brauchen, auch zu Zeiten
+in denen einige Balancemitglieder gerade wenig Lust und/oder Zeit haben. Nun
+in einem Punkt hat Boing jedoch Recht, es gibt nun einen neuen Chef,
+vielleicht sollten wir ihm einfach mal 100 Tage Zeit geben sich zu bewaehren
+und diesen Thread nun hoechstens zu konstruktiven Verbesserungsideen mutieren
+lassen.
+
+Pad*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Dieses Mud stirbt! (Ark, 31. Mai 2001, 11:35:01):
+~#! rn=Tsunami rt=991259513 rg=balance
+~#! tid=991183354
+Hm, Tsunami, nur mal kurz als Ueberlegung: mehr als 60 Objekte auf einmal?
+Wenn das stimmt, dann schaun wir mal, bei wirklich schnellen 2 Tagen als
+Bearbeitungszeit (da flutscht das aber schon, und die Leutchens machen nix
+anderes, als fuer einen Magier zu arbeiten!) haetten wir alle Saechelchen in
+120 Tagen, also etwa 4 Monaten hinter uns. Ist mir nun sonnenklar, dass es bei
+einem nicht trivialen Teil auch mal etwas laenger dauern kann. Ich kenne die
+Schule jetzt noch nicht in und auswendig, aber mehr als 60 Raeume hat die doch
+nicht, oder? Waere also ein ueberdurchschnittliches Item pro Raum (bitte ruhig
+korrigieren). Da stellt sich fuer mich die Frage, warum Du Dir als RM nicht
+mal an die Nase fasst und sagst: Mensch, in meinem Gebiet stimmt was mit der
+Balance nicht. Nicht falsch verstehen, die Sachen sind originell und gut, aber
+wohl _etwas_ gehaeuft. Oder liege ich da falsch?
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Dieses Mud stirbt! (Ark, 31. Mai 2001, 11:42:29):
+~#! rn=Tsunami rt=991261126 rg=balance
+~#! tid=991183354
+Gut, noch nicht weitergelesen, sorry. Aber wenn einige nur wenig ueber den
+Genehmigungsgrenzen waren, kann man sie doch auch problemlos darunterdruecken,
+oder? Wenn es wirklich nur 5-10 gewesen sind, die Du vorlegst und lange drauf
+warten musst, koennte ich Dir noch die Hand reichen, aber so muss ich aus
+eigener Erfahrung sagen: die Balance Leute sind zwar nicht die Schnellsten,
+aber wenn man jemanden freundlich ein oder zweimal erinnert, kam immer(!)
+Feedback, und dann auch relativ schnell (meine Erfahrung). Ton macht die
+Musik, klingt altklug, ist aber so. Wenn wir uns hier nicht dauernd
+persoenlich anpflaumen wuerden und Flamewars als Stilmittel pflegen wuerden,
+waere die vielzitierte Atmosphaere vielleicht auch nicht so "mies".
+Wie dem auch sei, ich mache immer weiter ;^)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Dieses Mud stirbt! (Grimmborn, 31. Mai 2001, 11:45:15):
+~#! rn=Ark rt=991302149 rg=balance
+~#! tid=991183354
+> Wenn wir uns hier nicht dauernd
+> persoenlich anpflaumen wuerden und Flamewars als Stilmittel pflegen wuerden,
+> waere die vielzitierte Atmosphaere vielleicht auch nicht so "mies".
+
+Waerst Du bitte so freundlich nicht die allgemein uebliche Verwendung der mpa
+zu torpedieren?
+Vielen Dank.
+
+Grimmborn der Atheist
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Dieses Mud stirbt! (Matis, 31. Mai 2001, 11:45:33):
+~#! rn=Ark rt=991302149 rg=balance
+~#! tid=991183354
+Punkt 1: Tsunami hat hinsichtlich der Bearbeitungsdauer seines Messerantrages
+vollkommen recht. Dort haette eine Entscheidung viel frueher fallen muessen,
+das geht eindeutig auf die Kappe der Balance. Aber ich moechte ein einziges
+Mal an diesem Beispiel aufzeigen, dass so eine Entscheidung nicht immer 
+einfach ist. 2Hand-Messer werden per Definition nicht zugelassen. Allerdings
+wollten wir sein Messer auch nicht einfach so auf 1Hand setzen und damit
+nahezu
+uninteressant machen. Also gab es Diskussionen ueber die Maximalwerte von
+1Hand- und 2Handwaffen, ob es da einen Unterschied geben sollte, ob der
+Vorteil
+von 2Haendern in einer hoeheren Waffenklasse liegen sollte oder in einem
+eigenen Skill, ob es nur einen Skill fuer 2Haender oder auch einen fuer 
+1Haender geben sollte, ob allgemeine (gildenunabhaengige) Waffenskills was 
+bringen koennten, wie es da eigentlich mit dem Trves-2Handskill aussieht,
+und so weiter und so fort. Zwischenzeitlich waren die Erzmagier mehrmals
+involviert. Tsunami hatte eine Version seines Messers angeschlossen, und so
+stellten wir den Antrag zurueck, da wir hofften, ihm etwas positiveres als
+eine
+Quasi-Ablehnung zu liefern. Und diese Zurueckstellung wurde leider immer 
+laenger ...
+
+Punkt 2: Man kann mit der Balance reden. Zumindest helfen Mitteilungen wie
+"Hey ihr Schlafsaecke, was macht mein Antrag? Macht mal ein wenig hin!"
+durchaus. Staendiges Nerven nervt irgendwann wirklich, und dann tuen wir auch
+was ;o).
+
+Punkt 3: Groessere Balance, kleinere Spezialteams - ich glaube nicht dass das
+funktioniert. Bei 3-Mann-Entscheidungen ueber Objekte besteht eine viel 
+groessere Gefahr der starken Polarisierung der Meinungen, und wenn in einem
+solchen Team einer fuer ein Weilchen fehlt, dann ist die Arbeit wirklich
+lahmgelegt. Tilly als neuer Balance-EM bringt im Moment viel neuen Schwung 
+ein, und vor allem er hat Zeit. Das tut der Balance spuerbar gut.
+
+Punkt 4: Mir faellt gerade nichts mehr ein, also ist hier erstmal Schluss.
+
+Matis
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Dieses Mud stirbt! (Pilgrim, 31. Mai 2001, 12:04:34):
+~#! rn=Tsunami rt=991259914 rg=balance
+~#! tid=991183354
+> einzige Rubrik wo balancetechnische
+> Angelegenheiten reinpassen ist "balance".
+> 
+> Die Balance setzt sich hauptsaechlich aus Spielern zusammen, die koennen
+> magier.x nicht lesen.
+
+O.K. ... das Argument ist stichhaltig, allerdings bezieht sich diese
+ganze Diskussion _nicht_ auf's 'breite Publikum', sondern
+nur auf das Verhaeltniss Magier<->Balance, also mehr auf
+Organisatorische Sachen ... vieleicht sollte man mal ueber
+ne MPAgruppe nachdenken, die nur Magier und Balance lesen
+koennen ... aber fuer jetzt ist das eh egal, das es hier
+nunmal schon steht ;-)
+
+Pilgrim
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Dieses Mud stirbt! (Bambi, 31. Mai 2001, 12:14:34):
+~#! rn=Anacrion rt=991259916 rg=balance
+~#! tid=991183354
+Was die Ecken betrifft... Bei euch ist wohl mehr Platz. Ich komm zu euch
+beiden. :)
+
+-----------------------------------------------------------------------------
+
+
+
+Balancemitglieder && Zeitung (Gloinson, 31. Mai 2001, 13:32:19):
+AFAIK wird das Feature des zu niedrigleveligen Mitlesers in einer
+hocheingestuften Rubrik vom Newsreader unterstuetzt. Eine Nutzung dieses
+duerfte formelle Fragen der Art in Zukunft etwas zurueckdraengen.
+
+Gloin(son)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Dieses Mud stirbt! (Wurzel, 31. Mai 2001, 16:37:08):
+~#! rn=Matis rt=991302333 rg=balance
+~#! tid=991183354
+wunderbar. toll. hat nur einen winzig kleinen schoenheitsfehler, ansonsten
+einwandfrei.
+zweihandmesser werden per definition nicht zugelassen. punkt, aus. das wird
+weder erlaeutert noch hinterfragt, sondern ist ja "per definition" (ich hoer
+grad meinen alten lateinlehrer rotieren, deswegen zitier ich das mal nicht
+weiter) eindeutig festgelegt. und jetzt kommt tsunami an und beantragt doch
+sowas, der boese wicht. eigentlich gibt es nur zwei moeglichkeiten: erstens,
+da haben wir ja diese definition, also abgelehnt. geht schnell, braucht kein
+ganzes jahr, noch nicht mal einen ganzen tag. wofuer haben wir denn unsere
+regeln? zweite moeglichkeit: tsunami begruendet das gut (hat er irgendwo in
+dieser rubrik glaub ich auch mal geschrieben), also koennte man ja mal eine
+ausnahme von dieser regel machen. da macht man (vorsicht, neudeutsch) ein
+impact assessment, sollte den muderfahrenen balanceleuten ja nicht allzu
+schwer fallen, und wenn der impact nicht alles zerfetzt, was gut und heilig
+ist, dann ab damit. wenn sich im nachhinein herausstellt, dass man bei dem
+assessment was uebersehen hat, kann man ja immer noch abwerten/abhaengen.
+das ganze sollte nicht laenger dauern als eine woche. und was passiert in
+wirklichkeit? da werden grundsatzdiskussionen losgetreten, ob man allgemeine
+waffenskills einfuehren soll etc. sowas dauert natuerlich, und es hat mit
+dem objekt in frage nicht wirklich etwas zu tun. ist dabei auch die oben
+angesprochene definition mal hinterfragt worden? ich kann mir momentan nicht
+vorstellen, warum es kein zweihandmesser geben soll. ich kenne da (in rl)
+einen schmied, der - gegen gutes geld natuerlich - auch ausgefallene und
+ungewoehnliche messer herstellt. zweihandmesser? kein problem. muss also
+einen bestimmten grund haben, wahrscheinlich brauchen hobbits mit trveslevel
+23 dann 5 sekunden weniger fuer die hydra als der kampfzwerg mit vollstrecker
+oder aehnliches. allerdings nur, wenn das messer maximale waffenklasse hat.
+um gottes brille, da geht ja die welt unter.
+hallo? seid ihr noch da? alles gesund? und wie geht es dem kopf heute?
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Dieses Mud stirbt! (Montanus, 31. Mai 2001, 17:43:25):
+~#! rn=Wurzel rt=991319828 rg=balance
+~#! tid=991183354
+
+Um eine vollstaendige Balance in diesem Mud herzustellen, gibt es nur EINE
+Loesung:
+
+Schafft ALLE Waffen ab. Schwerter zu Pflugscharen, Vollstrecker zu
+Diddl-Maeusen, Zweihandmesser zu Kartoffelschaelern.
+
+Nehmt auch den Monstern die Waffen weg. Bringt ihnen lieber interaktive Skills
+bei. Das waer doch was, wenn man den Weghier in 4gewinnt besiegen muesste,
+oder die Hydra erstmal zu einer Partie Skat in der Lupinentalkneipe
+herausfordern muss. Oder gegen kampfhuehner Rage spielt.
+
+Moensch, ihr habt echt Probleme, dabei ist die Loesung sooooooo einfach.
+
+-Montanus. Pazifist.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Dieses Mud stirbt! (Silvana, 31. Mai 2001, 17:46:09):
+~#! rn=Montanus rt=991323805 rg=balance
+~#! tid=991183354
+Skat gegen die Hydra? Die schummelt doch bestimmt mit ihren 12 Koepfen. Wer
+soll denn die im Auge behalten, dass einem nicht mindestens ein Kopf staendig
+in die Karten schielt...? Und mit Kampfhuehnern Rage spielen geht jetzt schon.
+Gewinnen ist zugegebenermassen schwer, aber zu schaffen. :)
+
+  Silvana
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Dieses Mud stirbt! (Hight, 31. Mai 2001, 17:55:07):
+~#! rn=Montanus rt=991323805 rg=balance
+~#! tid=991183354
+formlierne wir es anders: lasst die zauberer die welt regiern !
+
+du ****
+
+Hight kopfschuettelnd
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Dieses Mud stirbt! (Thanos,  1. Jun 2001, 00:35:04):
+~#! rn=Wurzel rt=991319828 rg=balance
+~#! tid=991183354
+baeh...
+der kampfzwerg mit vollstrecker
+
+Ich bin nicht mal kampfzwerch und schauder bei dem gedanken
+
+Thanos, Schwerter sind doch nix ((c) Karic)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Dieses Mud stirbt! (Teddy,  1. Jun 2001, 01:57:09):
+~#! rn=Tsunami rt=991259513 rg=balance
+~#! tid=991183354
+Der Reply ist nahezu willkuerlich gewaehlt, es geht um mehrere Artikel.
+Zum einen, der Arbeitsaufwnd ist teilweise wirklich enorm, auch ich erinnere
+mich an gewisse Antrags"orgien" seitens einiger Magier.
+Generell dauern Antraege wohl schon seit Gruendung der Balance deswegen so
+lange, weil es sich keiner der Mitglieder leicht macht. Im Klartext heisst
+das, wenn ein Objekt eigentlich abgelehnt werden muesste, haben wir es
+zumindest zu Zeiten, in denen ich der Balance angehoerte, so gehandhabt, dass
+der entsprechende Magier eine begruendete Ablehnung und meist auch ein oder 2
+Alternativvorschlaege von uns erhielt.
+Hintergrund ist einfach, dass eben niemand den Spielern oder Magiern den Spass
+verderben will, jeder Magier hat Arbeit und Kreativitaet und Muehe
+reingesteckt, zumindest unterstellt man ihm das ja im Allgemeinen, das wird
+nicht pauschal ignoriert.
+Das Balanceteam besteht halt NICHT aus einem Haufen Sesselpuper oder
+Buerokraten, die versuchen, eine schoene Idee im Dialog doch noch moeglich zu
+machen,
+Inaktivitaet oder fehlende Motivation fuehrten in der Vergangenheit immer
+wieder zu Umbesetzungen des Teams, immerhin ist von der anfaenglichen Kombo
+nicht mehr viel uebrig geblieben. Sollte hier aber das Gepruegel auf die
+Balance mal wieder so weitergehen, ein Phaenomen, das im uebrigen auch nicht
+neu ist, kann ich jeden verstehen, der dann garkeine Lust mehr hat auf sowas.
+Zusaetzlich zu der Masse und den Problemen, die gerade abzulehnende Antraege
+machen, gibt es dann noch Hammerantraege.
+Ich finde es interessant, dass sich gerade Padreic ueber Bearbeitungszeiten
+fuer Schlachthofobjekte beschwert, aber mit keinem Ton den immensen Aufwand
+gewisser anderer Projekte erwaehnt oder auch die Schwierigkeiten, die
+beispielsweise Runenschwerter verursacht haben, bei denen es eben deutlich
+schneller ging und vieles uebersehen wurde.
+Sachen ersteinmal anzuschliessen und im Zweifelsfalle wieder abzuhaengen oder
+zu aendern.... habt ihr euch mal ueberlegt, was ihr da sagt? Habt ihr euch mal
+alleine die Diskussionen zum SMS in den letzten Wochen angeschaut? SMS kann in
+diesem Fall gerne durch VS, Rattenblut etc ersetzt werden!
+
+Groesse des Teams: Der Grundgedanke war und ist imho noch immer, moeglichst
+sehr unterschiedliche Leute aus verschiedenen Gilden mit verschiedenen
+Kampfstilen zu integrieren, so bestand die Anfangsgruppe damals aus Sting,
+Nachtwind, Sharia, Zephyr, Tars, Boing und mir. Jeder einzelne voellig
+verschieden in Gile und/oder Kampfstil. Auch heute wird wohl noc immer nach
+diesen Kriterien vorgegangen, man schaue sich einfach die letzte Ausschreibung
+mal genauer an.
+Man kann einfach nicht alles ueber Maxwerteregelungen abdecken, zu viele
+Sachen sind beispielsweise bei anderen Grenzwerten fuer Gilde xy bei Spell ab
+optimal oder lassen sich kombinieren mit Tool123 aber nur bei Gilde 456 usw.
+Um das Spektrum moeglichst breit abzudecken (ganz wird es wohl nie gelingen)
+wurde diese Teamgroesse gewaehlt.
+Ein letztes Wort noch zu den willkuerlich gesetzten Grenzen, die sind nicht
+ganz so willkuerlich gesetzt wie es wohl den Anschein ha.
+Es gab mal andere, deutlich hoehere Grenzen, dann wurde ein Konzept fuer
+Schadenstypen entwickelt (Ueberraschung, die Balance beschaeftigt sich nicht
+nur mit Antraegen sondern schaut auch mal ueber den Tellerrand in die
+Zukunft), auf dieser Basis wurden dann fuer Schadenstypenklassen auch
+Grenzwerte festgelegt, die definitiv, nach damaligem Wissen, unkritisch sind.
+Diese Werte so niedrig anzusetzen war leider noetig, da es sich davor
+eingebuergert hatte, beispielsweise bei Waffen, exakt 1 Punkt WC unter der
+Grenze zu bleiben und diese alten Grenzen waren nicht ganz so unkritisch wie
+die neuen.
+Wenn also jetzt zum einen mehr Antraege kommen, liegt es eben daran, dass
+dieser Wildwuchs gestoppt werden musste. Wenn auf der anderen Seite aber auch
+mehr Leute nicht genehmigungspflichtige Objekte schreiben, dann hat die
+Balance imho nen guten Job gemacht, denn es gibt noch andere Sachen als
+Maxwaffen.
+
+Cu,
+
+Teddy.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Dieses Mud stirbt! (Ark,  1. Jun 2001, 10:42:09):
+~#! rn=Teddy rt=991353429 rg=balance
+~#! tid=991183354
+Und dann gibt es fuer uns Magier ja noch die Alternative, etwas ohne das
+kritische Objekt anzuschliessen und es erst spaeter zu anzukuendigen. Gibt
+meist nochmal einen Boost fuer das Gebiet und sicher ein kleineres Risiko fuer
+spaeteres Abwerten.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: ja was denn noch .. (Grimman,  8. Jun 2001, 14:47:49):
+~#! rn=Darkwing rt=990272406 rg=balance
+~#! tid=990173074
+Das Problem daran ist doch eher das die Leute in der Balance die selber
+spielen immer eine Umgehung fuer Ihre eigenen Abwertungen finden werden ...
+d.h. lassen wir mal das SMS abwerten, wir als balance wissen ja was noch gut
+oder auch besser als das ist und wie ich rankomme ...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: ja was denn noch .. (Grimmborn,  8. Jun 2001, 14:51:23):
+~#! rn=Grimman rt=992004469 rg=balance
+~#! tid=990173074
+Genau, es ist eine Unverschaemtheit dass sich Leute hier gut auskennen und
+fuer alles Alternativen kennen.
+
+Grimmborn der Atheist
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Schwertmeisterschwert (Grimman, 16. Jun 2001, 00:28:55):
+~#! rn=Anatol rt=989966916 rg=balance
+~#! tid=989966916
+Also, um den Thread nochmal anzuheizen ...
+Ich benutzte das SMS sehr gerne, und war immer zufrieden damit.
+Und ... um das gleich mal zu sagen ... ICH BIN ES HEUTE NOCH !!!
+Auch heute benutze ich mit Vorliebe das SMS, und in meinen Augen ist der
+Schaden nich wesentlich weniger geworden ... ich hab sogar das gefuehl, das
+ich besser damit kaempfe, vielleicht nich immer maximalen Schaden, dafuer aber
+auch selten nur Mindestschaden.
+
+So, und wenn ihr mich jetzt vierteilen wollt, weil ich den Thread nich ruhen
+lassen wollte, na dann los 
+
+*Flame on*
+
+GrimMan, noch nie wirklich unzufrieden mit der Balance, aber ich bin ja auch
+nur ne Wurst.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Schwertmeisterschwert (Tektuko, 16. Jun 2001, 08:19:26):
+~#! rn=Grimman rt=992644135 rg=balance
+~#! tid=989966916
+Mh... Dann wuerd ich auch gern nochmal meinen Senf dazugeben. Ich hab das Sms
+frueher auch gern benutzt. Und jetzt ist es abgewertet. Meine Zweitis werden
+es nicht benutzen koennen, Ersti ist Wurstmagier. Na und? Gibt doch noch
+andere Waffen und ich denke kaum das durch Abwerten der Balance Gegner
+unbesiegbar werden.
+Also sucht euch andere Waffen und haut einfach weiter schoen zu. Kann doch nix
+langweiligeres geben als Dg, Weghier, .. die man Todidlet weil es irgendwann
+solche Super Ruestungen und Superwaffen gibt.
+Tektuko, nicht viel Ahnung hab, aber eine Meinung.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Schwertmeisterschwert (Solmyr, 16. Jun 2001, 09:18:33):
+~#! rn=Tektuko rt=992672366 rg=balance
+~#! tid=989966916
+Selbstinitiative ist hier das Schlagwort! Wenn man sich selbst schon
+als Wurstmagier bezeichnet, dann sollte man das schleunigst aendern
+(meine Wenigkeit steht da uebrigends nicht zur Debatte *g*). Nunja,
+kommen wir zum Thema: Wozu Vollmagier, Regionsmitarbeiter oder sogar
+Erzie werden, wenn man sich seine Lorbeeren auch anders verdienen kann.
+Die Aufgabe: Die Programmierung eines gesamten 'KickAss-Satzes an 
+Ausruestung, sodass Weghier, DG und der ganze schleimige Rest nur so
+fallen wie die Fliegen. Ach ja, wir brauchen noch einen kleinen Kreis
+von Magiern, die bereits Schreibrechte in hoeheren Bereichen haben und
+ein wenig an der Balance vorbeiarbeiten wollen.
+Also, auf das wir Sky, Matis und Konsorten noch mehr Salz in die Suppe
+streuen und mit dieser KickA*Ausruestung zur Levelaufholjagd blasen!
+Schon in Rom hiess es ja 'Ehre und Staerke', aber 'Ehre, Staerke
+und Gerechtigkeit' habe ich noch nirgendswo gehoert bzw. gelesen, es
+waren immerhin Pioniere der professionellen Korruption :) Also los!
+Nieder mit dem System! Alle Macht dem Proletariat! Gegen die Alten!
+Es lebe das Volk! Ich liebe doch alle Menschen (oeh, falsches Zitat..)!
+Oder lasset die Spiele beginnen! Moege der hinterlistigste gewinnen!
+
+*Ironiemodus aus*
+Solmyr
+
+ersten Wortes ein. Vielen Dank!
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Schwertmeisterschwert (Taragon, 16. Jun 2001, 12:43:28):
+~#! rn=Tektuko rt=992672366 rg=balance
+~#! tid=989966916
+Tektuko schrieb:
+...
+> und ich denke kaum das durch Abwerten der Balance Gegner unbesiegbar werden.
+
+Meine rede... BALANCE ABWERTEN! :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Schwertmeisterschwert (Tektuko, 16. Jun 2001, 13:06:09):
+~#! rn=Taragon rt=992688208 rg=balance
+~#! tid=989966916
+Ich verbessere mich :) Durch das Abwerten von Ausruestungsgegenstaenden durch
+die Balance.
+
+Tektuko, fuer die Balance.
+
+-----------------------------------------------------------------------------
+
+
+
+auch mal was zum sms sagen will (Roland, 18. Jun 2001, 19:42:21):
+also das das sms zu stark war und abgewertet wurde.. schoen und gut ... 
+aber das hier auch eine kleie rassendiskri... uha wie schreibt man das .. 
+naja ich sags ma so .. :
+
+Was mir abselut gegen den strich geht! ist das hier im MG einige rassen
+beforzugt werden!
+wie ich das meine ... naja es gibt das sms (was mal ultimativ war)
+und  weiter ... menschen koennen den umgang damit abseult perfekt lernen
+(kaempfer/zaahk) + sms sehr hoch.
+andere rassen zb nicht ... 
+
+wieso wird hier immer nur von abwerten gesprochen und nicht mal von was neuem.
+was is mit den kleinen hobbitz ,,, wie waers fuer die mal n spitzen messer
+oder fuer andere rassen gut lernbare und auf die faehigkeiten zugeschnittenen
+eigenschaften
+produzierte waffen ...
+es wurde beklagt das katzen mit schwerten nicht zurecht komm ... naja dann
+soll man doch von jedem waffentyp eine sehr gute waffe machen und diese von
+mir aus in Para sonstwo einbaun
+sag aber alles einseitig zu gestalten .. und das dann auch noch so zu
+veraendern das kaum mehr wer damit zurecht kommt is eine bissel schlechte
+loesung.
+
+eine gute waffe zugeschnitter fuer rasse und gilde ... und gut ... 
+keiner wird sich beschweren .. 
+
+so das war alles ... 
+alles n bissel wir ... aber es muste mal raus.. !
+
+MfG Roland
+
+-----------------------------------------------------------------------------
+
+
+
+Re: auch mal was zum sms sagen will (Grimmborn, 18. Jun 2001, 19:57:28):
+~#! rn=Roland rt=992886141 rg=balance
+~#! tid=992886141
+Gewoehn Dich halt dran: Es gibt Loserrassen, ebenso wie es Losergilden gibt.
+Als ich mit Rollenspielen anfing wollte ich auch immer Superheroes spielen,
+aber mit der Zeit merkt man dann dass das nicht der Weisheit letzter Schluss
+ist. Im FRP machen die etwas... defekten Charaktere letztlich wesentlich mehr
+Spass. Ich hatte da mal einen Krieger, der war im linken Bizeps klasse, hatte
+einen maechtigen rechten Bizeps, und wenn sich seine vier Gehirnzellen
+anstrengten konnte er auch Saetze mit mehr asl fuenf Woertern bilden. Dass er
+in der Pubertaet war und in der Gruppe eine Frau mitging, in die er
+unsterblich verliebt war, hat die Situation nicht besser gemacht...
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re: auch mal was zum sms sagen will (Nizzl, 18. Jun 2001, 20:52:36):
+~#! rn=Roland rt=992886141 rg=balance
+~#! tid=992886141
+schon wieder einer der nicht weiss, dass hobbits die ultimative rasse
+schlechthin ist...
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: auch mal was zum sms sagen will (Troy, 18. Jun 2001, 20:55:47):
+~#! rn=Nizzl rt=992890356 rg=balance
+~#! tid=992886141
+Der Spruch war nicht ganz korrekt. Richtig muss es lauten:
+
+schon wieder einer der nicht weiss, dass hobbits ultimativ krass schlecht
+sind...
+
+Troy
+
+-----------------------------------------------------------------------------
+
+
+
+Re: auch mal was zum sms sagen will (Tektuko, 18. Jun 2001, 21:12:14):
+~#! rn=Roland rt=992886141 rg=balance
+~#! tid=992886141
+Hobbits haben auch ihre Vorteile, frag Miyagi :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: auch mal was zum sms sagen will (Anacrion, 18. Jun 2001, 21:13:24):
+~#! rn=Tektuko rt=992891534 rg=balance
+~#! tid=992886141
+
+Oder Devilchen, Jasmin, Eldaron, .....
+
+Anac*
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: auch mal was zum sms sagen will (Tektuko, 18. Jun 2001, 21:15:03):
+~#! rn=Anacrion rt=992891604 rg=balance
+~#! tid=992886141
+Ich hatte das jetzt auf Karate bezogen :)
+
+-----------------------------------------------------------------------------
+
+
+
+noch was dazu (Roland, 18. Jun 2001, 21:54:04):
+~#! rn=Tektuko rt=992891703 rg=balance
+~#! tid=992886141
+ich hatte es im bezug auf rassen in der kaempfergilde und den gilden
+ueberhaupt gemaien .. nicht das die eine rasse schlaecht waer
+
+-----------------------------------------------------------------------------
+
+
+
+Re: auch mal was zum sms sagen will (Pardauz, 18. Jun 2001, 22:01:43):
+~#! rn=Roland rt=992886141 rg=balance
+~#! tid=992886141
+rassendiskriminierung im MorgenGrauen? iss schon gemein dass keiner
+so schnell kaempfen kann wie felinen. und keiner mehr essen kann als
+ein hobbit. und warum sind die armen zwerge so anfaellig auf wasser?
+und erst die diskriminierung in den gilden! hobbits duerfen nicht
+in die chaosgilde. und selbst bei den kaempfern koennen sie nicht zum
+absoluten spezialist fuer zweihaendige schwerter werden.
+aber soll man deshalb fuer hobbits bessere messer machen?
+und fuer nicht-hobbits was damit sie mehr essen koennen?
+und fuer nicht-zwerge was zum mehr trinken?
+und fuer nicht-felinen was zum schneller kaempfen?
+...
+oder packen wir das problem besser an der wurzel und machen
+nur noch 1 rasse und nur 1 gilde, dann isses doch am gerechtesten, oder?
+am besten auch nur noch gleich starke (max!) waffen und ruestungen,
+dann bekommt niemand ne schlechtere als wer anderst.
+und level koennten wir auch noch abschaffen.
+
+denk mal drueber nach wovon du redest, Roland!
+das sms (einheits-waffe?) wurde nicht nur fuer menschen/kaempfer
+abgewertet, und das nicht ohne grund. so nebenbei angemerkt, es gibt
+auch andere (sehr) gute waffen (nicht nur schwerter). und fuer die,
+denen zB messer (die naturgemaess weniger schaden machen) besonders
+liegen gibt es sehr wohl nen ausgleich. aber alle gleich machen zu wollen
+ist wie oben demonstriert schwachsinn.
+
+Pardauz, weiss auch nix neues, aber fuer manche muss man scheinbar
+         bekannte Weisheiten wiederholen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Schwertmeisterschwert (Vector, 19. Jun 2001, 13:11:41):
+~#! rn=Solmyr rt=992675913 rg=balance
+~#! tid=989966916
+Hi Solmyr,
+
+vielleicht weisst du ja nicht, das solche Abwertungen in erster Linie
+die 'kleinen unter den grossen treffen'. Einem Matis/Sky (um bei deinen
+Beispielen zu bleiben) ist so eine Abwertung so ziemlich schnurz. Schonmal
+aufgefallen, dass sich keiner der sehr-hoch-leveligen-Spieler wirklich
+beschwert hat? Nun woran liegt das? Es ist halt so, dass sehr sehr viele
+Gegenstaende sehr stark sind, wenn man eine gewisse Level erreicht hat.
+(Vor allem bei Kaempfern). Das waere mal ne Sache, wo man sich ne Aenderung
+ueberlegen muesste. Sicher wird es jetzt NICHT zur 'level-aufholjagd'
+kommen.
+
+--Vector--
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Schwertmeisterschwert (Solmyr, 19. Jun 2001, 13:51:40):
+~#! rn=Vector rt=992949101 rg=balance
+~#! tid=989966916
+Hallo Vector,
+
+ich weiss mit Sicherheit, dass Abwertungen meist die Seher treffen, die
+grade auf "dem Weg nach oben" sind. Haettest Du diesen (zugegeben im
+Suff nach der Arbeit) entstandenen Artikel richtig gelesen, waere Dir
+wohl auch aufgefallen, dass nur mit Hilfe dieses 'KickAss-Satzes an
+Ausruestung' die Aufholjagd moeglich gewesen waere. Ich glaub da ist
+uns're Meinung nicht verschieden, aber die Auffassungsgabe schon eher.
+
+Wir koennen ja aber mal schaun, wie schnell ich 'nen Charakter in
+hoehere Gefilde spielen kann, ab 25.6. ist ja das DSL-Zeitalter bei
+mir angebrochen und als "Sozialschmarotzer" (so haben mich doch tat-
+saechlich Leute bezeichnet *huepf*) viel Zeit hat.
+Nur am Rande, wenn ich den leicht missfallenden Unterton richtig ver-
+standen habe, lege ich Dir neben dem schon bestehenden 'ignoriere
+Solmyr' auch ein 'ignoriere solmyr.news' waermstens ans Herz.
+
+Liebe Gruesse
+Solmyr
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Schwertmeisterschwert (Sky, 19. Jun 2001, 22:00:41):
+~#! rn=Vector rt=992949101 rg=balance
+~#! tid=989966916
+
+
+Hi,
+
+>Schonmal aufgefallen, dass sich keiner der sehr-hoch-leveligen-
+>Spieler wirklich beschwert hat? 
+
+Naja, koennte daran liegen, dass diese verstanden haben, dass bisher im
+MG noch nie (zumindest meines Wissens nach nicht :)) irgend eine Aenderung
+wieder rueckgaenig gemacht wurde, nur weil sich Leute beschwerten.
+
+Allen kann man es (leider) nie recht machen, es gibt immer welche denen der
+neue Zustand nicht passt ("Frueher war alles besser *flenn*").
+
+Gut, dass so feine Saechelchen wie Vampirschwert oder Todesritterschwert nun
+nicht mehr die gewohnte "Trefferquote" haben ist natuerlich erstmal ein wenig
+aergerlich, laesst sich aber kaum aendern. Da auch weitere Entwicklungen nie
+zu 100% voraussagbar werden muss man eben alte Sachen laufend anpassen, bzw.
+abwerten. Ob es nun Waffen, Ruestungen, Tank-, Punkte- oder Kampfsysteme sind,
+alles ist einem stetigen Wandel unterworfen. Beispielsweise gilt Paracelsus' 
+Eisspeer als momentan noch sehr unereichbar und der Aufwand und das Risiko den
+ueberhaupt zu haben, duerfte auch seine momentane Staerke rechtfertigen (btw. 
+ist der eingentlich abgewertet? :)). In dem Moment wo aber scharenweise
+Spieler 
+dahin pilgern und sich das Teil jeden Reset holen muss man eben eingreifen, 
+sprich abwerten.
+
+Frueher war es ein mittelgrosses Abenteuer um ein Blutsaugerschwert oder ein 
+Diamantschwert zu bekommen, heute wollen sowas nicht mal mehr Stufe 25 Spieler
+:)
+
+Das SMS beispielsweise haette man auf mehrere Arten _aendern_ koennen, dass 
+daraus eine Abwertung wurde, die alle betrifft ist natuerlich bedauerlich und
+war wohl etwas vorschnell.......
+
+Sky, Aenderungen hinnehmend und froehlich weiterspielend.
+
+P.S.: Trotzdem werde ich ab und an meinen Senf dazugeben :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: auch mal was zum sms sagen will (Devilchen,  7. Jul 2001, 15:36:09):
+~#! rn=Anacrion rt=992891604 rg=balance
+~#! tid=992886141
+Danke Anac*, schoen zu wissen, dass man noch nicht ganz in Vergessenheit
+geraten ist;)
+
+-----------------------------------------------------------------------------
+
+
+
+Abwertungen ... (Hirudo, 31. Jul 2001, 20:44:38):
+mal ganz ketzerisch gefragt:
+
+wenn es die menschenkaempfer ein weiteres mal getroffen hat, wann werden dann
+mal ein paar aexte und speere abgehangen?
+
+Hirduo eh nicht mehr spielend ...
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Abwertungen ... (Pitfall, 31. Jul 2001, 20:46:21):
+~#! rn=Hirudo rt=996605078 rg=balance
+~#! tid=996605078
+das ist nicht die frage,
+aber jetzt werden natuerlich alle magier anfangen anstaendige schwerter zu
+progegn ist doch klar *huestel*
+
+pit* -ernsthaft gruebelnd-
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Abwertungen ... (Gor, 31. Jul 2001, 20:47:27):
+~#! rn=Hirudo rt=996605078 rg=balance
+~#! tid=996605078
+Als eingefleischter Sperkaempfer kann ich dir versichern, das es lange nicht
+so schoene und vom Schaden so Hohe Speere gibt wie Aexte. ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Abwertungen ... (Hirudo, 31. Jul 2001, 20:57:25):
+~#! rn=Gor rt=996605247 rg=balance
+~#! tid=996605078
+soll ich mal lachen?!?!?!?
+du willst jetzt nicht wirklich die kampfkraft von elfen oder zwergen mit
+menschen vergleichen, oder?
+
+Hirudo kopfschuettelnd
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Abwertungen ... (Gor, 31. Jul 2001, 20:58:54):
+~#! rn=Hirudo rt=996605845 rg=balance
+~#! tid=996605078
+Spiel nen Kaempferelf und du lernst seine Tuecken kennen. Aber schade is nur,m
+das alle nur sehen, welchen Dam sie machen. Temporaer.... aber bist ja Magier
+schaus dir einfach an undurteile dann nochmal. Weiser..
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Abwertungen ... (Pitfall, 31. Jul 2001, 20:59:22):
+~#! rn=Gor rt=996605934 rg=balance
+~#! tid=996605078
+setz mir P_RACE auf elf und ich spiel den sofort :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Und wieder ein bischen weniger.... (Gnome, 31. Jul 2001, 21:01:18):
+~#! rn=Morgoth rt=996577173 rg=d.vland
+~#! tid=996577173
+gibt es dafuer auch noch eine begruendung von offizieller seite?
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Und wieder ein bischen weniger.... (Croft, 31. Jul 2001, 22:45:42):
+~#! rn=Gnome rt=996606078 rg=balance
+~#! tid=996577173
+Rein interessemaessig: wieso abhaengen und nicht abwerten?
+Gruss Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Und wieder ein bischen weniger.... (Karis, 31. Jul 2001, 22:49:17):
+~#! rn=Gnome rt=996606078 rg=balance
+~#! tid=996577173
+Ja, eine kleine Erklaerung... aber wie immer werden wohl alle
+die, die nach mehr Transparenz rufen (ja, hier, ich!) wieder
+enttaeuscht werden. Oder doch nicht? Morgoths Job wirds wohl net
+sein... also, wer sagt mal was? Oder duerfen wir uns wieder mal
+unseren Teil denken?
+
+Karis
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Und wieder ein bischen weniger.... (Patryn, 31. Jul 2001, 22:51:28):
+~#! rn=Karis rt=996612557 rg=balance
+~#! tid=996577173
+ihr solltet alle ne runde baden gehen, in der schoenen sonne draussen in
+einem tollen freibad. aber nicht die kopfbedeckung der wahl vergessen,
+sonst wirds noch schlimmer :)
+
+--
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Und wieder ein bischen weniger.... (Karis, 31. Jul 2001, 23:01:28):
+~#! rn=Karis rt=996612557 rg=balance
+~#! tid=996577173
+Ich wusste es....
+Gestatten Sie mir nur eine kleine Anmerkung, Herr Patryn. Das da oben
+ist nicht die Sonne, sondern der Mond. 
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Und wieder ein bischen weniger.... (Bielefeld, 31. Jul 2001, 23:02:02):
+~#! rn=Karis rt=996613288 rg=balance
+~#! tid=996577173
+Komisch, ich sehe nur eine Decke, die mal wieder gestrichen
+werden muesste...
+
+-Bielefeld (muddet selten unter freiem Himmel)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Und wieder ein bischen weniger.... (Patryn, 31. Jul 2001, 23:04:06):
+~#! rn=Karis rt=996613288 rg=balance
+~#! tid=996577173
+oh, ich vergass zu erwaehnen, dass die sonne nachts nicht scheint...das
+sollte hier im mud natuerlich dazugeschrieben werden ;)
+
+--
+herr patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Und wieder ein bischen weniger.... (Bambi, 31. Jul 2001, 23:48:06):
+~#! rn=Karis rt=996612557 rg=balance
+~#! tid=996577173
+Die erste Balance fuer einen Magier ist der gesunde Menschenverstand und ein
+Auge fuer das richtige Mass.
+Die zweite Balance ist der RM, in dessen Gebiet das Zeug angeschlossen werden
+soll.
+Der sollte seine eigene erste Balance einschalten.
+Dummerweise fehlen bei einigen Magiern ab und zu die ersten beiden
+(inoffiziellen) Balancen und dann muss halt die dritte (offizielle) Balance
+eingreifen und nachregulieren.
+Das ist zwar keine offizielle Begruendung (die kann ich naemlich nicht geben),
+aber ein Anhaltspunkt dafuer, wo man anfangen koennte, nach den Gruenden zu
+suchen, die eventuell zum Abhaengen des betreffenden Objekts gefuehrt haben.
+Wenn das stimmt, was mir einige Spieler erzaehlt haben, dann wuesste ich
+gerne, was ich denn ueberhaupt an Waffen noch anschliessen soll, dass sich das
+jemand ausser zum verkaufen noch holt.
+Jammert bloss ned rum, wenn euch Sachen weggenommen werden, die man eher als
+Testspielerausruestung durchgehen lassen koennte, anstatt als Belohnung fuer
+irgendeine (spieltechnische) Heldentat.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Anpassung Elementarschwert/-schild (Morgoth,  1. Aug 2001, 08:33:17):
+~#! rn=Anatol rt=996618996 rg=balance.bekanntmachungen
+~#! tid=996618996
+Hey, lass mich raten, es geht dem Todesritterschwert an den Kragen?
+
+Morgoth...sieht die Leute schon wieder fuer das Blutsaugerschwert schlange
+stehen 
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Anpassung Elementarschwert/-schild (Grimmborn,  1. Aug 2001, 08:38:15):
+~#! rn=Morgoth rt=996647597 rg=balance
+~#! tid=996618996
+In meiner Jugend (als das BSS tatsaechlich die Nonplusultrawaffe war) stand
+man weniger fuer das Schwert als vielmehr fuer den verdammten Ast Schlange.
+Und "script" bedeutete dass man eine Befehlsfolge per cut&paste in das
+telnet-Fenster geschoben hat. Ach ja, lang ists her...
+
+Grimmborn der Atheist
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Anpassung Elementarschwert/-schild (Varlarion,  1. Aug 2001, 10:36:27):
+~#! rn=Anatol rt=996618996 rg=balance.bekanntmachungen
+~#! tid=996618996
+Ist ja schoen und gut, dass hier angemerkt wird, dass die ach so armen
+menschlichen Trves mal wieder unter der Abwertung - aeh, ich korrigiere mich -
+Anpassung zu leiden haben, nur wird dabei mal wieder vergessen, dass ein Trves
+mit einem beliebigen Schwert schon in der Lage ist, gut auszuteilen, - ja,
+vermutlich macht er viel weniger Schaden, als mit einem Schwert, welches von
+den Schadensarten zu den Empfindlichkeiten des jeweiligen Gegners passt -
+wohingegen wir Chaoten nicht nur mit der Waffe so gut wie keinen Schaden
+machen, sondern obendrein unser Chaosball massiv geschwaecht wird, wenn die
+entsprechende Schadensart nicht von der Waffe unterstuetzt wird.
+Dass die sogenannten "Allround-Objekte" wegfallen kann ich persoenlich zwar
+auch nur begruessen, aber es waere sehr zu begruessen, wenn in absehbarer Zeit
+Ersatz in Form von "normalen" Waffen mit entsprechenden Schadensarten
+(Saeureschwert - Schnitt- und Saeureschaden?) geschaffen wuerde, wie es auch
+bei den Speeren (die meist zweihaendig und von daher fuer Chaoten relativ
+unbrauchbar sind) geschehen ist.
+Um es noch einmal deutlich hervorzuheben:
+Ich moechte mit diesem Artikel _nicht_ gegen die Arbeit der Balance hetzen,
+die ich respektiere, sondern die Magier dazu aufrufen, fuer entsprechenden
+Ersatz zu sorgen. Ich kenne beispielsweise an Waffen mit dem Schadenstyp
+Saeure einen Dolch, eine Axt und einen Speer, aber ausser dem Elementarschwert
+eben kein Schwert. Ebenso verhaelt es sich mit anderen Schadensarten, zB
+Feuer, Blitz und Luft. Zwar sind mir die Zweihaender aus der SSP durchaus
+bekannt, doch als Zweihaender eben fuer mich unbrauchbar und entsprechende
+Einhandwaffen, zB Dolche, machen ohne entsprechenden Waffenskill nunmal nur
+vernachlaessigbaren Schaden.
+Die Beispiele, die ich hier aufgefuehrt habe, waren uebrigens jeweils das
+Erste, was mir so in den Kopf kam, es gibt vielleicht vereinzelte Waffen, die
+den Kriterien entsprechen und mit denen ein Chaot trotzdem mehr als kratzt.
+Dennoch hoffe, ich, dass durch die Beispiele klar geworden ist, was ich
+ausdruecken wollte.
+
+Varl*, Chaot, _kein_ Trves
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Anpassung Elementarschwert/-schild (Orktoeter,  1. Aug 2001, 10:47:55):
+~#! rn=Morgoth rt=996647597 rg=balance
+~#! tid=996618996
+1. Wurde das Todesritterschwert nicht schon ueberarbeitet?
+
+2. Wenn schon Balance dann wird auch keiner mehr fuer das BSS Schlange stehen,
+weder beim Ast noch beim Vampir, denn dann wird auch das auf den hoechsten
+Schaden fuer eine Einhandwaffe gestutzt werden muessen.
+
+OrkT, generell fuer eine Balance.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Anpassung Elementarschwert/-schild (Grimmborn,  1. Aug 2001, 11:09:03):
+~#! rn=Orktoeter rt=996655675 rg=balance
+~#! tid=996618996
+> denn dann wird auch das [BSS] auf den hoechsten Schaden fuer eine 
+> Einhandwaffe gestutzt werden muessen.
+
+Mir bricht das Herz. Immerhin habe ich jetzt verstanden worueber hier soviel
+gejammert wird: Objekte werden auf den Maximalwert zurueckgestuft. Na dann,
+das ist doch wenigstens mal ein nachvollziehbarer Grund...
+
+Grimmborn der Atheist
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Anpassung Elementarschwert/-schild (Orktoeter,  1. Aug 2001, 11:48:38):
+~#! rn=Grimmborn rt=996656943 rg=balance
+~#! tid=996618996
+Grim* Ich habe das Erwaehnt um zu zeigen das es schonseit ewigen Zeiten
+Objekte gab, die ausserhalb der erlaubten Werte lagen. 
+
+OrkT.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Anpassung Elementarschwert/-schild (Ark,  1. Aug 2001, 11:49:46):
+~#! rn=Orktoeter rt=996659318 rg=balance
+~#! tid=996618996
+Und eben dafuer gibt es eine Balance, die solche genehmigt oder ablehnt, also
+ueber die Ausnahmen entscheidet. Warum sollten also jetzt die Objekte
+"zurueckgestuft" werden, verstehe ich nicht.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Anpassung Elementarschwert/-schild (Orktoeter,  1. Aug 2001, 11:52:58):
+~#! rn=Ark rt=996659386 rg=balance
+~#! tid=996618996
+Aeh Ark sorry, aber ich versteh dich nicht. Objekte wie das BSS die ueber dem
+Maxwert fuer eine Einhandwaffe liegen gibt es schon seit ewigen Zeiten. Die
+Balance gibt es bei weitem nicht so lange. Und es sind auch bei weitem nach
+der Gruendung der Balance nicht alle neuen Objekte der Balance vorgelegt
+worden. Also ist es doch voellig normal, das die Balance taetig wird, wenn
+sich zeigt das ein Objekt zu maechtig ist. Das gilt sogar fuer urspruenglich
+so genehmigte Objekte, wenn sich im Nachhinein heraustellt das die zu stark
+sind.
+
+OrkT.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Anpassung Elementarschwert/-schild (Ark,  1. Aug 2001, 12:04:58):
+~#! rn=Orktoeter rt=996659578 rg=balance
+~#! tid=996618996
+Ok, dann liegt es also an unserer Initiative. Lassen wir das BSS also nochmal
+durch die Balance. Von selbst wird die Balance nicht zigtausend Items anfassen
+und gleichzeitig alle neuen bearbeiten. Kapazitaetsfrage. Was ist uns wichtig?
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Anpassung Elementarschwert/-schild (Padreic,  1. Aug 2001, 12:17:16):
+~#! rn=Ark rt=996659386 rg=balance
+~#! tid=996618996
+Genau das ist der springende Punkt Ark. Es geht nicht mehr um eine
+Objektbalance die fuer die Genehmigung von Objekten zustaendig ist und nur
+einschreitet wenn Objekte das "Gleichgewicht empfindlich stoeren".
+Natuerlich kann es passieren, dass sich die Balance mal irrt und sich ein
+Gegenstand als zu stark herrausstellt bzw. eine Waffe wie das SMS nicht mehr
+wie frueher, nur von einigen Topsehern, sondern inzwischen von nahezu allen
+Spielern benutzt wird. Genauso natuerlich hat die Balance dann das Recht und
+die Pflicht diese Objekte wieder zurueck in ein fuer das Spiel akzeptablen
+Rahmen zu fuehren. Was jedoch nicht passieren darf, im Fall von
+Elementarschwert und Runenschwertern aber gerade passiert ist, das die Balance
+das ganze Mud nach ihren persoenlichen Vorstellungen neu anpassen will. Dieses
+bedeutet naemlich, dass jeder Wechsel im Balanceteam dazu fuehrt, dass ueber
+saemtliche strittigen Antraege jedesmal neu diskutiert wird und Magier
+ueberhaupt keine Arbeitsgrundlage mehr haben. Wenn sich an der Faktenlage auf
+deren Grundlage eine Genehmigung ergangen ist nichts geaendert hat, dann muss
+diese auch Bestand haben.
+In meinen Augen hat sich das Balanceteam als ganzes, gegenseitig in etwas
+hineingesteigert und was derzeit unter dem Namen "Balance" betrieben wird, hat
+mit einer Genehmigungsinstanz fuer Objekte nicht mehr viel gemeinsam. Das
+MorgenGrauen ist meiner Meinung nach derzeit nicht Rettungsbeduerftig.
+Gutgemeint ist leider oft das Gegenteil von gut und die Balance ist in meinen
+Augen dabei, dem Mud nicht zu helfen, sondern ihm sehr schweren Schaden
+zuzufuegen. Ich als Magier sehe mich zumindest meiner Arbeitsgrundlage
+entzogen, wenn ich zwei Jahre lang an einer neuen Gilde arbeite (und dies auch
+allgemein bekannt ist) und dann nach zwei Jahren, wenn die Arbeit getan ist,
+die Balance das wesentliche Objekt kastrieren will. Und zwar nicht weil sich
+an der Sachlage etwas geaendert hat, sondern nur weil sich die
+Mehrheitsverhaeltnisse in der Balance veraendert haben.
+
+
+Pad*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Anpassung Elementarschwert/-schild (Boing,  1. Aug 2001, 12:26:09):
+~#! rn=Orktoeter rt=996659578 rg=balance
+~#! tid=996618996
+Du taeuscht Dich, die Balance gibt es seit dem ersten Tag. Was es erst seit
+einigen Jahren gibt, ist das Balance-Team! Vorher wurde die Aufgabe immer
+von einer einzelnen Person uebernommen.
+  Boing
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Anpassung Elementarschwert/-schild (Gor,  1. Aug 2001, 13:21:58):
+~#! rn=Orktoeter rt=996659318 rg=balance
+~#! tid=996618996
+Hmm also erlaubt hin oder her, fuer das BSS wurde die Mudlib nicht geaendert,
+da bin ich mir sicher und die erlaubten Werte werden sicherlich nicht
+ueberschritten. Es ist lediglich eine Sache des Verhandlungsgeschicks, wenn
+man eine Waffe mit hoerheren Werten haben moechte. Das einzige Objekt, was
+weit darueber lag (auch ueber den Mudliberlaubten Maxwerten) war das SMS. Erst
+informieren, dann kraehen......
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Anpassung Elementarschwert/-schild (Tektuko,  1. Aug 2001, 13:38:49):
+~#! rn=Gor rt=996664918 rg=balance
+~#! tid=996618996
+Nur mal interessenhalber: Was fuer Abwertungen stehn den noch an?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Anpassung Elementarschwert/-schild (Montanus,  1. Aug 2001, 16:59:28):
+~#! rn=Tektuko rt=996665929 rg=balance
+~#! tid=996618996
+Aus gut informierten Kreisen war zu hoeren, dass weitaus mehr Objekte "unik"
+gemacht werden sollen, also nur noch in sehr begrenzter Stueckzahl im Mud
+existieren werden. 
+Auch eine Art, die Ruestungsspirale etwas zu stoppen... wenn auch dann viel
+mehr Leute sich einen eboot/Crash herbeiwuenschen werden, wenn sie gerade mal
+nicht ihre Lieblingswaffen/Ausruestungen bekommen haben.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Anpassung Elementarschwert/-schild (Grimmborn,  1. Aug 2001, 17:07:29):
+~#! rn=Montanus rt=996677968 rg=balance
+~#! tid=996618996
+Persoenlich wuerde ich vorschlagen die MPA zu begrenzen. Wenn die nur so
+zehnmal im Spielerbereich auftaucht sollte das einen wohltuenden Effekt aufs
+gesamte MG ausueben koennen...
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Anpassung Elementarschwert/-schild (Montanus,  1. Aug 2001, 17:09:25):
+~#! rn=Grimmborn rt=996678449 rg=balance
+~#! tid=996618996
+du weichst vom Thread ab. Orktoeter wird Dich dafuer hassen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Anpassung Elementarschwert/-schild (Grimmborn,  1. Aug 2001, 17:10:58):
+~#! rn=Montanus rt=996678565 rg=balance
+~#! tid=996618996
+Dafuer auch noch? Ach Du meine Guete...
+
+GdA wartet auf das teile mit "Das gehoert da nicht hin, verleg das nach
+schmarrn)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Anpassung Elementarschwert/-schild (Nachtwind,  1. Aug 2001, 17:15:45):
+~#! rn=Montanus rt=996677968 rg=balance
+~#! tid=996618996
+Vermutlich bin ich dann nicht mit den richtig gut informierten Kreisen
+in Kontakt, aber das hoere ich zum ersten Mal. Im Gegenteil, das was Du
+beschreibst, naemlich die einmalige Vergabe von Objekten pro Uptime, wird
+vehement bekaempft. An etlichen Stellen wurde das durch ein Rotationsprinzip
+ersetzt, das potentiell jedem ermoeglicht, auch waehrend einer uptime
+an ein bestimmtes Objekt zu kommen.
+
+Nachtwind.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Anpassung Elementarschwert/-schild (Boing,  1. Aug 2001, 17:23:08):
+~#! rn=Nachtwind rt=996678945 rg=balance
+~#! tid=996618996
+Und ja: Meine Steine dahingehend zu aendern ist ein DICKER Punkt auf 
+meiner Todo-Liste ... wenn ich nur mal die Zeit finden wuerde ... :(
+  Boing
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Anpassung Elementarschwert/-schild (Zook,  1. Aug 2001, 17:25:53):
+~#! rn=Boing rt=996679388 rg=balance
+~#! tid=996618996
+XXX teilt Dir mit: hihi, die steine rotieren doch jetzt auch
+XXX teilt Dir mit: schon. man muss nur in den richtigen
+XXX teilt Dir mit: seherhaeusern erlaubt sein ;-)
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Anpassung Elementarschwert/-schild (Wurzel,  1. Aug 2001, 17:58:45):
+~#! rn=Zook rt=996679553 rg=balance
+~#! tid=996618996
+es ist halt wie im richtigen leben. vitamin b ist entscheidend, auch wenn
+newcomer es dann eben extrem schwer haben. kurz: pech gehabt.
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Anpassung Elementarschwert/-schild (Hirudo,  1. Aug 2001, 18:44:04):
+~#! rn=Wurzel rt=996681525 rg=balance
+~#! tid=996618996
+ich hab mal nen gespraech mit der balance gesucht und einige erklaerungen
+gefunden.
+kurze zusammenfassung:
+h: wieso nicht nur das wandelbare kastrieren?
+b: weil dann trotzdem alle schadensarten zentral an einer stelle des muds
+verfuegbar waeren, wenn auch nur zufaellig.
+
+fazit:
+wir magier sind aufgefordert, aehnliche schwerter, wie das eleschwert, zu
+proggen. dann muss man sich wieder mehr auskennen und diverse orte des mgs
+besuchen, damit man die bisherige vielfalt wieder hat.
+
+an die spieler also der apell, wendet euch an einen magier eures vertrauens
+und schlagt ihm objekte vor, die ihr vermisst.
+
+hirudo jetzt verstehend.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Anpassung Elementarschwert/-schild (Patryn,  1. Aug 2001, 18:52:32):
+~#! rn=Hirudo rt=996684244 rg=balance
+~#! tid=996618996
+du verwirrst mich jetzt total...ich hasse informationen aus zweiter hand ;)
+
+-- 
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Anpassung Elementarschwert/-schild (Hight,  1. Aug 2001, 22:59:35):
+~#! rn=Wurzel rt=996681525 rg=balance
+~#! tid=996618996
+hmmm die steine sind so und so items die n newcommer kaum zu fassen bekommt
+... die dinger kann man sich nicht ohne weiteres holen -> man is immer mit nem
+team unterwegs ohne vorherige anmeldung is die warscheinlichkeit fuer nen nen
+newcommer recht gering das er den stein mal erwischt
+
+hight
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Anpassung Elementarschwert/-schild (Terrorist,  2. Aug 2001, 18:55:58):
+~#! rn=Montanus rt=996677968 rg=balance
+~#! tid=996618996
+Aber da wir ja in einem Multi User Dungeon sind sollte man sich bei unique
+Waffen vielleicht auch austauschen koennen :)
+Klappt(e) bei Mjoelnir ja auch recht gut.
+
+TERROR*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Anpassung Elementarschwert/-schild (Gloinson,  2. Aug 2001, 18:59:01):
+~#! rn=Terrorist rt=996771358 rg=balance
+~#! tid=996618996
+Naja, beschraenkt. Solange es Leute gab die den dauerhaft verwalteten ja.
+
+Gloin(son)
+
+-----------------------------------------------------------------------------
+
+
+
+rueckzug (Kieselstein,  5. Aug 2001, 22:56:12):
+Hiho allerseits
+Da mir die momentane Situation, was die Balance betrifft, mir doch entschieden
+zuviel aufm zeiger geht, werdet Ihr wohl ne weile ohne mich auskommen muessen.
+Das wird wohl nicht unbedingt ein grosser Verlust sein, gibt ja noch viele
+andere, aber mein hohles Hirn kann einfach den Verlust des Spielspasses nicht
+laenger verkraften.
+Macht was Ihr wollt, macht ihr ja sowieso, aber ohne mich!
+
+Gruss Kieselstein
+
+Ps:
+Ab und zu werde ich noch mal reinschauen, vielleicht bringt Darki mehr Licht
+in die Sache. (Licht = Spielspass)
+Ich bin uebrigens sicher das ich nicht der Einzige bin, der Spielspass anders
+definiert ...
+
+...Und Tschuess !
+
+Kiesel
+
+-----------------------------------------------------------------------------
+
+
+
+keine ahnung (Patryn,  5. Aug 2001, 23:08:36):
+also ehe sich hier noch mehr zum selbsternannten maertyrer aufschwingen,
+will ich der balance nur mal sagen: weiter so!
+wer mich kennt weiss durchaus, dass das nix mit schleimerei zu tun hat,
+sondern dass ich die notwendigkeit einfach mal sehe.
+nich nur die verschobenen kraefteverhaeltnisse sondern auch die langen
+uptimes zwingen nun einmal zu gewissen ueberpruefungen.
+
+-- 
+patrym ausnahmsweise lobend ;)
+
+-----------------------------------------------------------------------------
+
+
+
+och mensch  (Roland,  5. Aug 2001, 23:10:11):
+Also wenn schon gegenden auf unbestimmt abgehaengt werden .. dann solte man
+wenighstens drauf auchten das die zugehoerigen zt's auch abgeschaltet werden
+... 
+das find ich naemlich net lustig ... bekommt man n zt und stampft gerade wegs
+da hin wo man nen tipp bekommen hat .. und dann sowas ... 
+
+*grummel roland
+
+-----------------------------------------------------------------------------
+
+
+
+Re: och mensch  (Orktoeter,  5. Aug 2001, 23:12:03):
+~#! rn=Roland rt=997045811 rg=balance
+~#! tid=997045811
+Es gibt 4 ZT mehr als du fuer volle Stats brauchst. 
+Ausserdem wird die Gegend entweder in absehbarere Zeit wieder angeschlossen
+oder der ZT wird schon noch verlegt werden. Nur keine Panik deswegen.
+
+OrkT.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: keine ahnung (Gandur,  5. Aug 2001, 23:21:31):
+~#! rn=Patryn rt=997045716 rg=balance
+~#! tid=997045716
+tja, die verschobenen kraefteverhaeltnisse ... nur mal so, wie waere
+es denn alle ek's und skills bei allen auf 0 zurueckzusetzen? wuerde
+eine chancengleichheit zwischen alten und neuen charakteren schaffen.
+die bugs und unbalancierten items waren ja wohl zahlreich und nun
+wird ja alles besser ...
+
+provokant, gandur
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: keine ahnung (Patryn,  5. Aug 2001, 23:23:07):
+~#! rn=Gandur rt=997046491 rg=balance
+~#! tid=997045716
+mit verschobenen kraefteverhaeltnissen meine ich, dass es heut vielfach
+zu leicht ist, bestimmte aeltere tools zu ergattern, die dort einfach
+superschwer zu bekommen waren. zusammen mit den langen uptimes ist das ein
+schlechter mix...
+
+-- 
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re: rueckzug (Gloinson,  6. Aug 2001, 10:51:03):
+~#! rn=Kieselstein rt=997044972 rg=balance
+~#! tid=997044972
+Da hat wohl jemand vergesse wie das das mit "mail freunde" genau funktioniert.
+
+Gloin(son) wuenscht trotzdem geruhsame Ferien vom MUD
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: keine ahnung (Hight,  6. Aug 2001, 12:31:34):
+~#! rn=Gandur rt=997046491 rg=balance
+~#! tid=997045716
+waffenschaerfen hat das mit chancengleichheit zutun ?
+
+wenn du etz bei allen spielen die ek's auf null setzt fuehrt das dazu das die
+etwas aelternen und lvl technisch hoeheren spieler den neueren die ganzen
+npc'S (incl. quest npc's ... ich kenn da nix) wegkloppen und sich die
+"kleinen" aufregen weil nix laeuft wie sie es wollen.
+das ganze wuerde dazu fuehren das alles die skill neu hochscriptet und
+hinterher die npc's verdrischt die ek's geben. du kannst ja schlecht den
+spielern das wissen ausm hirn nehmen
+
+Yt Hight
+
+-----------------------------------------------------------------------------
+
+
+
+konstruktiver Vorschlag (Tsunami,  6. Aug 2001, 23:47:37):
+Hallihallo, Tsunami hier.
+
+Das wichtigste mal vorweg: eine Balance ist absolut notwendig, das sollte
+wohl jeder einsehen. Ansonsten ufert die Ruestungsspirale ins Grenzenlose
+(ja, ich bin da auch mitschuldig) und wir haben den Salat. Und genau das
+ist ueber die Jahre mit dem MG passiert. 
+
+Die Balance-Richtlinien wie auch die Leute dahinter haben mehrmals
+gewechselt. Sachen, die vor ein paar Jahren noch bewilligt wurden, muessen
+heute ueberarbeitet werden. Das wirft natuerlich die Frage auf, was ein OK
+der heutigen Balance in ein paar Jahren bedeutet - und was in OK der
+damaligen Balance heute bedeutet...
+
+Die radikalste, am meisten Arbeit erzeugende, wohl aber auch die sauberste
+Loesung fuer die ich plaediere, ist folgende: Tabula rasa! 
+
+Schritt I:
+
+Es werden noch klarere Richtlinien entworfen, was erlaubt ist und was nicht.
+Das dies kein einfaches Unterfangen ist, ist mir durchaus bewusst. Jedoch
+sollte dieses Kompendium danach wirklich der heilige Gral sein, auf den man
+sich auch spaeter berufen kann. Ist ein Objekt nach diesen Richtlinien
+bewilligt worden, soll das seine Gueltigkeit auch nach Jahren und einer
+neuen Balance-Besetzung haben. 
+
+Festhalten, nun wirds noch aufwaendiger:
+
+Schritt II:
+
+Alle Waffen/Ruestungen/Objekte muessen danach entsprechend dieser
+Richtlinien neu bewertet und gegebenenfalls geaendert werden. Hier sind
+dann vor allem die Regionsmagier gefragt, da ja viele der angeschlossenen
+Sachen nicht mehr von den urspruenglichen Magiern gewartet werden. 
+Das wird wohl auch die NPCs beinhalten, die diese Objekte mit sich tragen.
+Ich weiss, das wuerde ein gewaltiges Unterfangen geben.
+
+Mein wichtigster Vorschlag zur Objektueberarbeitung: magischer Schaden wird
+auf max. 1 pro Waffe beschraenkt. In ganz ganz seltenen Ausnahmen 2 magische
+Schadensarten.
+
+Die Vielfalt wuerde hiermit wieder ungemein gesteigert, da man sich ein Set
+von Waffen besorgen muss anstatt die die ultimative Kann-Alles-Waffe.
+Anstatt in Gebiet X zu rennen und alles stupide niederzumaehen mit seiner
+super-alround Waffe (die es ebenfalls im gleichen Gebiet X zu holen gibt),
+ist dann wieder etwas Taktik gefragt. 
+
+Wichtige NPCs muessten gemaess dieses Konzepts ebenfalls (zumindest 
+Resistenzen-maessig) ueberarbeitet werden. Ich denke, auch die
+Zauberspruch-Gilden wuerden wohl von dieser Aenderung profitieren.
+
+Ich bin auf jeden Fall sofort bereit, meine Sachen gemaess diesen
+Vorschlaegen umzugestalten. *Wenn es mudweit gemacht wird.*
+
+Die andere Loesung waere: alles beim alten zu behalten. Was frueher in
+derjenigen Form bewilligt wurde, darf so angeschlossen bleiben. Die 
+Ruestungsspirale wird sich dann halt weiterdrehen...(in meinen Augen
+die schlechtere Loesung).
+
+Was meint ihr dazu? 
+
+"Tsunami ist doof und stinkt"-Artikel bitte direkt nach muell,
+ernstgemeinte Artikel willkommen.
+
+Tsunami.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: konstruktiver Vorschlag (Wurzel,  7. Aug 2001, 00:06:19):
+~#! rn=Tsunami rt=997134457 rg=balance
+~#! tid=997134457
+klare regelungen waeren etwas feines. insbesondere, weil dann jahrelange
+antragsorgien entfallen koennten. man koennte klare regeln zumindestens
+teilweise in die mudlib binden, dann braucht es keine genehmigungen mehr.
+natuerlich muessten diese regeln dann umfassend sein, denn die spirale kommt
+ja nicht davon, dass einmal genehmigte objekte immer besser werden, obwohl
+der code nicht mehr angefasst wird, sondern davon, dass die benutzer sich
+veraendern (sprich, die entsprechenden gildenfaehigkeiten). eine balance, die
+nur als objectbalance verstanden wird, ohne _gleichzeitig_ auch die gilden
+zu pruefen, ist eh zum scheitern verurteilt.
+und schon haben wir das problem. wer moechte denn bitteschoen ein umfassendes
+regelwerk aufstellen und damit noch in diesem jahrzehnt fertigwerden? da man
+ja die volle komplexitaet mit betrachten muss, die sich aus dem zusammenwirken
+von objekten und skills ergibt, wahrlich keine leichte aufgabe. demgegenueber
+ist die ueberarbeitung aller objekte fast schon vernachlaessigbar.
+ein erster schritt sollte meiner meinung nach sein, dass man object- und
+gildenbalance zusammenlegt. das wuerde sicherlich einiges vereinfachen. ein
+allheilmittel kann das aber auch nicht sein, bestenfalls werden dann gleiche
+massstaebe angelegt. nach dem, was ich beim lesen in manchen spellbooks
+mit erschrecken gesehen habe, hatte ich den starken eindruck, dass derzeit
+eine gildenbalance nicht stattfindet, ganz im gegensatz zu den objekten.
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: konstruktiver Vorschlag (Padreic,  7. Aug 2001, 09:30:38):
+~#! rn=Wurzel rt=997135579 rg=balance
+~#! tid=997134457
+Au Mann, also das mit dem Zusammenlegen von Objekt und Gildenbalance halte ich
+fuer die schlechteste Idee die ich hier bisher gehoert hab. Wenn _ein_
+faehiger Magier schon ewigkeiten braucht eine Gilde abzunehmen, wie lange soll
+die Gildenabnahme denn dann bei einem ganzen Team dauern? Mal abgesehn davon,
+das ich bezweifle, dass man ueberhaupt genug Leute findet, die ueberhaupt die
+programmiertechnischen Vorraussetzungen fuer eine Gildenbalance erfuellen.
+Ich bin ganz eindeutig _fuer_ verlaessliche Genehmigungen, jedoch gegen starre
+Richtlinien. Starre Richtlinien verallgemeinern immer sehr und es wird immer
+Dinge geben, die von ihnen _nicht_ abgedeckt werden.
+Umso groesser ein Mud wird, umso mehr Objekte wird es geben und dadurch
+natuerlich auch mehr spezial-Objekte die fuer ganz bestimmte Dinge halt sehr
+gut sind. Spieler die sich gut auskennen und viele dieser Objekte besitzen
+werden dadurch immer staerker werden. Es gibt daher genau zwei Moeglichkeiten:
+Entweder man schliesst keine neuen Objekte mehr an und beschraenkt sich aufs
+NPC/Bluemchen proggen, oder man hat ein staerker werden der Spieler. Wobei ich
+hier Ruestungsspirale fuer den falschen Ausdruck halte, da das staerker werden
+der Spieler immer spezieller wird und nicht weil sie ein neuSMS bekommen, was
+wirklich mehr (allgemeinen) Schaden macht.
+
+Pad*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: konstruktiver Vorschlag (Anacrion,  7. Aug 2001, 10:24:49):
+~#! rn=Padreic rt=997169438 rg=balance
+~#! tid=997134457
+Also man sollte an dieser Stelle zwischen Organisationsproblemen und objektiv
+(subjektiv?) richtigem unterscheiden ...
+
+Auch wenn unter den von Dir beschriebenen Praemissen, eine ZHusammenlegung der
+Balance chaotisch waere, werden mir wohl wenige im MG widersprechen, wenn ich
+sagre, dass man Gildenbalnce und Objektbalance strikt von einander getrennt
+nicht durchfuehren kann. Durch die Unterschiedlichkeit der Objekte sind manche
+Objekte IMHO halt nur fuer eine Gilde zu gut ode5er werden andere Gilden mit
+der Abwertung eines bestimmten Objektes empfindlich gesxchwaecht
+(unabsichtlich?), whrend man bei der Abwertung nur auf eine andere Gilde
+geachtet hatte ....
+
+Meiner bescheidenen Meinung nach sind die verschiedenen Balancearten genau wie
+die programmierenden MAgier alle Teile eines grossen Getriebes und wenn man an
+einer Stelle was verndert , kommt es an derer Stelle zu Vernderungen. Aus
+diesem Grund wrde ich eine Zusammenlegung ALLER Balancearten (inkl.
+NPC-Balance) befrworten.
+
+Man kann nmlich die Einstufung von NPC nicht vornehmen, ohne Gildenfhigkeiten
+und Objkete zu bercksichtigen, die dem Monster evtl. inSekunden den garaus
+machen. Ich sage an dieser Stelle nur 'alte Daemonenaxt in Daemoinenburg'.
+#
+Ein anderer Aspekt ist das von Dir angesprochene Organisationsproblem.  Und
+ja, ich gebe Dior recht, dass ein von Dir beschriebenes Chaos herauskommen
+KOENNTE, wenn man die Balance 'einfach so'  zusammenlegt ... Aber nun sind
+unsere Balanceleute ja nicht superweltfremd. Aber MEnschen - wie Du und ich.
+Ich glaubwe nicht, dass die Balance jemals fuer
+Supermegaduperwaffen/Ruestungen/Tools eine Lebenslange Bestandgarantie
+vergeben kann/will - und so etwas waere auch nciht im Interesse des MUDs.
+Ausserdem koennten sie ja etwas uebersehen haben und das Problem nicht erst
+spaeter bei der Einfuehrung einer Gilde X auftreten.
+
+Wenn die Mitglieder eines zusammengelegten Balanceteams (das waeren immerhin 3
+EM und ne Horde mudsuchtiger Spieler ( :;o) )  sich zusammensetzen und ein
+paar Standardrichtlienien ausknobeln und evtl. auch nen Prozess festlegen,
+nach dem ein Objekt genehmigt oder auch nicht wird (Quasi ISO9000), dann
+sollte eigentlich allen geholfen sein unddas von Dir beschriebene Chaos
+vermieden UND noch die geforderte Transparenz in die Black Box Balance
+einfliessen. - waere das nicht toll ?
+
+anac* (2dcentwerfend)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: konstruktiver Vorschlag (Matis,  7. Aug 2001, 10:53:05):
+~#! rn=Anacrion rt=997172689 rg=balance
+~#! tid=997134457
+Ich empfehle "hilfe balance". So sollte es allen moeglich sein alleine
+festzustellen, dass Nachtwind als EM fuer Gildenbalance auch Mitglied
+der Objektbalance ist. Und das ist uebrigens schon sehr lange so.
+
+Matis
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: konstruktiver Vorschlag (Patryn,  7. Aug 2001, 12:05:23):
+~#! rn=Wurzel rt=997135579 rg=balance
+~#! tid=997134457
+ich bin gegen ein zu starres regelwerk und fest verdrahtete
+08-15-wir-machen-es-uns-leicht-regeln. wen sich die balance alle
+jubeljahre mal aufrafft, auch noch mal alte objekte unter die lupe
+zu nehmen muss man deshalb nich son fass aufmachen.
+klar jammer auch ich rum, wenns was von mir erwischt, und ich bin sicher
+auch nich mit jeder aenderung 100%-ig einverstanden, aber deshalb kann
+man da trotzdem etwas entspannter rangehen und muss hier weder
+maertyrer-spieler noch eingeschnappt-magier spielen.
+
+-- 
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: konstruktiver Vorschlag (Patryn,  7. Aug 2001, 12:11:05):
+~#! rn=Anacrion rt=997172689 rg=balance
+~#! tid=997134457
+es ist illusorisch dass spieler gildenbalance in die hand nehmen koennten,
+wenn nich nur hoeren-sagen und mystische vermutungen die zukunft der
+gilde bestimmen sollen ist taschenrechner, code und statistik gefragt.
+
+-- 
+patryn
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Anpassung Elementarschwert/-schild (Gor,  8. Aug 2001, 14:22:15):
+~#! rn=Hight rt=996699575 rg=balance
+~#! tid=996618996
+Also wenn Newbies die nicht bekommen, warum hast du dann ab und an welche?
+;))))
+
+Gor -> schmarrn
+
+-----------------------------------------------------------------------------
+
+
+
+Re: konstruktiver Vorschlag (Gor,  8. Aug 2001, 14:27:41):
+~#! rn=Tsunami rt=997134457 rg=balance
+~#! tid=997134457
+So Set-Items like D2 find ich grundsaetzlich net schlecht aber die alten
+Sachen umzukrempeln halt ich fuer Bloedsinnig, da das Flair der Items ja auch
+entsprechend angepasst werden muss. LIeber neue Sachen und ..........
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Schlagring fuer Zauberer (Liara,  8. Aug 2001, 15:58:42):
+Die im Titel genannte Ausruestung gibt es ja nun bekannterweise in Deinem
+Gebiet.
+
+Wenn ich versuche, dort hinzugehen, dann bekomme ich eine Meldung von Dir,
+dass es abgehaengt wurde. Finde ich OK.
+
+Nun geruechtelt es aber ganz gewaltig, dass es noch andere Wege gibt, um in
+das Gebiet zu kommen. Wen willst Du eigentlich mit der Abhaengerei bestrafen?
+Die Zaubis, die an Deinen Sachen interessiert sind, aber nicht so viel
+geforscht oder gemauschelt haben, dass sie halt keine weiteren Wege kennen, um
+dort hinzugelangen?
+
+LZZ, sauer, falls diese Geruechtels zutreffen
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Schlagring fuer Zauberer (Liara,  8. Aug 2001, 16:08:36):
+~#! rn=Liara rt=997279122 rg=balance
+~#! tid=997279122
+Adressat des Artikels ist natuerlich Padreic.
+
+LZZ, hat den ersten Satz vergessen ;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Schlagring fuer Zauberer (Anacrion,  8. Aug 2001, 16:08:52):
+~#! rn=Liara rt=997279716 rg=balance
+~#! tid=997279122
+Ne, echt ?
+
+anac*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Schlagring fuer Zauberer (Bielefeld,  8. Aug 2001, 16:11:44):
+~#! rn=Anacrion rt=997279732 rg=balance
+~#! tid=997279122
+Dein Freund Anacrion teilt Dir mit: hehe. wer braucht noch megaschmarrn
+
+q.e.d.
+
+-Bielefeld
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Schlagring fuer Zauberer (Wurzel,  8. Aug 2001, 16:12:20):
+~#! rn=Bielefeld rt=997279904 rg=balance
+~#! tid=997279122
+megaschmarrn ist ueberall.
+
+wurzel
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Schlagring fuer Zauberer (Padreic,  8. Aug 2001, 16:12:44):
+~#! rn=Liara rt=997279122 rg=balance
+~#! tid=997279122
+Es gab wohl noch irgendwo in Gebieten von _anderen_ Magiern Teleports in ein
+Feld hinter die Absperrung und dieses wurde von ein paar Spielern ausgenutzt
+(ich meine drei). Da dies so weder in meinem, noch im Sinn der Balance sein
+duerfte (da so auch die Schwerter wieder zu bekommen waren), habe ich dieses
+gestern Abend noch unterbunden.
+
+Pad*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: konstruktiver Vorschlag (Pilgrim,  9. Aug 2001, 22:23:40):
+~#! rn=Wurzel rt=997135579 rg=balance
+~#! tid=997134457
+> von objekten und skills ergibt, wahrlich keine leichte aufgabe.
+demgegenueber
+> ist die ueberarbeitung aller objekte fast schon vernachlaessigbar.
+Vor einiger Zeit hatten wir die Diskussion doch schonmal ;-)?
+
+Mein Posting dazu hatte glaub ich folgene Idee(n):
+a) begrenzen von magischen Waffen/Ruestungen durch generelle MP-Kosten bei
+Gebrauch selbiger um den (zu langen) Gebrauch von solchen Gegenstaenden
+zu beschraenken ...
+b) weiss ich nicht mehr
+und c) das Festlegen ABSOLUTER Obergrenzen fuer Wafen, Ruestungen, usw aber
+auch
+Saerke,HP,MP und Ruestung bei Playern ... die auch von der Balance nicht nach
+oben abgeaendert werden koennen ... damit ein fuer alle mal festlegen, ein
+Mensch kann niemals starker sein als XYZ. Alles andere ist viel zu
+komplieziert.
+d) als workaround: falls z.B. (Ruestung+Helm+Body) die MAx.Werte uebersteigen
+wuerden,\
+kommt bein versuch, den Helm anzuziehen halt: Du kannst diesen Helm nicht mit
+dieser Ruestung benutzen ... nicht schoen, aber wirkungsvoll ...
+
+Pilgrim
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Anpassung Elementarschwert/-schild (Hate, 15. Sep 2001, 21:12:05):
+~#! rn=Grimmborn rt=996647895 rg=balance
+~#! tid=996618996
+Du warst schon damals hoffnungslos hinter der Zeit.
+
+Hate.
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Anpassung Elementarschwert/-schild (Grimmborn, 15. Sep 2001, 23:39:22):
+~#! rn=Hate rt=1000581125 rg=balance
+~#! tid=996618996
+"Zeitlos" nennt man das, "zeitlos". Und nein, ich lass mich nicht provozieren
+zu outen wer mir die Dateien mit den Befehlen gemailt hat. Die habe ich
+natuerlich selbst geschrieben, damals.
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Artillerie (Crassus,  7. Apr 2008, 08:03:12):
+Die Artillerie soll geschwaecht werden, macht es dann noch Sinn, Wurfsterne
+oder aehnliches zu sammeln.
+Als kleiner Spieler ist die Artillerie sehr gut, da man die Zaubersprueche
+noch nicht so schnell beherscht.
+
+Mit dieser Reglung, muss man sich jetzt sehr oft einlogen, damit man was von
+den gesammelten Artilleriewaffen hat.
+Wer das nicht kann, fuer den sind diese Waffen nichts mehr wert.
+
+Man sollte im Gegenzug, dann auch erlauben, Zaubersrueche automatisiert zu
+lernen, oder die zu metzelnden Monster in der Kampfkraft absenken.
+
+Die alt gedienten Seher konnten diese Artilleriewaffen besser nutzen und nun
+muss dafuer auch ein ausgleich fuer die neuen Spieler geschaffen werden.
+
+Ich wuensche eine glueckliche Hand.
+
+Crassus
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Artillerie (Fallenangel,  7. Apr 2008, 08:09:05):
+~#! rn=Crassus rt=1207548192 rg=balance
+~#! tid=1207548192
+Also erstens ist das Ganze eine Regelung die schon lange existiert, jetzt aber
+erst umgesetzt wird.
+
+Dass man hier, wenn man hier haeufiger einloggt (Einloggen zum aktiv spielen,
+nicht zum Ideln setze ich mal voraus) mehr und schneller hoch kommt (Level,
+Sprueche, usw) war auch schon immer so.
+
+Wieso man deswegen was im Gegenzug erlauben muesste, nur weil man bestehende
+Regelungen endlich umsetzt und aktiv-am-Spiel-teilnehmen auch foerderlich ist
+und man durch Abwesenheit nicht Level geschenkt bekommt, verstehe ich nicht
+ganz.
+
+Und zu Deinem letzten Absatz laesst sich wohl nur "Frueher war eh alles
+besser!" sagen ...
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Artillerie (Ark,  7. Apr 2008, 08:24:39):
+~#! rn=Crassus rt=1207548192 rg=balance
+~#! tid=1207548192
+Oehm, von "super wertvoll" o.ae. auf "schrottig", davon stand aber nichts. Es
+gibt weiterhin Verwendung, und fuer wen diese Items gedacht sind, der kann sie
+sich auch wiederbeschaffen ... wenn nicht, nun, einem gefundenen/geschenkten
+Gaul ...
+Und mit Befremden lese ich "muss dafuer auch ein Ausgleich geschaffen werden"
+... warum? Jedesmal, wenn Anpassungen vorgenommen werden, dann ist das ein
+Ausgleich, auch wenn es liebgewonnene Vorteile betrifft. Es gibt immer
+Alternativen, und es kommen regelmaessig welche hinzu. Und damit auch, ich
+nenne es "Dinge, die sich im Feld noch bewaehren muessen". Von einem Anschluss
+solcher Objekte sofort auf ein Gewohnheitsrecht mit Ausgleich bei Einstellung
+zu schliessen, ist ein kuehner, aber nicht realistischer Ansatz.
+Die zu metzelnden Monster sind mit wenigen Ausnahmen gut im Team zu schaffen
+... denken .. sie mal ... drueber nach :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Artillerie (Vector,  7. Apr 2008, 10:27:33):
+~#! rn=Crassus rt=1207548192 rg=balance
+~#! tid=1207548192
+Nein Artillerie soll nicht geschwaecht werden, es soll
+nur ein bestehendes Ungleichgewicht beseitigt werden.
+Fast alle Artillerie, vor allem die Neue, haelt sich
+seit Jahren an die Regel, dass sie nicht beliebig
+hortbar sein darf.
+Auch ganz alte Artillerie wie z.b. Flammenkugeln
+und Saeurebaelle sind seit Jahren an diese Regel
+angepasst.
+Ein paar wenige Artillerie-Sachen haben hier 
+seit Jahren eine so gesehen illegale Extrawurst
+(Wurfsterne, Robins Pfeile, Steine vom Kampfstock)
+
+Diese illegale Extrawurst besteht weiterhin. Was
+bisher gemacht wurde, ist dass es eine prinzipielle
+Moeglichkeit gibt, diese Objekte an die Regeln
+anzupassen, da Zesstra ein entsprechendes flag
+gebastelt hat.
+Warum die Artillerie als "kleiner Spieler" sehr gut
+sein soll, im Gegensatz zu Zaubersprueche erschliesst
+sich mir nun wirklich nicht, keine Ahnung wieviel
+tausend Sterne man verwerfen mussen (die ja auch
+erstmal besorgt sein muessen) bis man damit einen
+aehnlichen Schaden kriegt wie beim Feuerball o. ae.
+
+Wie schnell und wieviel die Artilliere dann
+verschwindet, steht dann ja auch einem anderen Blatt,
+aber ich sehe es eher positiv: Nun koennte es sich
+fuer Magier lohnen wieder Artillerie ueberhaupt
+zu proggen. Den welcher Magier hat den derzeit
+Lust, da ueberhaupt Energie reinzustecken?
+Es gibt ja die Wurfsterne, die nicht verfallen
+und viel zu viel Schaden machen. Man sollte
+die Aenderung (wenn sie denn mal durch ist) eher
+als Chance fuer Neues sehen.
+
+Den Absatz mit der Forderung nach automatisiertem
+Lernen oder NPC abschwaechen wegen dieser kleinen
+Wurfsternaenderung schiebe ich mal in die Schublade
+"verspaeteter Aprilscherz", hier wird ja echt
+der Eindruck erweckt, als dass alle "kleinen 
+Spieler" mit zig tausend Wurfsternen durchs
+MG huepfen und deswegen es nicht mehr noetig
+haben ihre GildenSpells zu lernen.
+Und wenn dem so ist, ist diese Anpassung wirklich
+mehr als ueberfaellig.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Artillerie (Gnome,  7. Apr 2008, 11:14:15):
+~#! rn=Crassus rt=1207548192 rg=balance
+~#! tid=1207548192
+dieser artikel gibt mir wahrlich zu denken.
+
+
+>Die Artillerie soll geschwaecht werden, macht es dann noch Sinn, Wurfsterne
+>oder aehnliches zu sammeln.
+
+die artillerie wird nicht geschwaecht, nur die quantitaet wird einem verfall
+ausgesetzt.
+sammeln? du meinst im sinne von geschenkt bekommen? ich glaube naemlich
+kaum, dass ein lvl-16-bierschuettler faehig ist, wurfsterne im nennenswerten
+umfang zu ermetzeln. wenn doch, dann haelt normalorkhausen definitiv zu
+viele wurfsterne parat.
+
+>Als kleiner Spieler ist die Artillerie sehr gut, da man die Zaubersprueche
+>noch nicht so schnell beherscht.
+
+ARGL!
+als kleiner spieler solltest du *gerade* wert auf das lernen deiner
+zaubersprueche legen, damit du dir spaeter zB alleine wurfsterne holen gehen
+kannst.
+(note to balance: wurfstern-MP-verbrauch fuer kleine spieler erhoehen.)
+
+>Mit dieser Reglung, muss man sich jetzt sehr oft einlogen, damit man was von
+>den gesammelten Artilleriewaffen hat.
+>Wer das nicht kann, fuer den sind diese Waffen nichts mehr wert.
+
+wieviele wurfsterne hast du denn bisher immer so pro tag erbett^Wgemetzelt?
+das wuerde mich wirklich interessieren.
+
+>Man sollte im Gegenzug, dann auch erlauben, Zaubersrueche automatisiert zu
+>lernen, oder die zu metzelnden Monster in der Kampfkraft absenken.
+
+ja, warum nicht. guter, konstruktiver vorschlag!
+allerdings schlage ich dann auch gleich vor, den weghier durch blosses
+erschrecken seinen vollstrecker fallenzulassen, einen zap-schalter bei
+myung, nars und robin einzubauen, und wenn ich am eingang von paraorkhausen
+auf den dritten knopf von links druecke, fallen mir 1093 wurfsterne in
+den schoss.
+wenn schon, denn schon, oder?
+
+>Die alt gedienten Seher konnten diese Artilleriewaffen besser nutzen und nun
+>muss dafuer auch ein ausgleich fuer die neuen Spieler geschaffen werden.
+
+du wirfst schon wieder qualitaet und quantitaet durcheinander.
+metzel einfach ein paar mehr und der "nachteil" ist wieder ausgeglichen.
+(note to balance: "Seher" ist im zusammenhang mit wurfsternen eigentlich ein
+                  gutes stichwort, oder?)
+
+>Ich wuensche eine glueckliche Hand.
+
+und ich ein wenig mehr gehirn.
+
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Artillerie (Maharet,  7. Apr 2008, 11:26:11):
+~#! rn=Gnome rt=1207559655 rg=balance
+~#! tid=1207548192
+Nur zur Info: Man kriegt auch Wurfsterne, ohne zu metzeln oder zu betteln. Ich
+fand die Mengen nur nie so interessant, als dass ich mich aufs Wurfsternwerfen
+haette spezialisieren wollen ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Artillerie (Vector,  7. Apr 2008, 11:38:33):
+~#! rn=Maharet rt=1207560371 rg=balance
+~#! tid=1207548192
+echt das gibts noch? ich weiss nur noch das da wochenlang
+ein tf-gesteuerter xtie stand der die weggetriggert hat.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Artillerie (Maharet,  7. Apr 2008, 11:49:51):
+~#! rn=Vector rt=1207561113 rg=balance
+~#! tid=1207548192
+ich hatte mal Morgoth einen solchen Skripter umsetzen lassen. Damals wusste
+ich noch nicht,dass die Orks einen killen, wenn die einen erwischen, sonst
+haette ich den da stehen lassen ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Artillerie (Vector,  7. Apr 2008, 11:50:45):
+~#! rn=Maharet rt=1207561791 rg=balance
+~#! tid=1207548192
+na da sag ich mal lieber nix dazu....
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Artillerie (Amynthor,  7. Apr 2008, 14:52:28):
+~#! rn=Crassus rt=1207548192 rg=balance
+~#! tid=1207548192
+Na ja... Diese Loesung finde ich auch nicht so toll. Ob die Wurfsterne an
+sich zu stark waren, kann ich nicht beurteilen, ich habe sie nie benutzt.
+Aber verfallende Objekte sind unlogisch (was fuer eine Atmosphaere muss das 
+sein, die Metall so schnell angreift?) und dem Spielspass hinderlich (ich 
+muss jetzt noch schnell metzeln gehen, solange ich die Wurfsterne habe).
+
+Wenn man den Gedanken weiterdenkt, muesste man auch die Komponenten fuer
+Zaubersprueche gammeln lassen. Immerhin sind ewige Komponenten (hier mal im
+Sinne von "bis zum Gebrauch") eine illegale Extrawurst der Gilden, und was
+ist mit dem Bumerang (= ewiger Wurfstern)? Ich persoenlich waere unter den
+Umstaenden niemals Zauberer geworden. Na gut, auf Wurfsterne kann man
+offenbar verzichten, ohne etwas zu versaeumen. Aber ich kann mir nicht
+vorstellen, dass es keine andere Moeglichkeit gegeben haette, die Balance
+wiederherzustellen.
+
+Amynthor
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Artillerie (Gnome,  7. Apr 2008, 15:22:15):
+~#! rn=Amynthor rt=1207572748 rg=balance
+~#! tid=1207548192
+es geht ja nicht nur um logik und spielspass, sondern auch darum,
+gildenuebergreifende waffen etwas zu beschraenken.
+
+mir persoenlich gefallen rostende wurfsterne und vergammelnde
+flammenkugeln auch nicht besonders, aber diese loesung ist wohl
+notwendig, um solche artillerie nicht voellig in ihrer wirkungsweise
+zu beschneiden.
+wurfsterne waren schon immer kritisch, man haette bei ihrer
+einfuehrung ihnen schon einige beschraenkungen auferlegen muessen,
+was man aber verpasst hat. diese werden nun schrittweise nachgeholt.
+
+wenn man also pro kampfrunde fuer 10-15 MP 100-150 LP schaden
+machen kann (teilweise auch deutlich mehr), was ist einem dann
+lieber: dass die sterne ploetzlich nur noch die haelfte oder
+sogar nur noch 1/3 an schaden machen? oder dass alle 45 minuten
+mal ein paar sterne aus dem inv verschwinden?
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Artillerie (Chagall,  7. Apr 2008, 16:38:39):
+~#! rn=Amynthor rt=1207572748 rg=balance
+~#! tid=1207548192
+Bitte erklaer mir mal einer, warum ewige Komponenten (hier mal im Sinne von
+"bis zum Gebrauch") eine illegale Extrawurst der Gilden ist?
+MC
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Artillerie (Croft,  7. Apr 2008, 16:41:21):
+~#! rn=Chagall rt=1207579119 rg=balance
+~#! tid=1207548192
+Amynthor will doch nur von der Extrawurst der Gilden ohne Komponenten
+ablenken.
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Artillerie (Ark,  7. Apr 2008, 18:31:15):
+~#! rn=Amynthor rt=1207572748 rg=balance
+~#! tid=1207548192
+Hm, ich wuerde folgende These aufstellen:
+Wer auf Wurfsterne beim Metzeln angewiesen ist, stirbt. Frueher oder spaeter.
+Ist wie bei Drogen, von denen man nicht loskommt, da helfen auch keine Kuren.
+Noch ein These:
+Wer Wurfsterne in grossen Mengen hortet, hat entweder keine alternativen
+Kampfideen, oder er/sie verbraucht die dazu noetige Energie zu schnell mit
+Wurfsternwerfen. Folge: siehe These 1.
+</Ironie aus> :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Artillerie (Humni,  7. Apr 2008, 21:51:45):
+~#! rn=Ark rt=1207585875 rg=balance
+~#! tid=1207548192
+Offizielles Statement der Gildenbalance:
+
+Wenn ewige Komponenten illegal waeren, waeren sie laengst verboten. Von mir.
+Sind sie aber nicht. Ich weiss, dass es sie gibt.
+
+Man mag ueber die ein oder andere (ewige) Kompo geteilter Meinung sein, aber
+ich bin grossteils der Meinung, dass sie an Stellen liegen, wo man sie nicht
+"mal eben" abholen kann. Aber wenn das ein Problem ist, dann gehoert es in
+einen anderen Thread, und nicht hierher.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Artillerie (Crassus,  8. Apr 2008, 07:31:09):
+Erst mal, auch kleinere Spieler sind in der Lage Wurfsterne zu holen, nur
+nicht genuegend an einem Tag.
+
+Es waere eine super Sache, wenn es dem Spieler selbst ueberlassen wird was er
+uebt, koennte den Spass am Spiel heben.
+Warum ist es verwerflich, Wurfsterne zu sammeln und zu lagern und andere
+Hilfsmittel fuer Zaubersprueche nicht.
+
+Welchen Grund gibt es dafuer, das Wurfsterne vergaenglich sein muessen und
+andere Waffen und Ruestungen nicht.
+Waere doch auch gut, wenn die Ruestung aller 45 min zerfaellt.
+
+Welchen Grund gibt es dafuer, das die Gilden so unterschiedlich in ihrer
+Kampfkraft sind, ist mir bei den Chaoten, Bierschuettlern und Abenteurer
+aufgefallen. Wenn es gerecht zu gehen soll muesste das zuerst ausgeglichen
+werden.
+Crassus
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Artillerie (Fallenangel,  8. Apr 2008, 07:42:08):
+~#! rn=Crassus rt=1207632669 rg=balance
+~#! tid=1207632669
+Es _wird_  hier jedem Spieler selbst ueberlassen, was er ueben will, ebenso
+sollte man der Balance sowie den Magiern genug Weitsicht zusprechen, dass sie
+auch die Probleme der Items bedenken und eben gegebenenfalls Regeln dazu
+erstellen und diese - in diesem Fall auch sehr verspaetet - umsetzen.
+
+Aber wenn Du hier den wohl unbestritten falschen Weg gehst, um stark zu werden
+(Und dazu zaehlt auf Deinem Level Sterne sammeln anstatt Sprueche zu maxen und
+zu questen) erwartest Du trotzdem, gleichstark wie andere Gilden zu sein (Die
+ja eh alle auf einen Einheitsbrei gemischt werden, ansonsten waeren sie nicht
+gleichstark sondern die eine haette immer dort und die andere da einen kleinen
+Vorteil).
+Ich muss sagen, dass Dich diese Einstellung etwas disqualifiziert ...
+
+Und warum zB Zaubis Kompos holen die nicht verfallen, Chaoten ebenso, usw,
+lerne zu unterscheiden zwischen Artillerie und Gildenspezifischen Items, da
+besteht ein Unterschied.
+
+Ich wuerde jetzt ja vorschlagen, dass Du Sprueche ueben gehst und Seher wirst,
+aber ich gehe davon aus, dass Du das als Bevormundung und nicht als Ratschlag
+siehst, insofern lasse ich das mal.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Artillerie (Kessa,  8. Apr 2008, 08:12:39):
+~#! rn=Fallenangel rt=1207633328 rg=balance
+~#! tid=1207632669
+> lerne zu unterscheiden zwischen Artillerie und Gildenspezifischen Items...
+
+Etwas aehnliches wollte ich auch dazu sagen. Der Unterschied ist: Jede Gilde
+kann _zusaetzlich_ zu ihren gildenspezifischen Faehigkeiten Artillerie
+verwenden (ja, ich weiss, Zauberer koennen es nicht so toll). Als solche
+zusaetzliche Faehigkeit ist die Verwendung von unbegrenzt Wurfsternen halt
+sehr maechtig - wie man fand, zu maechtig. Ich kann das gut nachvollziehen.
+
+> das die Gilden so unterschiedlich in ihrer
+Kampfkraft sind, ist mir bei den Chaoten, Bierschuettlern und Abenteurer
+aufgefallen. Wenn es gerecht zu gehen soll muesste das zuerst ausgeglichen
+werden.
+
+Soll es in dieser Hinsicht gar nicht, wobei das auch gar keine Sache der
+Gerechtigkeit waere, sondern der Gleichmacherei. Es ist Absicht, dass es
+Gilden gibt, in denen man einen einfacheren Start und weniger aufwendige
+Lernerei hat, dafuer aber auch nicht so stark wird wie in anderen. Die
+Bierschuettler gehoeren zur ersteren Sorte. Wenn dir die Staerke der
+Bierschuettler nicht reicht, wechsle die Gilde - allerdings wirst du dann noch
+deutlich mehr an deinen Gildenfaehigkeiten ueben muessen, da huelfe auch ein
+ewiger Wurfstern nichts.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Artillerie (Ark,  8. Apr 2008, 14:37:03):
+~#! rn=Crassus rt=1207632669 rg=balance
+~#! tid=1207632669
+Wir befinden uns in der Rubrik balance, damit ist das Argument "wenn wir es
+dem Spieler selbst ueberlassen, was er uebt", natuerlich zugelassen, insofern
+er sich in den gesetzten Grenzen bewegt. Ansonsten ist das wieder die muessige
+Argumentation "Spiel ohne Regeln, jeder macht, was ihm Spass macht".
+Die Balance setzt die Massgabe, die auch andere Artillerie betrifft, nicht wg.
+den paar erforschbaren Sternchen um, sondern um zu verhindern (wie schonmal
+anklang), dass jemand mit 345345645 Sternen recht einfach entsprechenden
+(unbalancierten) Schaden machen kann.
+Alternative waere, die Nutzung auf Seher zu beschraenken und die
+Nicht-Ermetzel-Stelle auszubauen. Aber selbst dann waere eine Zerfallsloesung
+nicht zu umgehen.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Artillerie (Ark,  8. Apr 2008, 14:38:59):
+~#! rn=Crassus rt=1207632669 rg=balance
+~#! tid=1207632669
+Achso, Gleichmacherei bei Gilden kann uebrigens nicht das Ziel sein, die
+Diskussion "Einheitsgilde" ist schon etwas abgenutzt. Ausserdem vermischt sich
+hier wunderbarerweise wieder das Thema "Gilden" mit "Item, das fuer alle
+Gilden gleich ist".
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Artillerie (Humni,  8. Apr 2008, 21:33:32):
+~#! rn=Ark rt=1207658339 rg=balance
+~#! tid=1207632669
+Richtig erkannt, wie gesagt haben "Kompos" damit gar nichts zu tun.
+
+Eine RPG-Erklaerung fuer das Verhalten gibt es in Schmarrn, dabei geht es um
+wattierte Braten, da braucht man nichtmal "Magie" fuer. Und eine
+Balance-Erklaerung gibts hier: Die Artillerie an sich ist zu stark, also haben
+wir sie nicht abgewertet, sondern eingeschraenkt. Und ich denke, das ist fuer
+die Spieler besser. Wenn wir den Wurfsternen 10% des Schadens genommen haetten
+(und das verkuendet) waere das ein deutlicherer Aufschrei gewesen - und sie
+waeren immer noch deutlich besser als alles, was wir derzeit genehmigen
+wuerden.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Artillerie (Darklor, 20. Apr 2008, 10:58:44):
+~#! rn=Crassus rt=1207548192 rg=balance
+~#! tid=1207548192
+Was is der Hintergrund dieser Aenderung?
+
+Im uebrigen halte ich vergammelnde Ausruestung fuer ne ziemlich miese Loesung.
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Artillerie (Zesstra, 20. Apr 2008, 22:19:55):
+~#! rn=Darklor rt=1208681924 rg=balance
+~#! tid=1207548192
+Ich bin nicht von der Balance, aber ich denke, dass es wie immer bei
+kampfbeeintraechtigenden Items auf das Verhaeltnis von Wirksamkeit und
+Verfuegbarkeit ankommt. In diesem Fall wurde also drauf verzichtet, die
+Wirksamkeit zu reduzieren und man reduzierte stattdessen die Verfuegbarkeit
+(durch begrenzte Haltbarkeit/Hortbarkeit). Egal, welche Entscheidung, Kritik
+waere eh gekommen. ;-)
+BTW: Die Entscheidung, dies zu tun, ist schon ziemlich alt. 3 Jahre? Oder
+schon 4?
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Artillerie (Darklor, 21. Apr 2008, 14:20:25):
+~#! rn=Zesstra rt=1208722795 rg=balance
+~#! tid=1207548192
+Ah wurde es einfacher gemacht die Sterne zu bekommen? - Was ich so gehoert hab
+sind die Orks recht fies, was das zur verfuegungstellen von Sternen
+anbelangt...
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Artillerie (Alkohol, 21. Apr 2008, 18:37:41):
+~#! rn=Darklor rt=1208681924 rg=balance
+~#! tid=1207548192
+ich versteh echt nicht, wieso man immer den hintergrund einer aenderung
+erklaeren muss. Die Balance befindet diese Aenderung fuer notwendig. In der
+Balance sind sogar Spieler. Ich weiss echt nicht, wieso in irgendeiner Weise
+noch darueber diskutiert werden muss.
+
+Alki
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Artillerie (Darklor, 21. Apr 2008, 19:02:15):
+~#! rn=Alkohol rt=1208795861 rg=balance
+~#! tid=1207548192
+Hmm ja und dann ueber Spielerschwund jammern...
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Artillerie (Vanhelsing, 21. Apr 2008, 19:04:37):
+~#! rn=Darklor rt=1208797335 rg=balance
+~#! tid=1207548192
+Ich kann echt nich verstehen, warum eine Aenderung, die vor mehreren Jahren
+schon beschlossen wurde jetzt so diskutiert wird. Aber vllt muss ich das auch
+nicht.
+
+Ich frag mich auch, was an dem "Rosten" der Wurfsterne so schlimm ist? Ich
+denk mal nicht, dass das 1mal pro Minute passiert.
+Es ist halt alles vergaenglich.
+
+VH
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Artillerie (Ark, 21. Apr 2008, 19:07:40):
+~#! rn=Darklor rt=1208780425 rg=balance
+~#! tid=1207548192
+Es war schon immer so, dass balancerelevante Items sich nicht durch eine
+leichte/schwere Erreichbarkeit definieren, dito sind Aenderungen an den Items
+auch mitnichten mit Aenderungen der Beschaffbarkeit einhergehend.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Artillerie (Gloinson, 21. Apr 2008, 19:26:11):
+~#! rn=Darklor rt=1208797335 rg=balance
+~#! tid=1207548192
+Krampfkraftsenkung vertreibt Spieler? Halte ich fuer eine vage Theorie. So
+simplifiziert sollte Krampfkrafterhoehung dann ja Spieler anziehen.
+
+Und wenn Krampfkrafterhoehung Spieler anzoege wie die Fliegen, dann saehe
+PK-MUD aus wie ein frischer Kuhfladen in Australien.
+
+Das "wer pk" ueberlasse ich dir.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Artillerie (Alkohol, 21. Apr 2008, 20:20:26):
+~#! rn=Darklor rt=1208797335 rg=balance
+~#! tid=1207548192
+das ist doch kein argument, mit diesem argument kannst du jegliche regel
+hinterfragen.
+
+So und ich werde nix mehr zu dieser Diskussion sagen. Solche Diskussionen sind
+fast so alt wie das MG, sprich absolut fruchtlos.
+
+Alk
+
+PS: ich wuensche noch viel Spass beim jammern. Muss wirklich schoen sein.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Artillerie (Vector, 22. Apr 2008, 13:38:43):
+~#! rn=Darklor rt=1208797335 rg=balance
+~#! tid=1207548192
+vielleicht ist schon wem aufgefallen, das die leute, die die
+sterne wirklich benutzen (skill 80-90 prozent und mehr) hier
+gaaanz still sind? die wissen schon warum.
+eher komsich, das hier sich nun leute beschweren, die 
+(wie ich unterstelle) den skill entweder gar nicht haben,
+oder so niedrig, dass es weit entfernt von "nutzbar" und
+"nuetzlich" liegt.
+schade, das es den zweien scheinbar nur darum geht, die
+giftspitze auszupacken und einfach mal aus prinzip sich
+lauthals aufzuregen.
+wenn ihr (alle) den thread mal genau lest dann wuerdet
+ihr merken, das die sterne bisher NULL geaendert wurden;
+die sterne haben derzeit immernoch ihre illegale extra-
+wurst.
+war jetzt geaendert wurde, ist das es nun eine technische
+moeglichkeit gibt, die sterne an die bestehenden regeln
+anzupassen. nicht mehr und nicht weniger.
+
+-----------------------------------------------------------------------------
+
+
+
+Jungs... (Anatol,  3. Nov 2009, 12:36:54):
+
+... macht doch den Deckel drauf. Oder tut sonst irgendwas. Aber ueber den
+aktuellen Zustand kann man doch weder lachen noch weinen, was ich persoenlich
+sehr, sehr schade finde.
+
+Die Objektbalance besteht laut Hilfeseite personell aus: 
+"McDee, Moonshine, Lurchi, Croft, Zarku, Huraxprax, Humni, Zook und Miril"
+
+Moonshine: vor 95 Tagen zuletzt eingeloggt
+Lurchi: Vor 426 Tagen zuletzt eingeloggt
+Zarku: Vor 698 Tagen zuletzt eingeloggt
+
+Mal ehrlich: Muss man die noch aktiven (oder zumindest anwesenden) Mitarbeiter
+des stets umstrittenen Gremiums mit solchen Karteileichen belasten und der
+Laecherlichkeit preisgeben? Oder gibt es ueberhaupt nix mehr zu tun bzw. ist
+die Relevanz des Gremiums fuer das Morgengrauen inzwischen so unbedeutend,
+dass man es eigentlich abschaffen oder zumindest auf drei Personen schrumpfen
+kann? Macht das dann doch? :)
+
+Anatol wirft Steinchen
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Jungs... (Ark,  3. Nov 2009, 12:42:40):
+~#! rn=Anatol rt=1257248214 rg=balance
+~#! tid=1257248214
+Wieviele Karteileichen gibts denn aktuell? Mir war nicht so, als gaebe es
+gerade Antragsfluten?
+Beklagst Du die Arbeit der verbliebenen Balancemitglieder (oder Nichtarbeit,
+was weiss ich)? Wieso sind diese der Laecherlichkeit preisgegeben? Kann das
+die Balance intern nicht selbst regeln (falls es sie stoert)?
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Jungs... (Gnome,  9. Nov 2009, 23:27:58):
+~#! rn=Ark rt=1257248560 rg=balance
+~#! tid=1257248214
+mag sein, dass es gerade keine antragsfluten gibt. dann frage ich mich
+aber, warum antraege von der einreichung bis zur genehmigung monate
+dauern, die latenz mitunter wochen betraegt.
+mag auch sein, dass der schwarze peter nicht immer auf balanceseite
+liegt (auch aktive magier loggen sich mal ne woche nicht ein), und
+hinreichend komplexe objekte moechten sicherlich auch ausreichend
+getestet werden, doch so im grossen und ganzen gesehen...
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Jungs... (Ark,  9. Nov 2009, 23:37:42):
+~#! rn=Gnome rt=1257805678 rg=balance
+~#! tid=1257248214
+... kann das die Balance regeln, ja :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Jungs... (Anatol, 10. Nov 2009, 02:21:05):
+~#! rn=Gnome rt=1257805678 rg=balance
+~#! tid=1257248214
+
+Unter "Karteileichen" verbuchte ich ausnahmsweise keine kuehl und trocken
+gelagerten Antraege, sondern das Personal, das sich teilweise schon ein 
+wenig "laenger" hat nicht mehr sehen lassen. Die Interna der Balance - 
+insbesondere die Laufzeiten von Antraegen - kenne ich nicht.
+
+Andererseits, Gnome, wenn Du da Spitzen setzen musst: Falls Dir eine
+rasche Bearbeitung lieber ist, vielleicht fuehrt das B-Team Dir zuliebe
+eine "aut idem"-Checkbox ein. Wenn Du da ein Kreuzchen reinmachst, ist 
+ein "ja" oder "nein" genug, Du willst keine Gruende, Du willst keine
+Teilfreigaben, Du willst keine Alternativvorschlaege. 
+
+Anatol
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Jungs... (Guard, 10. Nov 2009, 11:13:39):
+~#! rn=Anatol rt=1257816065 rg=balance
+~#! tid=1257248214
+Es ging Gnome glaube nicht darum, dass die Antraege zu ordentlich bearbeitet
+werden, sondern um die Wirkung der Balancearbeit nach aussen.
+1. Es gibt laut Liste Teammitglieder, die offensichtlich nicht mit
+Balancearbeit beschaeftigt sind, da ewig nicht eingeloggt.
+2. Wenn Antraege bearbeitet werden, so dauert das (was auch ok ist) aber es
+laesst sich nicht erkennen, wenn NICHT daran gearbeitet wird.
+3. Musste ich persoenlich die Erfahrung machen, dass Antraege monatelang
+rumliegen. Humni hat sich dafuer entschuldigt, aber es scheint nicht so rund
+zu laufen, wie es gewuenscht ist.
+
+Das wirft kein gutes Licht auf die Arbeit und verleitet zu vorschneller
+Verurteilung des Gremiums -> alles nicht im sinne des Erfinders
+Vielleicht sollte man diese "black Box" Balance etwas offener gestalten, indem
+zu Antraegen direkte ansprechpartner dem antragsteller genannt werden, so dass
+auf kurzen wegen dinge geklaert werden koennen (probleme, unklarheiten,
+fehlende zeit etc.)
+
+Guard
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Jungs... (Gnome, 14. Nov 2009, 00:32:35):
+~#! rn=Anatol rt=1257816065 rg=balance
+~#! tid=1257248214
+es liegt mir - ganz im gegensatz zu dir, anatol - nicht daran, spitzen zu
+setzen, sondern auf ein generelles, in der letzten zeit zunehmendes
+problem aufmerksam zu machen, was mit deiner spitze aber durchaus in
+zusammenhang stehen koennte.
+
+wie du dir leicht vorstellen kannst, ist mir persoenlich eigentlich egal,
+wie lange welches mitglied der balance abwesend ist. auch anderen magiern
+ist das glaub ich nicht so wichtig, denn um es mit kohls worten zu sagen:
+entscheidend ist, was hinten rauskommt.
+
+wenn aber ein antrag fuer ein simples (im sinne von nicht komplexes) objekt
+10 monate (!) bei der balance verharrt, nur um dann den stempel "geht nicht"
+zu bekommen... dann laeuft da definitiv etwas nicht rund.
+
+moeglicherweise haengt das mit den abwesenden mitgliedern zusammen, ja.
+aber moeglich ist auch, dass das grundsaetzliche black-box-system nicht
+optimal ist. eine glaeserne balance mit genauen zustaendigkeiten, eingangs-
+stempel, jederzeit abrufbaren und nachvollziehbaren prozesswegen, und
+vielleicht sogar von vornherein angepeilten zeitrahmen wuerde in allen
+bereichen fuer klarheit, sowohl auf der einen als auch auf der anderen
+seite fuer weniger missverstaendnisse und einen strafferen zeitplan sorgen.
+die gesamten infos fuer alle magier huebsch ueberschaubar an einem schwarzen
+brett, dies sogar vielleicht auch fuer alle seher[1] einsehbar, damit man
+weiss, was, wieviel und in welcher weise es auf einen zukommt, sollte man
+sich mal fuer einen balanceposten bewerben wollen.
+
+
+gnOme
+
+
+[1] - nein, fuer seher natuerlich nicht in allen einzelheiten.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Jungs... (Croft, 14. Nov 2009, 00:45:44):
+~#! rn=Gnome rt=1258155155 rg=balance
+~#! tid=1257248214
+10 Monate sind sicher zuviel, aber imho sind/waren sowas nur extreme
+Einzelfaelle.  Die betroffenen Objekte sind/waren grenzwertig und in
+den meisten Faellen wurde der Balance auch das Alpha-Testing
+ueberlassen.  Aka der entsprechende Magier hatte auch seine Anteil
+dran.
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Jungs... (Bambi, 14. Nov 2009, 11:12:16):
+~#! rn=Gnome rt=1258155155 rg=balance
+~#! tid=1257248214
+Hallo Gnome. 
+
+Ich interessiere mich sehr dafuer, wie Du Dir die Details einer "glaesernen
+Balance" vorstellst. Nach meiner Erfahrung kann man problemlos bei
+Balancemitgliedern nachfragen, ob die Tests schon angefangen haben und ob es
+irgendwelche Probleme gibt. Es kann natuerlich sein, dass die Antwort
+unbefriedigend ist. Instituionalisierte Verwaltungsarbeit, die den
+Entscheidungsprozess dokumentiert, halte ich aus dem Bauch heraus fuer
+schwierig. Ich kenne das aus Projekten, wenn man fast soviel (oder mehr!) Zeit
+damit verbringt, Aufwaende zu schaetzen, Deployment-Auftraege zu stellen,
+Daten per Management-Tool anzufordern (anstatt mal eben anzurufen) und so
+weiter. Ich habe keinen Einblick in die Interna der Balance-Prozesse, mir war
+die Aussage ganz am Schluss ("was hinten bei rauskommt") bisher immer
+ausreichend. Die einzelnen, mir nicht sichtbaren Schritte in einer mir
+verstaendlichen Weise zu praesentieren, duerfte eine Mehrarbeit erzeugen, die
+ich persoenlich lieber im Test der Objekte (oder in der Freizeit der
+Balance-Mitglieder) investiert saehe. 
+
+Ueber die Aussage "10 Monate fuer ein einfaches Objekt" bin ich irritiert. Was
+ich der Balance vorgelegt habe, wuerde ich als einfach ansehen (Poempel als
+Beispiel) und die wurden mit akzeptablem Zeitaufwand (Wochen inkl. Warteliste)
+bearbeitet. Aus reiner Neugierde wuerde ich gerne wissen, was das fuer ein
+einfaches Objekt war (welche Faehigkeiten es verleiht beziehungsweise welche
+Modifikationen es im Spiel/am Spieler vornimmt). 
+
+Nicht vergessen sollte man auch, dass auch Balance-Mitglieder nicht immer
+"24/7" verfuegbar sind oder sein wollen. Ich bin in den letzten Monaten bis
+Jahren auch manchmal wochenlang nicht im MorgenGrauen erreichbar und bin bei
+jedem Login froh, dass mir keiner den Kopf abreisst, weil ich weder als GM
+noch als RM meine Arbeit erledigt habe. (Hier mein Dank an Tusk.) 
+
+Gruss, Bambi
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Jungs... (Gnome, 15. Nov 2009, 01:35:49):
+~#! rn=Bambi rt=1258193536 rg=balance
+~#! tid=1257248214
+ueber das spezielle objekt kann ich nichts sagen, a) ist es nicht von mir,
+b) gehoeren zuviele einzelheiten nicht hierher.
+
+ich gab mich bisher auch groesstenteils mit dem zufrieden, was hinten
+rauskam. allerdings wuenschte ich mir aus magiersicht manchmal schon die
+moeglichkeit eines statuschecks, ohne gleich jedes mal ein mitglied
+anpingen zu muessen.
+ich sehe bei einem einfachen einchecken / weiterchecken / statuswechsel
+des antrags eine mehrarbeit von max. zehn minuten pro objekt;
+ein vertretbarer zeitaufwand in meinen augen.
+
+aber da ich hier nix mehr beantragen werde, haenge ich mich da auch nicht
+weiter rein. es war nur eine idee, wie man sowas etwas reibungsloser
+gestalten koennte.
+
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Jungs... (Guard, 15. Nov 2009, 08:18:56):
+~#! rn=Gnome rt=1258245349 rg=balance
+~#! tid=1257248214
+da ich gerade als antragsteller mit der balance konfrontiert bin und bambi so
+schoen auf projektarbeit anspielt ...
+1. antragsteller stellt antrag per mail
+2. antragsteller erhaelt mail, dass antrag eingegangen ist und eine
+vorgangsnummer
+3. auf dem balancebrett kann der antragsteller die nummer abfragen und erhaelt
+den jeweiligen status: eingegangen, zugewiesen/bearbeitung von xxx,
+abgenommen, abgewiesen
+aufwand fuer antragsteller und balance ist minimal, wirkung ist enorm
+beide parteien haben einen ueberblick, welche antraege in welchem status wie
+mlange rumliegen
+antragsteller hat einen einsprechpartner und bekommt informationen auch ohne
+immer ein balancemitglied abpassen zu muessen oder mails in ne blackbox zu
+schicken
+
+nur mal so als erfahrungen aus projektarbeit
+
+Guard
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Jungs... (Ark, 15. Nov 2009, 13:28:33):
+~#! rn=Gnome rt=1258245349 rg=balance
+~#! tid=1257248214
+Plain Talk? Jede zusaetzliche Regelung ist ein Aergernis mehr, an dem man sich
+ob deren Nichteinhaltung reiben kann. Imho braucht es das nicht. Wer macht das
+Ganze? Leute, Menschen, Spieler, Magier ... und mit denen kann man
+normalerweise reden. Und imho geht es nur so, im Endeffekt will der
+Antragsteller (z.B. ich) ja etwas (einen getesteten und fuer gut befundenen
+Gegenstand/NPC), ergo muss ich mich als Antragsteller auch darum kuemmern,
+denn anders als im RL sind wir hier nicht auf dem Amt. Und mein Ego sagt "das
+geht schneller", muss sich aber mit der Realitaet abfinden, dass da kein
+kleiner Balancler nur sein Mailfile auf das Eintreffen eines Antrags
+durchforstet in der Hoffnung, sich gleich an die Arbeit machen zu koennen. Das
+mit "kleiner Balancler" ist natuerlich nicht wirklich so :-)
+Ueberall jammern wir ueber noch mehr Hindernisse, da waere es doch gelacht,
+wenn hier mehr Formalitaeten noetig waeren, um fuer Verbesserung zu sorgen -
+sie sind es nicht, imho im Gegenteil. Mit beharrlicher Kontaktsuche erfaehrt
+man aus meiner Erfahrung auch, was nicht sehr attraktiv am Item/NPC ist und
+kann das ggf. verbessern, und DAS schafft kein Formalismus, der sich am Antrag
+und dessen Weiterbehandlung festbeisst.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Jungs... (Guard, 15. Nov 2009, 14:05:11):
+~#! rn=Ark rt=1258288113 rg=balance
+~#! tid=1257248214
+Klingt ganz so, als sei es voellig ok, dass die Balance in schlechterem Licht
+dasteht als sie muss. Nix aendern ist natuerlich am einfachsten. Und an den
+guten Willen haben wir ja nun nicht zum ersten Mal appeliert.
+Und Transparenz ist nicht gleich Formalismus/Beamtentum ...
+
+Guard
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Jungs... (Ark, 15. Nov 2009, 14:11:08):
+~#! rn=Guard rt=1258290311 rg=balance
+~#! tid=1257248214
+Natuerlich kann man was aendern. Ich bezweifel nur, dass das im Ergebnis dann
+besser ist. Es steht mir fern, mich da reinzumischen, gebe nur meine Meinung
+und Erfahrung kund.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Jungs... (Ark, 15. Nov 2009, 14:13:59):
+~#! rn=Ark rt=1258290668 rg=balance
+~#! tid=1257248214
+Btw., falls sich von den Spielern jemand dazu berufen fuehlt, aktiv an der
+Entwicklung mitzugestalten, kann er jederzeit sich bei der Balance bewerben,
+denke ich. So koennte man zumindest dem Personalproblem begegnen, ist ja nicht
+so, dass die Balance schon immer aus den gleichen Spielern bestand.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Jungs... (Vector, 15. Nov 2009, 14:15:41):
+~#! rn=Ark rt=1258290839 rg=balance
+~#! tid=1257248214
+solange keiner der (inaktiven karteileichen) sich dazu entscheidet,
+sich seine (in)aktivitaet einzugestehen und ausscheidet (bzw 
+ausgeschieden wird) is die balance doch voll besetzt!?
+wobei man bei ein jahr und mehr an nicht-da-sein wirklich sowas
+wie den deckel drauf machen koennte bzw entsprechendes
+unkraut jaeten, und dann versuchen koennte mit frischen blut
+weiterzumachen
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Jungs... (Guard, 15. Nov 2009, 14:22:46):
+~#! rn=Vector rt=1258290941 rg=balance
+~#! tid=1257248214
+Finde auch, dass man etwas deutlicher klarmachen sollte, dass entweder
+"unkraut gejaetet" wird und dann nach bewerbern gefragt wird, oder ob Spieler
+kraft der eigenen wassersuppe ne bewerbung schreiben und dabei gleich
+mitschreiben, welche karteileiche sie ersetzen wollen ...
+
+Guard
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Jungs... (Ark, 15. Nov 2009, 14:31:03):
+~#! rn=Vector rt=1258290941 rg=balance
+~#! tid=1257248214
+Ja dann sind wir wieder beim Anfang des Threads ... pls. handle :-)
+Wobei ... gab es ne Max Mitglieder Beschraenkung (von der ich nix weiss)?
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Jungs... (Anatol, 15. Nov 2009, 14:39:20):
+~#! rn=Ark rt=1258291863 rg=balance
+~#! tid=1257248214
+
+Diese jofverdammte Abpasserei der Magier, die einen Zwischenstand haben 
+wollen, die Einfluss auf die Entscheidung nehmen wollen, die nicht an einem
+Kompromiss, sondern am eigenen Ego interessiert sind. Die Dich hier 45
+Minuten zutexten und nicht merken, dass Du 45 Minuten in der Kueche warst,
+von Deiner Unfaehigkeit ebenso ueberzeugt sind wie davon, dass sie die 
+Weisheit via Schaufelradbagger zugefuehrt bekamen.
+
+Oh, das ist kein sachlicher Beitrag. Das ist nur ein Stein. Aber der wollte
+geworfen werden, ich hab's ihm angesehen...
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Jungs... (Gnome, 15. Nov 2009, 17:07:52):
+~#! rn=Ark rt=1258290839 rg=balance
+~#! tid=1257248214
+> Jede zusaetzliche Regelung ist ein Aergernis mehr, an dem man sich
+> ob deren Nichteinhaltung reiben kann. Imho braucht es das nicht.
+
+hey, da hat wohl jemand meine alten artikel gelesen. koennten wir das
+kurz auch noch auf bestimmte aktuelle regelfassungen ausweiten?
+imho braucht es da viele auch nicht.
+
+
+> Und imho geht es nur so, im Endeffekt will der Antragsteller (z.B. ich)
+> ja etwas (einen getesteten und fuer gut befundenen Gegenstand/NPC), ergo
+> muss ich mich als Antragsteller auch darum kuemmern,
+
+bitte? ich arbeite wochen- und monatelang konzepte, gegenden und objekte aus,
+schreibe, teste und verwerfe sie, schreibe sie neu bis es passt, stelle
+seitenlange antraege und muss *dann* auch noch zusehen, dass sie zuegig durch
+die balance gehen? nun mach aber mal nen punkt.
+wenn du das als teilaufgabe deines magierdaseins siehst... lass dich nicht
+aufhalten.
+
+ich sehe das so, dass die balance irgendwann zwischen die magier und
+das mud geschoben wurde. sie sieht sich als bestimmende bzw. beschneidende
+institution fuer objekte, die gewisse grenzen ueberschreiten wollen. sie
+fordert also von magiern dahingehend antraege mit zahlen und begruendungen,
+ergo eine nicht zu unterschaetzende mehrarbeit.
+ab antragseingang ist in meinen augen die balance dafuer verantwortlich,
+dass dem magier auf schnellstmoglichem weg ein feedback zugesandt wird.
+und natuerlich erwarte ich als magier, dass man sich relativ zuegig mit
+meinem antrag auseinandersetzt. von sich aus, ohne dreimal nachzufragen.
+
+wenn mir das als balancemitglied (zu) schwer von der hand geht oder ich
+monate bzw. jahre durch abwesenheit glaenze oder ein simpler antrag aus
+welchen gruenden auch immer monatelang bei der balance verstaubt, ist dann
+die kritische frage nach meiner balancezugehoerigkeit legitim bzw. die hier
+urspruenglich erwaehnte forderung nach einem systemwechsel von "black" zu
+"white box" sogar erforderlich.
+
+
+> Mit beharrlicher Kontaktsuche erfaehrt man aus meiner Erfahrung auch,
+> was nicht sehr attraktiv am Item/NPC ist und kann das ggf. verbessern,
+> und DAS schafft kein Formalismus,
+
+natuerlich. das persoenliche gespraech muss bleiben. das steht aber in
+keinem widerspruch zu einem system, was dem magier wertvolle infos
+vermittelt, sollte sein ansprechpartner sich mal 2 wochen im urlaub befinden.
+
+
+> Btw., falls sich von den Spielern jemand dazu berufen fuehlt, aktiv an der
+> Entwicklung mitzugestalten, kann er jederzeit sich bei der Balance bewerben
+
+sicher, initiativbewerbungen sind nicht verboten. aber in erster linie liegt
+es doch wohl im interesse der balance, aktive mitarbeiter zu haben, damit
+antraege zuegig bearbeitet werden koennen?
+
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Jungs... (Ark, 15. Nov 2009, 17:32:59):
+~#! rn=Gnome rt=1258301272 rg=balance
+~#! tid=1257248214
+Hm, welche Regelfassungen sollten das wohl sein? Egal, gehoert aber nicht in
+diesen Thread. Und "seitenlange Antraege"? Ich dachte, es gaebe da "wichtige
+Werte", auf die man sich beschraenken kann (im Endeffekt reduziert sich das
+meiste, was genehmigt werden muss, immer auf das Gleiche, die Werte), oder
+kurz das revolutionaere neue, was Item Bla kann. Wuesste jetzt nicht, was
+wirklich mehr als ne Viertelstunde dauern sollte, das Gegenueber muss das ja
+auch lesen und verstehen koennen. Vielleicht auch Teil des Problems, was weiss
+ich.
+Wie gesagt, ich bezweifle stark, dass eine White Box weniger im Gebrauch
+verstaubt als eine Black Box, aber das sei dahingestellt. Im Endeffekt glaube
+ich, dass die Diskussion bei der Balance angekommen ist, und ueberlasse "ihr"
+jetzt Kommentare oder Taten :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Jungs... (Gloinson, 15. Nov 2009, 17:51:22):
+~#! rn=Ark rt=1258302779 rg=balance
+~#! tid=1257248214
+Ich habe seit laengerem den Eindruck einer sterbenden Aktivitaet seitens
+Spielern und Magiern. Ich weiss nicht genau, seit wann es die Balance gibt,
+aber es koennte der Zeitpunkt erreicht sein, an dem sie nicht mehr notwendig
+ist.
+
+Ganz ehrlich: bei 50 aktiven Spielern sind 5 Balancemitglieder mehr oder
+weniger albern.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Jungs... (Ark, 15. Nov 2009, 18:54:53):
+~#! rn=Gloinson rt=1258303882 rg=balance
+~#! tid=1257248214
+Warum? Damit jemand ungetestet seine Uberwaffen/-ruestungen auf den Markt
+werfen kann? Dazu wurde die Balance ja mal gegruendet. Man kann sie
+Magier-/Spielerzahlen anpassen, wenn es keine aktiven Magier mehr gibt, die
+was anschliessen wollen, kann man sie gerne auf 1 (fuer Altlasten) anpassen.
+Es ist ja nicht so, dass das Ergebnis ihrer Existenz schlecht ist, nur die
+Aenderung des Modus Operandus wurde ja diskutiert.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^15: Jungs... (Gloinson, 15. Nov 2009, 19:44:54):
+~#! rn=Ark rt=1258307693 rg=balance
+~#! tid=1257248214
+Wenn die Balance durch ihre schwundbedingte Abwesenheit mittlerweile das
+bisschen an Aktivitaet das existiert ausbremst, dann bevorzuge ich schnellere
+Zulassung von dann bei Anwesenheit der Balance ggf. nachzubalancierende
+Objekte.
+
+Die Balance funktioniert nur mit Aktivitaet fuer beide Seiten
+zufriedenstellend. Ich hatte den Eindruck, dass die fehlende Aktivitaet hier
+von Antragsstellern kritisiert wird. Ich kann auch meine 2 Cent mit einem
+verlorengegangenen Antrag von vor einem Jahr in die Wagschale werfen.
+
+Mal Tacheles: hier sind inzwischen so wenig Aktive, dass selbst Megaschmarrn
+unter 100 faellt. Wie zum Geier soll da irgend ein groesseres Gremium mit
+sinnvollen Antwortzeiten funktionieren? Und wenn es nicht funktioniert, warum
+sollen wir dann nicht zwischen dem Schaden durch Nichtexistenz und dem
+Schaden durch Nichtfunktionalitaet abwaegen?
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Jungs... (Anatol, 16. Nov 2009, 12:28:33):
+~#! rn=Gnome rt=1258301272 rg=balance
+~#! tid=1257248214
+Gnome schrieb u.a.:
+> [...]
+> sie fordert also von magiern dahingehend antraege mit zahlen und
+> begruendungen, ergo eine nicht zu unterschaetzende mehrarbeit.
+> [...]
+
+So sich die Verpflichtungen eines Magiers nicht allzusehr geaendert
+haben, zeugt dieses Kommentar von einer Einstellung, ueber die sich
+das aktuelle B-Team sicher mit jedem Deiner Antraege masslos freut.
+
+Gnome, es gehoerte seit alters her zu den Pflichten eines Magiers,
+sich seine Anschluesse wohl zu ueberlegen und vor sich, vor seinem
+Regionsmagier, ggf. vor dem fuer das Themengebiet verantwortlichen
+Erzmagier begruenden zu koennen. Die Behauptung, diese Aufwaende 
+seien erst mit dem spieleranteiligen B-Team entstanden, ist nicht 
+nur aus der Luft gegriffen, sondern auch ein klein wenig frech, mh?
+
+Darueber hinaus ist schon seit Jahren selbst ein ueberdurchschnittlich
+in den Spielbetrieb eingebundener Magier nicht mehr in der Lage, die
+notwendigen Facetten eines Neuanschlusses hinreichend zu bewerten. Da
+hat auch Rochus' Waffen-/Ruestungsmaster nichts daran geaendert. Und
+nur aus diesem Grund wurde das Balance-Team ins Leben gerufen. Weil 
+es Spieler gibt, die ueber den eigenen Tellerrand hinauskucken wollen
+und koennen - und weil deren Wissen und Kombinationsgabe das der Magier
+deutlich ueberschreitet. Man wird da natuerlich nicht gerade Spieler
+hinzuziehen wollen, die ein im gesamten Spiel unverwundbar machendes
+(immer wieder zu erlangendes) Questobjekt als Feature und nicht als
+als Fehler betrachten (Tellerrand, Tellerrand...). Aber das ist nur
+fuer genau diese Spieler ein Problem.
+
+Die historisch bedeutensten Abwertungen (neudeutsch "Nerfs") waren
+meines Wissens von Spielern getrieben. Sie haben sich damit bei ihren
+Mitspielern nicht beliebt gemacht, wie auch der Rest ihrer Arbeit kaum
+Ruhm und Ehre einspielt (immerhin quatschen Magier auf Stammtischen 
+ganz gern. "Ach, ich hatte das viiiel staerker beantragt, aber die
+Balance..."). 
+
+Mein Anliegen war lediglich, das Team um die Karteileichen zu bereinigen.
+Das koennte (!) Abstimmungsprozesse beschleunigen, das macht es Magiern
+einfach, einen Nachfass zu schreiben und mir ganz persoenlich gibt es das
+Gefuehl, dass irgendwer in dieser Welt die aktiven B-Team-Mitglieder
+noch ernst nimmt.
+
+Anatol
+
+PS: Das ist schon wieder so viel Text, dass es ausser Gnome keiner liest.
+    Well, macht nichts. ]:^>
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Jungs... (Gnome, 16. Nov 2009, 23:00:39):
+~#! rn=Anatol rt=1258370913 rg=balance
+~#! tid=1257248214
+> So sich die Verpflichtungen eines Magiers nicht allzusehr geaendert
+> haben, zeugt dieses Kommentar von einer Einstellung, ueber die sich
+> das aktuelle B-Team sicher mit jedem Deiner Antraege masslos freut.
+
+ohh, ich hab es geahnt... doch haette ich es wissen muessen!
+
+anatol, alter erbsenzaehler, meinst du wirklich, ich wuerde mir bei
+meinen objekten keine gedanken machen? es ist jedoch ein unterschied,
+ob ich mir "nur" gedanken mache und diese vor meinem innere auge abnicke,
+oder ob ich diese auch in einer formellen form anderen zukommen lassen muss,
+die sie dann auch noch inhaltlich und rechnerisch nachvollziehen muessen.
+mit allem drum und dran, nebst beispielrechnungen, tabellen und nachkomma-
+stellen, dauert solch ein antrag bei einem moderat komplexen objekt etwa 2
+stunden. der rekord liegt bei mir bei ueber 300 zeilen. das waren dann mal
+eben 10 stunden arbeit. abgerundet.
+
+dass ich bei den werten meiner antraege hier und da uebers ziel hinaus-
+geschossen bin, mag ich gerne zugeben und ist sicherlich verbesserungs-
+wuerdig, ist aber in deinen augen ein argument fuer genau *was* bitte?
+
+zum rest deiner ausfuehrungen: ich zweifle nicht am sinn der balance,
+sondern versuche seit zig artikeln darauf hinzuweisen, dass es offensichtlich
+defizite sowohl in der kommunikation zwischen magiern und balance als auch
+in den arbeitsablaeufen derselbigen gibt. das eine koennte man verbessern,
+indem man eine white box resp. schwarzes brett resp. balancetool fuer magier
+strickt, das andere beschleunigen, indem man innerhalb des teams den besen
+schwingt und offiziell nach neuen fahndet.
+wenn du das bis hierhin jetzt noch nicht verstanden haben solltest, antworte
+ich einfach mal mit: dein pech.
+
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Jungs... (Zook, 23. Nov 2009, 17:48:11):
+~#! rn=Anatol rt=1258370913 rg=balance
+~#! tid=1257248214
+Doch, ich habs gelesen, bis zum PS.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Jungs... (Darklor, 29. Nov 2009, 18:10:57):
+~#! rn=Zook rt=1258994891 rg=balance
+~#! tid=1257248214
+Dito! ;)
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Jungs... (Sharia,  7. Dez 2009, 09:51:42):
+~#! rn=Gloinson rt=1258303882 rg=balance
+~#! tid=1257248214
+zur Info @ Gloinson:
+
+Das erste offizielle Treffen des Balanceteams war am 26.6.1998.
+Das Balanceteam bestand damals aus:
+Boing, Nachtwind, Sting, Tars, Teddy, Zephyr und mir.
+Das erste Treffen des B-Teams fand zunaechst in Teddys Seherhaus statt, aber
+da das Morgengrauen dann erstmal beschlossen hat nichts zu tun, wurde das
+Treffen dann in den Arbeitsraum von Muaddib im Silberland verlegt.
+
+nur so als kurzer historischer Abriss :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Jungs... (Muadib, 28. Dez 2009, 10:46:04):
+~#! rn=Zook rt=1258994891 rg=balance
+~#! tid=1257248214
+jehova?
+
+-----------------------------------------------------------------------------
+
+
+
