Nikolaus! (Catweazle, 21. Nov 2003, 18:49:15):
~#! on=Pizzapepe ot=1063179236 og=party
'Allo Partypeople,

Pizzapepe 'ier. Larinchen hat mich gerade gefragt, ob wir Nikolausi wieder mal
auf der Winterburg zusammenkommen wollen.
Also tun wir das. Ich kuemmer mich um Termin, Speiseplan etc., und wem Tdas
alles nicht passt, der brauch nciht meckern, sondern kann tun und lassen, was
er will. Ich lasse mich auch nicht auf eine Verlegungsdiskussion ein, auf
keine Abstimmungsautomaten oder aehnliches. Wir hatten schonmal eine
Nikolausfete mit 25 Leuten, die war sehr gemuetlich und nett, und wenn es
nicht mehr werden, dann halt nicht.
Ihr koennt gerne Terminvorschlaege machen, aber ich ziele jetzt erstmal auf
das WOchenende 6./7. Dezember.

PP
(Partydiktator)

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



Partytermin waer moeglich (Catweazle, 21. Nov 2003, 18:50:01):
~#! on=Pizzapepe ot=1063360963 og=party
Also ich hab mal mit der Hausverwaltung telefoniert, der Termin waere noch
frei. Nun mal Butter bei die Fische - wer ist so lieb und stellt ein
Partybrett auf?

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



Re: damit sich keiner wundert ....  (Catweazle, 21. Nov 2003, 18:50:53):
~#! on=Montanus ot=1063788351 og=party
~#! rn=Larina rt=1063735765 rg=party
~#! tid=1063735765

... und noch ein Nachtrag:
in schweren Verhandlungen *g* und durch wunderbare Kalkulation ist es
Larinchen und mir gelungen, den Preis signifikant gegenueber der letzten Party
zu druecken:
Wer im Vorfeld ueberweist, zahlt nur noch 44.44 Euro (letztes Mal waren es
47).
Wer auf Abendkasse zockt, der bleibt aber bei den 50. (Keinen Bock auf
Wechzselgeld...)
Und jetzt fleissig anmelden!

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



Halbe Party (Catweazle, 21. Nov 2003, 18:51:17):
~#! on=Montanus ot=1064492801 og=party
Da ich grad gefraegt wurde, wie teuer es denn sei, wenn man nur von Samstag
auf Sontag die Burg beehren wuerde, haeb ich mal den Taschenrechner rausgeholt
und bin auf 25 Euro und 25 Cents gekommen. Nur so zur Information.
Die ganze Party kostet nach wie vor 44,44 Euro.

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



Neues vom Chinesen (Catweazle, 21. Nov 2003, 18:51:31):
~#! on=Anysidora ot=1065011138 og=party
Ich habe mich jetzt mal etwas genauer ueber den Kreuznacher Chinesen
informiert. Er bietet jeden Mittag ein Mittagsbuffet an, welches wirklich
lecker ist (ich habs schon gekostet ;)). Allerdings kostet dieses Sonntags
13.50 Euro, da an diesem Tag noch ein Grill mit dabei ist (man kann sich also
sein Fleisch oder Fisch roh aussuchen und sich direkt vor der Nase braten
lassen).  
Alternativ gibt es natuerlich wieder den Chinesen in Bad Sobernheim, der hatte
letztes Mal 10 Euro pro Person gekostet, wobei sich jeweils 2 Leute eine
Platte geteilt haben. Dort war es natuerlich auch nicht unlecker. ;)

Nun dachten wir, wir fragen einfach mal diejenigen, die nach Winterburg
kommen, was sie zum Thema Chinese so meinen. Eher Bad Kreuznach oder eher Bad
Sobernheim? (Ob preislich noch was zu machen ist, weiss ich nicht. Das muesste
man vielleicht mal versuchen zu regeln, wenn man weiss, wieviele es nun
wirklich sind. Aber erstmal gehe ich von den genannten Preisen aus.)
Also postet fleissig eure Meinungen, ihr muesst das schliesslich essen und
bezahlen ;)

Bye, Any 

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



Re: Neues vom Chinesen (Catweazle, 21. Nov 2003, 18:51:35):
~#! on=Anysidora ot=1065011358 og=party
~#! rn=Anysidora rt=1065011138 rg=party
~#! tid=1065011138
Achja, ich habe noch etwas vergessen...
Hier koennt ihr euch den Kreuznacher Chinesen mal anschauen, wenn ihr wollt ;)
http://www.bad-kreuznach.com/gastronomie/great_khan/great_khan.htm

Bye, Any

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



(hoffentlich) endgueltiges vom Chinesen (Catweazle, 21. Nov 2003, 18:55:13):
~#! on=Anysidora ot=1067382199 og=party
Hi Ihr!

Da ja nun schon ein paar meinten, dass es wichtig waere, so schnell wie
moeglich zu wissen, zu welchem Chinesen es denn nun gehen soll, damit man sich
noch entsprechende Zugfahrkarten sichern kann, erklaere ich die
Meinungsumfrage hiermit fuer beendet. :)
Die Auswertung der eingegangenen Meinungen hat ein ziemlich eindeutiges
Ergebnis gebracht. (Naja, wenn man das so sagen kann, nachdem man sich
anschaut, wieviele ueberhaupt was zum Chinesen gesagt haben. Aber ich nehm nun
einfach mal an, dass sich wer gemeldet haette, wenn er wichtige Gruende fuer
einen der beiden gehabt haette ;))

Es geht also hiermit zum Chinesen in Bad Kreuznach.

Damit ist nun auch der Run auf die Zugfahrkarten eroeffnet und ich hoffe
einfach mal, dass da nun nichts mehr dazwischenkommt. ;) Wenn doch, halte ich
euch hier auf dem Laufenden. (Aber jetzt fahr ich erstmal bis 16.11. in Urlaub
:))

Bye, Any* :)

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



Anmeldeschluss (Catweazle, 21. Nov 2003, 18:55:23):
~#! on=Montanus ot=1067422224 og=party
Ich hab grad mit Larinchen geschwaetzt, und wir sind zu folgendem Ergebnis
gekommen: Party-Anmeldeschluss ist der 20. November. Dann melden wir Zahlen
nach WiBu, und wer spaeter noch kommt, der zahlt den Abendkassenpreis.
Was wird jetzt eigentlich fuer ein Motiv gewuenscht fuers T-Short? Oder den
Pullover?Mail an mich bitte.

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



ueberweisen bitte auch  bis zum 20.11. (Catweazle, 21. Nov 2003, 18:56:50):
~#! on=Larina ot=1067978458 og=party
Hallo allerseits :-) 
Wie Montanus schon geschrieben hatte, haben wir den 20.11. als Anmeldeschluss
angegeben, daher bitte auch nur bis dahin ueberweisen. Wer erst spaeter daran
denkt muss das Geld eben mitbringen. :-) 
liebe Gruesse
Larina

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



Re: Re: ueberweisen bitte auch  bis zum 20.11. (Catweazle, 21. Nov 2003, 18:57:48):
~#! on=Croft ot=1068037462 og=party
~#! rn=Cassandra rt=1068037248 rg=party
~#! tid=1067978458
Bei dem in der AG steht es:

Name:  Saskia Schmid
Knr:   625120019
BLZ:   55190000
Bank:  Mainzer Volksbank eG

Croft

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



Musik et cetera (Catweazle, 21. Nov 2003, 18:58:30):
~#! on=Anatol ot=1069097672 og=party
Als Partyverantwortlicheraushilfsassistentenordnerschlepper habe ich
den Auftrag, kund zu tun, dass es auch dieses Jahr wieder sehr nett waere,
wenn ein paar Leute Musik in CD-Form mitbringen. 

Wer das tun moechte, sage mir bitte unter Angabe der Stilrichtung bescheid,
damit nicht etwa 23x Nightwish herumliegt - und sonst nix. :)

Angeregt wurde auch, basierend auf einer MS(tm)-Umfrage, dass bei der
Anzahl aenzer/Taenzerinnen auch die eine oder andere Ballroom-Hour nett
waere. Also hier explizit die Bitte: Jungs, Maedels, bringt eure Tanzlatschen
mit. Und wenn ihr die Musik dazu habt: Die bitte auch.

Gruessles,
Anatol (Partyverantwortlicheraushilfsassistentenordnerschlepper)

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



motiv (Catweazle, 21. Nov 2003, 18:59:14):
~#! on=Montanus ot=1069327450 og=party
Guckt euch mal das moegliche Motiv an: waere weisser Flock auf dunkelgruenem
Shirt.
Link: http://www.geocities.com/kuestenzauberer/schneemann.tif
(nicht alle auf einmal hinhuepfen, ich hab da nicht so grosse bandwidth...)

Inwieweit das mit der Schrift sich realisieren laesst, muss ich mit dem
Drucker auch noch klaeren.

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



T-Shirt (Montanus, 24. Nov 2003, 14:55:55):
Sodele. Mit heutigem Tage ist die T-Shoertliste geschlossen.
Folgende Dam- udn Herrschaften haben bestellt:
Maharet (S)
Beldaran, Ronda, Zarku (M)
Anatol, Brewer, Gitarre, Guen, karima, Larina, Miril, Muhkoyoma, Pitfall,
Taranis, Zook, Montanus (L)
Akasha, Bambi, Firehawk, Guard, Muadib, Mupfel, Pardauz, Vincent (XL)
Humni, Olli, Catweazle, Larisielle, Twingi und nochmal Twingi (XXL).
macht genau 30 Stueck.

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



Winterparty Muenster (Catweazle, 14. Feb 2004, 13:33:06):

So, die Wahrscheinlichkeit fuer die Muensteraner Winterparty sind nun endlich
bei 90% angekommen (die waren schon mal bei 25, ich faule Sau ich).

Aber alles ist gut, fast alles ist festgeruettelt, fehlen nur noch
unwesentliche Details.

Ergo: Bitte streicht schon mal als belegt an: 02.-04. April, das ist eine
Woche vor Ostern. 

Ankuendigungen folgen...

Ach und! Ihr muesst alle kommen, sonst laeuft hier gar nix, damit das klar
ist! :-)

Yours truly,
     Catweazle

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



Einladung zur Fruehlingsparty in Muenster (hochoffiziell) (Catweazle, 27. Feb 2004, 13:24:15):
Kuckuck!

Nach den ganzen Vorabankuendigungen brauch ich ja fast nix mehr zu sagen,
oder? Na gut vielleicht doch. Es gibt eine 

                  ****** Fruehlings-MG-Party ******
Und zwar am                 
                  ****** 02.-04. April 2004  ******
in
                  ******      Muenster       ******


Nachdem ich ein paar Muensteraner Mudder angetriggert und ein paar 
Reservierungen getaetigt habe, ist es nun doch wieder passiert, es 
gibt eine MG-Party in Muenster. Das Rahmenprogramm wird vielen bekannt
vorkommen, wir wiederholen bewaehrtes :-)

Freitag:
19:30 Uhr       Treffen im "Uferlos" am Aasee
ab 22:00 Uhr    steht in Gievenbeck ein Turnhalle zum Uebernachten zur 
                Verfuegung

Samstag (hat eine Menge "Vielleicht"s):
(Morgens)       Fruehstueck in der Halle (falls genug Leute kommen
                und das finanzierbar ist)
(Mittags)       RL-Quest (Einige Muensteraner zucken da evtl. und 
                organisieren was)
(Nachmittags)   Seminarvortraege und/oder Vereins-Vollversammlung
Abends          Ab etwa 20:00 Uhr Grosse Party in Fachwerk Gievenbeck.

Sonntags:
12:30 Uhr       Traditionelles China-Essen bei "Hong-Bin"

Der diesmalige Partybeitrag liegt bei 15 Euro Vorkasse und 18 Euro
Abendkasse. Vorkasse bezahlt bitte an:

Kontoinhaber: Christian Schild                    
Kontonummer:  022443662             
Bankleitzahl: 40070024              
Deutsche Bank Muenster             
IBAN:         DE55400700240022443662
BIC/SWIFT:    DEUTDEDB400           

Bitte gebt auf der Ueberweisung unbedingt den Mudnamen mit an,
damit ich korrekt zuordnen kann, wer schon bezahlt hat und wer nicht.

Soweit die Einladung.
Weitere Infos ueber Seminarvortraege, Tshirts, Wegbeschreibungen, Hotels,
usw. usf. gibts es in Kuerze in dieser oder der Party-Rubrik. 

Yours truly,
     Catweazle (+ Areelanir, Darkwing, Foobar, Gorog, Kadis, u.m.a.)

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



Wegbeschreibungen (Catweazle, 15. Mar 2004, 19:35:20):
Ola!

Wie einigen schon aufgefallen sein duerfte, hat die angekuendigte Webseite 
http://mg.mud.de/Party/Party.25/hinweise.html mittlerweile auch Inhalt.

Ich hab endlich die Wegbeschreibungen fertig geschrieben, diese sind nun
verlinkt bzw. auf Seite http://mg.mud.de/Party/Party.25/wegbeschreibung.html
zu finden.

Was noch fehlt ist eine Hotelliste, die gibts in Kuerze, wahrscheinlich aber
erst morgen.

Yours truly,
    Catweazle

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



Hotels (Catweazle, 16. Mar 2004, 20:03:46):
Ola!

Auf der Info-Webseite http://mg.mud.de/Party/Party.25/index.html ist nun auch
die Hotelliste und ein paar Infos zu den Hotels zu finden.

Yours truly,
     Catweazle

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



partytasse (Tasse, 18. Mar 2004, 20:26:26):
Hallo zusammen,

Es wird dieses zur Muenster-Party eine Tasse geben. Kosten wird das ganze pro
Stueck 11-12 Euro - zu zahlen auf der Party (nicht mit ueberweisen).

Motivtechnisch wirds eine Karte vom Morgengrauen und dazu den Namen geben.
Sonderwuensche zum Text einfach mit in eure Bestell-Mail schreiben.

Also wer so ein Teil haben mag: Mail an tasse, das ganze moeglichst bis zum
24.3.

So long,
    Tasse :-)

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



Partytasse (Tasse, 22. Mar 2004, 21:04:56):
Auf der Partyseite ist nun ein Link zum Motiv.

Zwei Stellen sind individuell pro Tasse, einmal der Name unten rechts (ohne
Titel) und dann noch eine Zeile in der Mitte (auf dem Bild die mit den
schwarzen Drachen, die kommt auf Humni's Tasse).

So long, bis Mittwoch Abend werden Bestellungen und Sonderwuensche angenommen
:-)

Tasse


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



Die Turnhalle (Areelanir, 24. Mar 2004, 10:20:35):
Hier einige Infos zur Turnhalle:
Wir kommen wahrscheinlich schon eher als 22:00 Uhr rein, da ich den Schluessel
schon vorher habe, wann genau kann ich aber noch nicht sagen. Wir haben nur
einen Hallentrakt und zwar Trakt II, da die anderen schon fuer die Ferien
eingemottet sind, dafuer sind wir in der Zeit die Einzigen in der Halle und
koennen sie nach Gutduenken nutzen, also auch Basketball spielen. Den Ball
wird aber jemand mitbringen muessen, da ich nicht an die Geraeteschraenke
kommen werde. Wir muessen am Sonntag um 12:00 Uhr wieder aus der Halle raus
sein, dann kommt der Hausi und holt den Schluessel wieder. Er hat mich auch
explizit darauf hingewiesen, dass in der Halle das Rauchen und das Trinken von
Alkohol nicht gestattet sind. Er schlug vor, dafuer vor die Halle zu gehen
*g*. Ansonsten haften wir mit unserem guten Namen, aber das hat ja noch nie
gestoert :-)
Falls noch Fragen zur Halle sind, wendet euch an mich,

Areelanir

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



Ganz schoen wenig Anmeldungen... (Catweazle, 26. Mar 2004, 15:28:42):

So, jetzt haben wirs eine Woche vor der Party, und die Anzahl der Anmeldungen
stagniert seit laengerem bei 60. 

Das ist weit weniger als die Menge mit der ich geplant habe. Ich bin
ueberrascht, und zugegebenermassen auch einigermassen enttaeuscht, dass es so
wenig sind. Ich haette niemals erwartet, das weniger als 100 Leute zu einer
reinen MG-Party kommen. Ich kenn das eigentlich gar nicht anders. 

Das Treffen in Muenster ist schon als hundertprotzentige Party geplant, nicht
als Camp wo ein Haufen Dutzend Mudder Urlaub machen und nicht als
Zwischentreffen in nem Landheim mit beschraenktem Schlafplatz wo viel gespielt
wird.. 

Aber offenbar ist mit ner groesseren Sauf- und Fressparty kein Blumentopf mehr
unter den Muddern zu gewinnen, oder sie wollen die Gelegenheit nicht mehr
ergreifen sich untereinander mal kennenzulernen. Haette ichs geahnt, haette
ich keinen gescheiten Partyraum fuer bis ueber 150 Leute besorgt und keine
Schlafhalle noetig gehabt. 60 Leute krieg ich auch auf meinem Balkon unter,
ich merks mir fuers naechste mal, bevor ich mich in Unkosten stuerze.

Nun gut.
Ich habe versucht mit 15 Euro einen guten und verlockenden Preis zu machen,
das scheint sich aber nun boese zu raechen. 
Mit nur 60 Leuten kann ich nicht mehr viel reissen und muss Abstriche machen.
Am einfachsten ist die Seminar-Rubrik, es hat sich eh keiner gemeldet, der ein
Seminar halten will (muss ich mit dem Vereinsvorstand wg. mangelnder
Vorbeiretung schimpfen? Halt da bin ich ja auch beteiligt :-) ).
Das Fruehstueck in der Halle ist nicht mehr finanzierbar, Hallenschlaefer
muessen sich also morgens selbst versorgen. Sollte aber kein Problem sein,
direkt um die Ecke ist Gievenbeck-Zentrum (*huestel*). Wenns Zentrum auch
nicht gross ist, Baecker, Cafes und Supermaerkte haben die zu Hauf.
Ich hatte urspruenglich mal vor auch am Partyabend nur 15 Euro zu nehmen, das
ist nicht mehr moeglich, ich werde jeden Penny brauchen, daher definitiv 18
Euro Abendkasse. Wenn du 3 EUro spaern willst, solltest du dringend dieses
Wochenende noch ueberweisen. 
Schliesslich werden wir wohl einige kulinarische Gimmicks, die wie uns fuer
den Partyabend ueberlegt haben, wegstreichen muessen. 

Allen die nicht kommen kann ich nur ins Gesicht pfeffern, ihr verpasst eine
grossartige Gelegenheit :)

Yours truly,
     Catweazle

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



Party-Lotterie (Catweazle, 27. Mar 2004, 21:08:48):

Um moeglicherweise auftretenden Finanloecher zu finanzieren, hat sich
Orag-Team-Muenster entschlossen eine grosse 

                 P A R T Y - L O T T E R I E 

zu veranstalten!

Es gibt durchaus tolle Preise zu gewinnen, Hard- und Software, DVDs und CDs,
Audio und Video. Und das alles nur zum Lospreis von einem Euro. 

Die Lotterie wird auf dem Partyabend ausgelost. Lose koennen ausschliesslich
am Partywochenende in Muenster ersteigert werden. 

             Also lasst euch diese Chance nicht entgehen!
      Kommt zur Party und nehmt an der grossen MG-Lotterie teil!
  Beim Kauf von mehrfachen Losen steigt eure Gewinnchance entscheidend.
  Zum Beispiel beim Kauf eines zweiten Loses gleich um 100 Prozent!!!
          Jedes Los hat eine garantierte Gewinnmoeglichkeit!

Eure Orga-Team Muenster
   (i.A. des Party-Refinanzierungs-Notprogramm-Komitees)

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



Wetter (Catweazle, 30. Mar 2004, 16:40:35):
Moin!

Hiermit bestimme ich, das es am Partywochenende im Muenster warm (min. 18
Grad) und sonnig (mindestens 6h/tag)  wird!
So!

Der Bestimmer!

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



Notfallnummer (Catweazle, 30. Mar 2004, 17:37:13):
Fuer Notfaelle gibts eine Handynummer, die ihr anrufen koennt.

Hier eine Defaulterlaeuterung zu obigem Satz, der bisher immer gut
funktioniert hat:
Ich moechte das Wort Notfaelle in diesem Satz weiter erlaeutern. Ich hab keine
Lust staendig am Handy zu haengen, und irgendwelchen Pappnasen zu erklaeren,
wo die Colaflaschen gelagert werden, oder dumm gegruesst zu werden. Die Nummer
ist fuer Notfaelle bestimmt, wie zB ihr habt euch verlaufen, verfahren, wisst
nicht weiter, oder steckt in der Klemme. _Dann_ duerft ihr mich anrufen, aber
bitte auch nur dann.

Die Nummer ist +49 177 3212500.

Yours truly,
     Catweazle

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



Re: partytasse (Catweazle, 31. Mar 2004, 14:46:36):
~#! rn=Tasse rt=1079637986 rg=party.bekanntmachungen
~#! tid=1079637986
Moin!

Entgegen frueherer Versprechungen wird die Partytasse nun exakt 10 Euro
kosten. Dafuer ist sie voll spuelmaschinenfest. 

Du hast keine bestellt? Dummdas ....

YTC

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



RL-Quest (Catweazle,  1. Apr 2004, 10:14:51):

Moin!

Fuer all die, die erst Samstag ankommen:

Die RL-Quest findet Samstag nachmittag statt, ich schlag mal vor gegen 14:00
Uhr. dann bleibt genug Zeit um Aufzuwachen bzw. was zu Essen einzuwerfen.

Die als Stadtrallye geplante Quest fuehrt euch durch Muensters huebsche
Innenstadt, also gibts auch was zu sehen (ja, die Eisdiele haben wir direkt
ins Questprogramm mit aufgenommen :-)

Treffen ist vorm Schloss, und zwar direkt davor am Haupteingang (der auf der
Ostseite :-). Das sollte eigentlich jeder finden
(http://stadtplan.muenster.de).

I. A. des Quest-Komittees,
     Catweazle

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



Sommerparty Halle (Catweazle, 21. Apr 2004, 09:09:40):
~#! on=Catweazle ot=1074600186 og=party.bekanntmachungen
~#! on=Cassandra ot=1074004225 og=party
So nu mal Butter bei die Fische

Halle wird die Sommerparty machen
Zeit: Erste Augustwoche (2.-8.8.04)
Ort: Halle /Saale
     Zeltplatz (wie gehabt)

Weitere Infos, Wegbeschreibungen etc spaeter an dieser Stelle.

Cassy, im Namen des Partyorgateams-Halle

P.S. keine Angst diesmal schreib ich die Auto-Wegbeschreibungen nicht selbst

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



Sommerparty diverses (Cassandra, 19. Jul 2004, 15:16:25):
~#! on=Cassandra ot=1090242735 og=party

1. Lokation:
Die Lokation steht nun endlich fest. Spaet aber nicht zu spaet. Das ganze wird
im Huehnermanhatten-Club stattfinden.
Ecke Ludwig-Wucherer Strasse - Paracelsiusstrasse
Das ist nur ca 100 m von der alten lokation entfernt.

2. Partybetrag
Bitte nur den Partybetrag ueberweisen. Den Zeltplatz zahlt dann jder fuer sich
an der Schwimmbadkasse. 

3. Abendkasse
Der Betrag fuer die Abendkasse wird jetzt ebenfalls 20 Euro betragen. Ich
bitte euch jedoch trotzdem vorher zu ueberweisen.

4. Bungalows
Der Preis fuer den Bungalow bezieht sich jeweils auf den gesammten bungalow
pro nacht und ist somit durch die jeweilige anzahl derer zu teilen die dort
naechtigen (max 6 pro Bungalow)
nach bisherigen stand sind auch noch einige wenige Plaetze frei, dazu bei
interesse Mail an mich.
5. Sonntag-Mittag
Wir werden am Sonntag vorraussichtlich nicht zum Chinesen gehen sondern zum
Inder. Begruendung: Der Chinese ist zwar naeher aber dafuer auch nicht
besonders gut und abwechslung kann auch nicht schaden.

7. Wegbeschreibungen
Die wegbeschreibungen fuer die Bahnfahrer kommen noch, sind aber bis auf die
Preise fuer den OePNV mit denen vom letzten mal identisch. Autofahrer
benuetzen bitte eines der Fahrtenplaner-Programme im Netz (map24.de etc) da
ich kein auto hab um die strecke abzufahren und das beim letzten mal etwas
schief gegangen ist. Als adresse Pfarrstrasse eingeben nummer ist egal.

8. Alergien etc.
Falls jemand bestimmte sachen nicht essen darf und moechte das das eingeplant
wird, bitte an mich schreiben. Waer schade wenn jemand nix essen koennte weil
zum beispiel ueberall kaese drauf ist. (wird nicht der Fall sein)

So das waers erstmal.

Cassy, Partyorgateam Halle

P.S. Fuer rechtschreibung und Gramatik uebernehme ich keine Garantie 

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



Sommerparty (Cassandra, 19. Jul 2004, 15:27:25):
~#! on=Cassandra ot=1087483538 og=party
Erstmal einen grossen Dank an Humni fuer das promte aufstellen des
Partybrettes.

Weitere Infos, insbesondere zum Partyort am samstagabend werden so schnell wie
moeglich nachgereicht und dann auch der Preis. Orientiert euch solange an den
Preisen der letzten Halle-Party (20/25Euro). Wobei wir noch versuchen das
guenstiger hinzubekommen. (Ist von der Partylokation abhaengig)

Zum Zeltplatz
Die Preise sind dort noch die gleichen wie vor 2 Jahren
Also immer noch richtig niedlich
Preise jeweils pro Nacht:
Zelt    1Euro
Person  4,1 Euro
Ermaessigt 1 Euro (Kinder/Studenten)
Bungalow 20,50 Euro

Also erneut bitte nicht lachen und statt dessen fleissig unser schwimmbad
unterstuetzen
Wer nen Bungalowplatz moechte schreibt mir bitte Eine Mail. Es sind nur 2
vorhanden, vorrang wie immer fuer Eltern mit Kindern und ansonsten wer zuerst
mailt kommt zuerst.

Cassy, Partyorgateam Halle

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



wegbeschreibung (Cassandra, 23. Jul 2004, 13:22:04):
Wegbeschreibungen

1. 	Fuer Bahnfahrer
1.1 	Zum Zeltplatz
Vom Bahnhof durch den Haupteingang raus, links durch den Tunnel und in den
naechsten rein. In der Mitte sind mehrere Treppen, eine aussuchen und
hochgehen.
Oben angekommen Fahrkarten fuer die Strassenbahn kaufen:
Einzelfahrkarte:	1,50
4er Karte		5,20
Wochenkarte 		12,60
Wochenkarte Ausz.	 9,80 (Nummer des Studentenausweises eintragen)
Fuer die die nicht erst am Wochenende kommen wuerd ich die Wochenkarte
empfehlen.
 	Nun in die Strassenbahn Nr. 12 Richtung Trotha (letzte Bahn faehrt 19:52 ab
Riebeckplatz/Hauptbahnhof) bis zur Haltestelle Seebener Strasse fahren. Von
dort noch ein paar Meter in Fahrtrichtung gehen. Und dann links in die Strasse
am Nordbad. An der Schwimmbadkasse anmelden und Zeltplatz bezahlen.  Dann
entweder durch das Schwimmbad durch oder aber ueber die Pfarrstrasse zum
Zeltplatz. Die Pfarrstrasse ist die naechste Strasse die von der Hauptstrasse
links abgeht. An ihrem Ende geht eine Strasse nach links auf den Zeltplatz.
Wer spaeter ankommt nimmt die Strassenbahnen 7 (Richtung Kroellwitz) oder 2
(Richtung Goettinger Bogen) und faehrt bis zum Juliot-Curie-Platz, dort
Umsteigen in die 95 Richtung Trotha (Achtung haelt auf der anderen
Strassenseite) und faehrt dann bis zur Pfarrstrasse und laeuft dann hoch zum
Zeltplatz. Anmelden vermutlich am naechsten Morgen, da keiner mehr da ist.
Diejenigen die in Bungalows schlafen kommen am besten erst auf den Platz, da
nur einer den Bungalow zahlt und ihr das dann zwischen euch aufteilen muesst.
1.2	Strassenbahnfahrplaene sind unter
http://www.havag.de/verkehr/linien_fpl/linien_fpl.htm zu finden.
1.3	Zum Huehnermanhatten
Vom Zeltplatz mit der Linie 95 oder 12 (je nach Zeit) bis zur Lessigstrasse
fahren. Dann auf die andere Strassenseite wechseln und in die Fahrtrichtung
weiterlaufen. Am Gebaeude der Landwirtschaft vorbei und um die Ecke am Ende
der Strasse rum. Dort ist dann der Eingang. 
Rueckfahrt stuendlich mit der 95 Richtung Trotha

2.	Fuer Autofahrer
2.1	Zum Zeltplatz
Benuetzt bitte einen Routenplaner, da ich kein Auto habe um die Strecke
abzufahren.
Am besten am Schwimmbad parken. Bei tiefergelegten Autos nicht!!! In die
Pfarrstrasse fahren, da sehr unebenes Kopfsteinpflaster.
2.2	Allgemein ist fuer Autofahrer anzumerken, dass in Halle akute Parkplatznot
herrscht. Zudem sind einige Strasse immer noch Kopfsteinpflaster, wer ein
tiefergelegtes Auto hat sollte entsprechend darauf achten wo er langfaehrt.
Mein Tipp fuer Autofahrer ist, parkt das Auto am Schwimmbad oder in der Naehe
und benutzt ansonsten die oeffentlichen Verkehrsmittel.
2.3	Huehnermanhatten
Aufgrund der Parkplatzsituation wuerde ich davon abraten mit dem Auto hierhin
zu fahren und zur Strassenbahn raten. Wers denoch nicht lassen kann hier eine
Beschreibung:
Mit dem Auto Wieder raus auf die Hauptstrasse Richtung Innenstadt. Ueber die
Trothaerstrasse in die Reilstrasse (gehen ineinander ueber) bis zum Reileck.
Dort links ab in die Ludwig-Wucherer Strasse, am Ende dieser Strasse
beziehungsweise in den Nebenstrassen einen Parkplatz suchen. Erneut Vorsicht
bei tiefergelegten Autos.


Rechtschreib und Grammatikfehler duerfen behalten werden.

cassy

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



Re: wegbeschreibung (Cassandra, 23. Jul 2004, 13:23:02):
~#! rn=Cassandra rt=1090581724 rg=party.bekanntmachungen
~#! tid=1090581724
ja ich weis das das so kaum zu lesen ist, wer will dem schick ichs auch per
mail oder es findet sich wer ders auf die homepage stellt
Cassy

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



Wegbeschreibung, Kissen etc. (Cassandra, 26. Jul 2004, 13:40:44):

Wegbeschreibung, Hotelliste und die Kissen motive sind nun endlich auch auf
der Homepage abrufbar.
Der dank fuers einstellen geht an Zook.
Die schimpfe fuer die grossen dateinen an mich.

Cassy

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



Re: Wegbeschreibung, Kissen etc. (Zook, 26. Jul 2004, 14:08:20):
~#! rn=Cassandra rt=1090842044 rg=party.bekanntmachungen
~#! tid=1090842044
Direkt zum Draufklicken: http://mg.mud.de/Party/Party.26/

Wer die Bild-Dateien verkleinern kann und als .jpg oder so bereitstellen,
kann sich gern an mich wenden, dann stelle ich die auch noch ins Netz.

Zook.

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



Re^3: Wegbeschreibung, Kissen etc. (Zook, 26. Jul 2004, 14:20:13):
~#! rn=Zook rt=1090844215 rg=party.bekanntmachungen
~#! tid=1090842044
So, nun auch als kleinere JPG-Dateien betrachtbar. :)

Zook.

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



Notfallnummern (Cassandra, 27. Jul 2004, 13:24:13):
Hallo Partygaenger
Ich werde vermutlich am Montag so gegen 12 Uhr auf dem Zeltplatz auftauchen.
Wenn wer frueher kommt oder es sonst Probleme gibt,
unter 0179/4845376 bin ich die meiste Zeit erreichbar.

Beim Campingplatz bitte erst zur Schwimmbadkasse und bezahlen, dann runter auf
dem Platz. Zu diesem Zweck ist es ratsam vor 19 Uhr anzukommen. Wer spaeter
kommt muss sehen ob die Kasse noch offen ist und ansonsten zum Zeltplatz
runter und am naechsten tag bezahlen.

Cassy

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



Achtung: Partygeld (Mieze,  2. Aug 2004, 09:51:01):
Hallo zusammen,

wer bis jetzt noch nicht von Cassandra bestaetigt wurde und Geld fuer die
Party ueberwiesen hat: Bringt unbedingt einen Nachweis dafuer mit.

Mieze - im Auftrag von Cassandra

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



XXVII (Anatol, 12. Aug 2004, 22:49:33):
3.12. - 5.12., Winterburg.

Anatol

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



Re: XXVII (Zook, 13. Aug 2004, 09:21:56):
~#! rn=Anatol rt=1092343773 rg=party.bekanntmachungen
~#! tid=1092343773
Bretter aufgestellt.

Zook.

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



MG-Party XXVII: 0. Kurz und knackig (Anatol,  9. Okt 2004, 20:37:21):
Morgengrauen-Party XXVII 
''''''''''''''''''''''''

Die Party steigt am ersten Dezemberwochenende, d.h. vom
    |
    +-- Freitag (3.12.) bis Sonntag (5.12.) 
    |
    +-- im Schullandheim Winterburg bei Winterbach
    |
    '-- http://www.schullandheim-winterburg.de/


Kostenbeitrag 
    |
    +-- 44,44 EUR  (Abendkasse +5,56 EUR)
    |
    +-- 1903797 Adrian Holzwarth
    |
    '-- 620 500 00 Sparkasse Heilbronn


Obligatorische Mitbringsel
    |
    +-- Dreiteilige Bettwaesche (in der Burg gegen Gebuehr leihbar)
    |
    '-- Eine eigene Tasse / eigenes Glas o.ae.


Geplante Events
    |
    +-- Vortrag + AddOn ('Balance')
    |
    +-- Crashkurse ('Wiener Walzer', 'Disco Fox')
    |
    +-- Versammlung ('Morgengrauen e.V.')
   

Ausfuehrliches folgt.
Anatol


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



MG-Party XXVII: 1. Location (Anatol,  9. Okt 2004, 20:37:22):
Location
''''''''

http://www.schullandheim-winterburg.de

Die Party-Staette ist bei MG-Partygaengern eigentlich hinreichend
bekannt. Nichtsdestotrotz nochmal das Wichtigste in Worte gegossen.

Tief in der Pampa, wohlwollend 'Hunsrueck' genannt, liegt westlich
von Bad Kreuznach ein verschlafenes Dorf im Tal, Winterburg. Hoch 
darueber erhebt sich die ehemlige Buergermeisterei, jetzt als 
Schullandheim betrieben. 

Im Gebaeude stehen zwei Speisesaele, ein Seminarraum nebst Klavier,
ein Kaminzimmer und ein Freizeitraum mit Musikanlage zur Verfuegung.

Verteilt auf Erdgeschoss (10, 8) und dem 1. Stock (8, 4+6, 11, 8,
17) stehen uns 72 Betten zzgl. Lehrerzimmer zur Verfuegung, d.h. 
die Party ist, wie jede Winterburg-Winterparty in der Teilnehmerzahl 
begrenzt (im Zweifelsfall wird nach Anmeldung/Ueberweisungseingang 
entschieden). 

Die Bettenverteilung wird von Larina gemanagt, wer also Wuensche
hinsichtlich Wer-mit-wem-in-welchem-Zimmer hat, moege ihr eine Mail
schreiben.

Es ist dreiteilige Bettwaesche vorgeschrieben. Wer sowas nicht
besitzt (huh?) oder nicht mitschleppen moechte, kann sich solche
auch vor Ort leihen, kostet allerdings ein paar Euro.

Da die Kueche abends schliesst empfiehlt es sich fuer jene, welche
nicht aus Flaschen trinken wollen, ein eigenes Trinkgefaess (Glas,
Becher, Tasse, ...) mitzubringen.

Anatol


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



MG-Party XXVII: 2. Anfahrt (Anatol,  9. Okt 2004, 20:37:23):
Anfahrt
'''''''

Die Gemaeuer haben sich als recht ortsgebunden erwiesen, daher sind 
die Wegbeschreibungen der letzten Jahre noch immer gueltig. Wer es
grafisch mag kann neben Stoebern unter der oben genannten URL (es
gibt ein schoenes anfahrt.pdf dort) natuerlich auch einen ganz
gewoehnlichen Routenplaner wie map24 zu Rate ziehen (als Zielort 
macht sich Schlossborner Str., Winterburg recht gut).

Im Dezember kann sich ggf. der Besitz von Schneeketten auszahlen.

Fuer Freunde des oeffentlichen Personennahverkehrs, die keine
Mitfahrgelegenheit gefunden haben, endet der Service der Deutschen 
Bahn in Bad Kreuznach. Dort dann in einen Bus (242) und bei 
"Winterbach Kreuzung" (knappe Stunde Fahrzeit) aussteigen. Das 
letzte Stueck muss, wenn man niemanden zum Shuttlen ueberreden 
kann, dann zu Fuss gegangen werden. Zur Planung hilft: 

http://reisekauskunft.bahn.de

Da der Handyempfang auf der Burg bislang unglaublich schlecht
war, rechnet nicht damit, dass Partygaeste unter ihrer Mobil-
Telefonnummer erreichbar sind.

Anatol


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



MG-Party XXVII: 3. Events (Anatol,  9. Okt 2004, 20:37:24):
Events
''''''

Keine Party ohne Events. Diesesmal wird geboten:


- Vortraege:

    o Hinter den Kulissen der Balance (Humni)
      "Wieso dauert das so lange?!" dachten sich schon viele fleissige 
      Magier, die auf eine Antwort der Objekt-Balance gewartet haben. 
      Ein Insider erklaert, was da so passiert, bei der Objekt- und 
      bei der Gildenbalance.
    
    o Hinter den Kulissen der Balance - Comedy Add-On - (Humni)
      Tief in den Archiven der Objektbalance sind sie, zahlreich, die 
      schrecklichsten, abartigsten und verruecktesten Antraege, die 
      je gestellt aber nie genehmigt wurden. Unser Insider zerrt ein
      paar davon ins Rampenlicht. Ohne Nennung von Namen, natuerlich.


- Rhythmische Bewegungen zu Klang und Gesang

    o Crashkurse "Wiener Walzer" (Maharet) und  "Disco Fox" (Larina)
      Nicht nur fuer Leute, die auf eine Hochzeit muessen oder gar
      selbst heiraten wollen/muessen oder fuer Frauen, die davon 
      traeumen, dass Pierce Brosnan mit ihnen den Wiener Opernball 
      eroeffnet, sind Tanzfertigkeiten unerlaesslich. Unsere Grazien
      geben tapsigen Anfaengerfuesschen ein wenig Leitung, damit sich
      blauen Flecke an den Fuessen der TanzpartnerInnen in Grenzen
      halten. Vorsicht! Tanzen kann Spass machen!
     
      Wer an eine Teilnahme denkt, sollte passendes Schuhwerk dabei 
      haben. Moeglichst keine Hausschlappen, keine gummierten Sohlen.

      Das "Wann" und "Wie" wird natuerlich erst entschieden, wenn
      klar ist, ob und wieviel Interesse besteht. 
      

- MORGENGRAUEN e.V. Mitgliederversammlung (Sa, 17:00 Uhr)

    o Eingaben zu ausserordentlichen Tagesordnungspunkten sind
      willkommen. Detais dann zu gegebener Zeit in entsprechender
      MPA-Rubrik.


- Any Other Business? 
   
    o Bin nicht ueberall auf dem Laufenden. Kann sein, dass
      Montanus wieder eine Plaetzchenbacken-Orgie organisiert.
      Naeheres dazu ggf. von ihm.


Anatol


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



MG-Party XXVII: 4. Finances (Anatol,  9. Okt 2004, 20:37:25):
Finanzielles
''''''''''''

Ich freue mich, mitteilen zu duerfen, dass trotz Inflation 
und allgemeiner "Preisanpassung" der Partybeitrag stabil bei
EUR 44,44 pro Person geblieben ist.

Ueberweist dies bitte auf das folgende Konto:

         Kto   1903797           Adrian Holzwarth
         BLZ   620 500 00        Sparkasse Heilbronn

Vergesst den Mudnamen im Verwendungszweck nicht. :)

Wer erst vor Ort zahlen moechte, zahlt 5.56 mehr. Wenn jemand
nicht ueberweisen will, weil er sich nicht sicher ist, dass 
er ueberhaupt kommt, sage er das bitte vorher - damit wir nicht
zuviel Leute bei der Koechin anmelden. 

Sollte die Party tatsaechlich ueberbucht werden, tun wir
natuerlich was wir koennen, um moeglichst Wenige aussen vor
lassen zu muessen. Einen Platz sicher hat jeder, der ueberwiesen
hat und bestaetigt wurde.

Anatol


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



Re: MG-Party XXVII: 4. Finances (Montanus, 17. Okt 2004, 14:03:54):
~#! rn=Anatol rt=1097347045 rg=party.bekanntmachungen
~#! tid=1097347045
Plaetzchenbacken...

kann ich organisieren. Wenn Bedarf besteht.
Auf der anderen Seite wuerde ich *nicht* empfehlen, erst "Winterbach Kreuzung"
auszusteigen. Stattdessen haelt meistens auch der Bus unten im Dorf, also
"Winterburg Kirche", selbst "Winterburg Abzweigung Allenfeld" ist noch naeher
dran als "Winterbach Kreuzung" :-)
Es sei denn, man heisst Humni und hat eh noch seine Schiebkarre dabei.
*g*

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



Re: MG-Party XXVII: 3. Events (Shakedbeer, 20. Okt 2004, 22:13:13):
~#! rn=Anatol rt=1097347044 rg=party.bekanntmachungen
~#! tid=1097347044
Ich haette auch noch was vorzutragen...

ke
    o Making of PGI-Flash-Replay
      Auch wenn die Arbeiten auf der Grossbaustelle "Para-Gefaengnis-
      Insel" scheinbar nur langsam vorangehen, tut sich einiges hinter
      den Kulissen. Shakedbeer gibt exklusiv in Winterburg einen Ein-
      blick in die Technik und den Entstehungsprozess des grafischen
      Replay-Tools zur Quest. 

    o Welturauffuehrung: PGI-Trailer II
      Noch bevor der zweite Trailer im Netz steht, koennt ihr ihn live
      und in Farbe in Winterburg ansehen.

Shaky.

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



Re: MG-Party XXVII: 3. Events (Boing, 25. Okt 2004, 13:18:26):
~#! on=Grimmborn ot=1098702774 og=party
~#! on=Boing ot=1098701490 og=party.bekanntmachungen
~#! on=Grimmborn ot=1098701080 og=treffen
~#! on=Maharet ot=1098700956 og=party.bekanntmachungen
~#! rn=Anatol rt=1097347044 rg=party.bekanntmachungen
~#! tid=1097347044
Da mehrmals nachgefragt wurde:  Ich kann (auch) - wenn Zeit und Raum es
zulassen - Crashkurse in diversen anderen Taenzen anbieten.  Eine kurze
Mitteilung, an welchen Taenzen da Interesse besteht, waer nett, damit ich ggf.
entsprechende Musik mitbringen kann.
Zur Auswahl stehen die Turniertaenze, also Langsamer Walzer, Tango, Foxtrott,
Quickstep, Wiener Walzer (ist ja schon angesetzt), Rumba, ChaChaCha, Paso
Doble, Jive, Samba.
Ausserdem Tango Argentino und ein bisschen Salsa (oder auch Mambo).

LG Maha

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



Re: Re: MG-Party XXVII: 3. Events (Boing, 25. Okt 2004, 13:18:28):
~#! on=Grimmborn ot=1098702775 og=party
~#! on=Boing ot=1098701536 og=party.bekanntmachungen
~#! on=Grimmborn ot=1098701082 og=treffen
~#! on=Maharet ot=1098701054 og=party.bekanntmachungen
~#! rn=Maharet rt=1098700956 rg=party.bekanntmachungen
~#! tid=1097347044
Foxtrott ist natuerlich kein Turniertanz, jedenfalls nicht dass, was wir in
Deutschland unter Foxtrott verstehen.  Ich koennte auch Slowfox anbieten, aber
Foxtrott ist wohl angebrachter.

Maha

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



Asiate (Anysidora, 21. Nov 2004, 14:59:14):
Eine gute Nachricht fuer alle frueh buchen wollenden Bahnfahrer unter den
Partygaesten. Ihr koennt jetzt voll loslegen und euch die beste
Rueckfahrverbindung ab Bad Kreuznach raussuchen. ;)

Und fuer alle anderen: Freut euch, Great Khan ist gesichert, ihr koennt euch
dort also Sonntags froehlich in das Buffet stuerzen. :) (oder natuerlich in
die Karte, wenn wer kein Buffet mag ;))

Guten Hunger, Any* ;)

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



Hochzeitseinladung (Mesirii, 25. Nov 2004, 00:56:26):
Liebe Mitmudder,

um die Partybesuchszahlen von Winterburg etwas in die Hoehe zu treiben, opfern
wir unsere Unschuld und werden die Party mit unserer Hochzeit bereichern.

Die Gelegenheit bietet sich an, da wir so guenstig zu einer grossen 
Hochzeitsparty kommen.

Geheiratet wird am Samstag, dem 04.12.2004 um 12:30 im Standesamt Kirn (wo 
auch immer das sein mag), so dass wir nach dem gemeinsamen Mittagessen 
puenktlich zur Mitgliederversammlung des Vereins "Projekt Morgengrauen e.V." 
wieder auf der Burg sind.

Kommet zuhauf, wir werden auch das Abendbuffet aufpeppen!

Maharet & Mesirii

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



Hochzeits-Wiki (Mesirii, 28. Nov 2004, 23:50:03):
Zur Bekanntgabe von Informationen, Absprache von Mitfahrgelegenheiten,
Besucheruebersicht und so weiter, hab ich mal nen Wiki gebastelt.
Wen es interessiert, wer Fehler findet, MFGs anzubieten hat, usw.
User hochzeit PW: tina&micha
Danke
Mesi

P.S. Und da ich vergesslich bin: http://hochzeit.mesirii.de
*seufz*

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



MG-Party XXVII: 5. Nichts vergessen?! (Anatol,  3. Dez 2004, 08:49:20):


[ ]  dreiteilige Bettwaesche

[ ]  eigenes Glas bzw. Becher

[ ]  frische Unterwaesche

[ ]  Werwoelfe im Finsterwald und Co.

[ ]  Ausdruck des Reisewegs, falls unbekannt

[ ]  ggf. tanzfaehige Schuhe

[ ]  ggf. 50 Euro Partybeitrag

[ ]  ggf. non-schlabber-Kleidung 


Wir seh'n uns :)
Anatol

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



_K_eine Partyankuendigung (Catweazle, 10. Mar 2005, 12:33:32):
Moin!

Hiermit moechte ich bekanntgeben, das am Wochenende des 22. Juli _Keine_ Party
stattfindet.

Nur dass sich da niemand vertut ;-)

YTC

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



Party XXVIII (Miril,  5. Mai 2005, 20:12:34):
Hi Mitmudder!

Es ist soweit, die Sommerparty 2005 hat einen Partyort gefunden. Sie
wird diesmal im schoenen, gruenen Ruhrpott stattfinden (kein Witz). Der
Partyort ist Hattingen und wir haben einen netten Campingplatz direkt an
der Ruhr gefunden. Vor Ort gibt es zahlreiche Moeglichkeiten fuer Unter-
nehmungen, angefangen vom Schwimmen in der Ruhr, Paddeln, bei Interesse
Teilnahme an einem Surfkurs, Wandern, Radfahren oder kulturelle Dinge wie
Industriedenkmaeler besichtigen oder einfach nette Kneipen aufsuchen.

Die Party wird stattfinden vom

     24.7.2005 - 31.7.2005

Eine Vereinssitzung ist in diesem Zeitraum auch vorgesehen. Momentan sind wir
noch etwas unsicher mit der Auswahl des Partyraumes, es gibt zwei Optionen
und die Entscheidung fuer eine von beiden haengt ein wenig von der Teilnehm-
merzahl ab. Daher moechte ich euch bitten, euch moeglichst schnell anzumelden,
damit wir das sinnvoll festlegen koennen.

Partybretter werden in Kuerze von einem gewissen schwarzen Drachen aufgestellt
werden. 

Momentan rechnen wir mit einem Preis im Bereich von 20-25 Euro fuer die Party.
Den Campingplatz muesste jeder selbst abrechnen, Zelt kostet 3,5 Euro und
Erwachsene pro Tag ebenfalls 3,5 Euro. Wer Naeheres zum Campingplatz wissen
moechte, kann sich auf der Seite www.camping-hattingen.de informieren.

Das wars fuer Erste erstmal

Miril

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



Surfen (Miril, 10. Jul 2005, 09:23:51):
Fuer alle Surfinteressenten:
Es waere gut, wenn ihr schon am Sonntag anreisen koenntet (also am 24.).
Der Surfkurs faengt Montag um 9.00 Uhr an. Da es nur 5 oder 6 Leute waren,
koennten die auch eine Nacht bei mir verbringen (waere wohl etwas 
preisguenstiger ;)

Miril

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



Re: Surfen (Mieze, 10. Jul 2005, 09:27:39):
~#! rn=Miril rt=1120980231 rg=party.bekanntmachungen
~#! tid=1120980231

Ich kann auch noch 1-2 Leute aufnehmen fuer die Nacht vom Sonntag auf Montag.

Mieze - hat es diesmal wieder nah zur Party

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



Re: Re: Surfen (Taranis, 10. Jul 2005, 15:18:05):
~#! rn=Mieze rt=1120980459 rg=party.bekanntmachungen
~#! tid=1120980231
Ich koennte auch 1-2 Leute aufnehmen, falls Bedarf besteht. Waere allerdings
ueber ein paar Tage "Vorwarnzeit" froh. ;-)

Taranis, auch nur 15min entfernt wohnend vom Campingplatz.

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



Re: Surfen (Miril, 11. Jul 2005, 01:24:45):
~#! rn=Miril rt=1120980231 rg=party.bekanntmachungen
~#! tid=1120980231
Weitere Infos zum Thema Surfen:
Alle die daran teilnehmen, sollten alte Turnschuhe und Badezeug mitbringen.
Sonstige Ausruestung wie Neopren wird von der Surfschule gestellt.

Miril

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



Fuer die Taucher im Ruhrgebiet (Muadib, 13. Jul 2005, 09:36:46):
Hi,

ich habe mal nachgefragt, ob man dort auch tauchen kann. Hier die
vollstaendige Antwort:
"Tauchen ist hier nicht zu empfehlen, da hier alles recht undurchsichtig ist."

Schade

Muadib

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



Rettet Mirils Turm (Miril, 15. Jul 2005, 09:41:40):
Hi!

Wir planen fuer den Partysamstag (zwischen ca. 10 und 14 Uhr) eine RL-Quest.
Starten wird das ganze in der Kneipe "Zum weinenden Drachen" in Drachenhort,
wo sich alle Teilnehmer ca. um 10 Uhr versammeln muessten. Dort wird ein
kleines Fruehstueck angeboten, fuer das wir vor Ort einen kleinen Unkosten-
beitrag erheben werden. Einige PKW Besitzer muessten sich allerdings bereit-
erklaeren, die ganzen Interessenten an der Rettungsaktion dorthin zu karren.

Alle, die daran teilnehmen moechten und evtl. auch einen PKW zur Verfuegung
haben, moegen dies bitte Ruhrgebiet per mail mitteilen.

Miril, auf die Rettung ihres Turmes hoffend.

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



Neues zu den Tassen (Arathorn, 21. Jul 2005, 18:38:10):
Hallo zusammen,

ich weiss, dass das etwas kurzfristig ist, aber die Deadline fuer Tassen-
bestellungen ist HEUTE ABEND. ;-)

Alles, was ich nicht heute abend bekomme, kann ich nicht mehr rechtzeitig
vorbereiten, denn die CD mit den zu druckenden Daten muss morgen in der 
Druckerei sein.

Wer also eine haben will, bitte mit Motivwunsch an Ruhrgebiet mailen.
Wer sich kein Motiv aussucht, muss mit dem leben, das _wir_ dann aussuchen
werden. ;-)

Gruss, Arathorn.

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



Re: Neues zu den Tassen (Arathorn, 22. Jul 2005, 22:40:31):
~#! rn=Arathorn rt=1121963890 rg=party.bekanntmachungen
~#! tid=1121963890
So, nochmal zu den Tassen.

Was Euch sicher am meisten interessiert, ist der Preis. In zaehen 
Verhandlungen haben wir es geschafft, die Druckerei auf 9,50 EUR pro
Tasse runterzuhandeln.

Naja... Vielleicht verkaufen die die Tassen ab 10 Stueck auch ohne Verhand-
lung fuer den Preis... ;-)

Nun gut.

Jedenfalls wissen die Tassenbesteller jetzt, wieviel Taler ich gerne haette,
wenn sie ihre Tassen abholen. :-)

Gruss, Arathorn.

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



Termin Sommerparty 2006 (Zook, 22. Jan 2006, 00:35:26):
~#! on=Gnome ot=1137760957 og=party
hi,

da die herberge in brieselang jetzt schon anfragen von anderen gruppen
fuer anfang august bekommt, muessen wir das ganze etwas abkuerzen.

da sich bisher niemand deutlich gegen die die erste augustwoche
ausgesprochen hat, wird hiermit vom orga-team folgender termin
fuer die sommerparty 2006 festgelegt:

                            31.07.06 - 06.08.06

die website, auf der alle infos detalliert aufgelistet werden, wird
demnaechst (ca. 1-2 monate) ins netz gestellt. partybretter duerfen
natuerlich jetzt schon geclont werden.

es darf urlaub eingereicht werden. :)

gnOme

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



Re: Termin Sommerparty 2006 (Zook, 22. Jan 2006, 00:35:36):
~#! rn=Zook rt=1137886526 rg=party.bekanntmachungen
~#! tid=1137886526
Partybretter aufgestellt.

Zook.

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



15 Jahre Krautland (Miril,  1. Apr 2007, 22:54:21):
 Oder war's JRMud? Lang ist es jedenfalls her, seit der ersten denkwuerdigen 
 Party Nr.0, bei der wir unsere Zelte im Garten von Hyps Eltern aufstellten 
 und uns wueste Namen fuer das Spiel ausdachten, das ihr heute unter dem 
 Namen MorgenGrauen kennt. 
 
 Heimlich, still und leise hat das MG letzte Woche seinen 15. Geburtstag 
 gefeiert. Doch so einfach kommt es uns nicht davon, denn es wird eine 
 grosse Jubilaeumsparty geben, bei der es hoffentlich weniger leise und 
 heimlich zugehen wird. 
 
 Damit ihr diesen Surfurlaub im Sommer mit netten Grillabenden, Pen and
 Paper Rollenspiel, RL-Quest und vielleicht sogar einem Ausflug in das
 nahe Muenster zwecks Besichtigung historischer Orte schon jetzt planen 
 koennt, kommen nun die Daten:
 
 Wann: 23. - 29.7.2007
 
 Wo:   Unter der Bruecke, aeh ne war ein Scherz, ihr wisst schon der 
       nette Campingplatz von nebenan in Hattingen (Ruhr).
     
 Wer:  Moeglichst viele.
 
 
 Im Namen des Orgateams,
 Eure Uroma

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



Re: 15 Jahre Krautland (Mesirii,  1. Apr 2007, 23:14:03):
~#! rn=Miril rt=1175460861 rg=party.bekanntmachungen
~#! tid=1175460861
Hallo junge Familien,

wer von Euch mit den Kleinen nicht im Zelt schlafen will oder kann, hier eine
laengliche List von privat vermieteten Ferienwohnungen in Hattingen und
Umgebung. Vielleicht koennen wir uns da abstimmen und ggf. ein paar gemeinsam
nehmen.

http://stadtmarketing-hattingen.de/downloads/Prviatvermieterliste.pdf

Eine Bitte von uns. Bitte die Familien mit Auto nicht gerade die
Ferienwohnungen wegschnappen, die am naechsten am Zeltplatz liegen :)

Gruss Rana, Maharet & Mesi 

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



Re: 15 Jahre Krautland (Zesstra,  1. Apr 2007, 23:20:20):
~#! rn=Miril rt=1175460861 rg=party.bekanntmachungen
~#! tid=1175460861
Wollte noch was ergaenzen:
Die Entscheidung mag etwas abrupt erscheinen, ist sie aber eigentlich nicht.
Auch ist sie nicht an Danu vorbei getroffen worden, auch wenn sie gerade im
Urlaub ist. ;-)
Der Termin Mitte August war fuer einige problematisch, weswegen noch nach
Alternativen gesucht wurde. Danu hatte da z.B. auch noch einige Campingplaetze
im Netz angeguckt, die nun aber irgendwie auch nicht besser, sondern scheinbar
hauptsaechlich teurer waren.
Daher fragten wir in Hattingen bei der Betreiberin nun an und in der Woche
ging es noch (hatten ein bisschen Glueck sogar dabei).

Zesstra

P.S. Mesirii schrieb gerade waehrend ich schrieb, wollte gerade eigentlich
noch nen Hinweis auf Ferienwohnungen oder Mietwohnmobile fuer die, die gar
wirklich nicht zelten wollen, formulieren. Ich denk, da koennen wir vielleicht
auch noch weitere Anlaufadressen finden. (BTW: Der Stadteil Bochum-Linden ist
auf der anderen Seite des Campingplatzes, das geht anstelle von Hattingen auch
gut.)

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



Re: 15 Jahre Krautland (Mesirii,  2. Apr 2007, 00:02:10):
~#! rn=Miril rt=1175460861 rg=party.bekanntmachungen
~#! tid=1175460861
Uebernachten bei den Naturfreunden,

dank Zesstra gibt es noch diesen Hinweis auf ein Naturfreundehaus (mit
Fruehstueck).
die haetten in dem Zeitraum noch ca 26 Betten frei.

Unser Haus bietet seinen Gasten folgende Ausstattung:

    * Aufenthaltsraume fur 90, 50, 30, 20 und 10 Personen
    * Besonders geeignet fur Familienerholung, Gruppenreisen, Seminare,
Seniorenfreizeiten und Wanderubernachtungen
    * 70 Betten in Einzel, Zwei- und Vierbettzimmern mit fliesend Kalt- und
Warmwasser, uberwiegend mit Dusche und WC
    * Fernsehen
    * Videorecorder
    * Tageslichtprojektor
    * Leinwand
    * Pinwand
    * Tafel
    * Spiele
    * Tischtennisplatte
    * Kinderstuhlchen
    * Kinderbetten 

Man beachte die Pinnwand!

lt. google ca 5km strasse bis zum Campingplatz, aber lt. plan ist es direkt
kuerzer.

Adresse:
Naturfreudehaus Hedtberg
Herbergsweg 1
44789 Bochum-Dahlhausen

Tel.: 0234 49 41 63
Fax: 0234 9 41 11 83

Vielleicht koennen wir uns Familien da ja zusammentun und das gemeinsam
beziehen?

Von Zesstra: Vom Naturfreundehaus sind es etwa nen Kilometer nach
Von Zesstra: Linden zur Strassenbahnhaltestelle. Dort faehrt eine
Von Zesstra: Linie, die ziemlich genau am Campingplatz haelt.

Gruss Mesi


Ubernachtung mit Fruhstuck

Preise                          Einzelgaeste                    Gruppen ab 10
Pers.

Erwachsene                     20,45 bis 22,45*                19,90
Jugendliche (14 - 17)      17,80 bis 19,80*                17,10
Kinder (6 - 13)                14,20                           13,50
Kinder (3 - 5)                  10,70                           10,70


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



MG-Sommerparty: bitte anmelden, letzter Aufruf. ;-) (Zesstra,  9. Jul 2007, 22:02:38):
Huhu,

ich moechte euch nochmal, kurz vor Schluss, an die Anmeldung zur
MG-Sommerparty erinnern. ;-)
Speziell, wer am Partyabend was von uns organisiertes essen will, sollte sich
schnellstens anmelden und eine Mail an "essen" schreiben und das Geld an Miril
ueberweisen. (Hier sei auf Mirils Artikel in 'party' vom 15.6. verwiesen.)
Da wir uns nicht leisten koennen, einfach auf Verdacht irgendwelchen Kram zu
bestellen, werden nur angemeldete Leute beim Essen beruecksichtigt.
Und auch sonst waeren wir euch dankbar, wenn ihr euch nun anmeldet, falls ihr
kommen wollt, damit wir etwas besser planen koennen, auch bzgl. der RL-Quest,
die am Partytag morgens stattfinden soll.

Viele Gruesse,
Zesstra

P.S. Wer sich nicht sicher ist, ob er/sie kommen wird, schreibt uns am besten
ne Mail oder meldet sich an und vermerkt es im Partybrett unter den
Anmerkungen.

P.P.S Wer sich angemeldet hat und inzwischen sicher nicht kommt, meldet sich
am besten wieder ab. ;-)

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



Partytassen 2007: 'Black-Magic'-Tassen (Zesstra, 16. Jul 2007, 20:26:01):
Huhu,

so, ich hab einige Infos ueber die Partytassen. (s. auch Thread in party) Ist
leider sehr kurzfristig, aber die Planung kam erst gestern recht kurzfristig
mit Motividee in Fahrt.
Also, es gibt die sog. 'Black-Magic'-Tassen, das sind diese Dinger, die kalt
schwarz sind und beim Einfuellen eines heisses Getraenkes weiss werden.
Zusaetzlich sind die dann mit etwas bedruckt, was auf diese Art nur im heissen
Zustand sichtbar ist. (Nachteil: Diese Tassen sind nicht spuelmaschinenfest,
bzw. Handwaesche wird empfohlen!)
Wir kommen mengenmaessig in den Bereich, wo wir 11.99 pro Tasse bezahlen
muessen.
Als Motividee kam offenbar ganz gut an, zu den Urspruengen eines Muds zu
gehen: der Loginbildschirm. ;-) (Danke Shaeena)
Also, 2 Beispiele fuer ein solches Motiv findet ihr unter:
ftp://mg.mud.de/Party/Bilder/mvorschlag_schwarz.png
ftp://mg.mud.de/Party/Bilder/mvorschlag_weiss.png
einmal mit schwarzem Hintergrund und gruener Schrift und einmal mit weissem
Hintergrund und schwarzer Schrift. Schriftfarbe und der Charakter, der sich
einloggt, wird individualisiert.

Also, wer eine Tasse haben will, schreibt bitte bis Mi Abend eine Mail an
magictasse, jeweils mit folgenden Infos:
- gewuenschter Charakter (falls nicht Absender)
- Schriftfarbe (gruen, schwarz, rot, blau)
- Hintergrundfarbe (schwarz, weiss)
- Rechtshaender- oder Linkshaendertasse.

Bezahlen koennt ihr dann auf der Party bei Erhalt der Tasse.
Falls ihr nicht kommt und doch ne Tasse haben wollt, muesstet ihr mir das Geld
ggf. ueberweisen. In diesem Fall meldet euch bitte mit der Bestellung noch
wegen Zustellweg (ich mag ungern 10mal Pakete durch die Gegend schicken, wenn
das jemand dann zu euch mitnehmen kann (z.B. zu nem Stati), waere das toll.).
Achja, Ruecktritt ab Mi Abend gibts nicht mehr. ;-)

An dieser Stelle schonmal Dank an Ronda und Vanhelsing. :-)

Viele Gruesse,

Zesstra

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



Re: Partytassen 2007: 'Black-Magic'-Tassen (Zesstra, 19. Jul 2007, 22:24:14):
~#! rn=Zesstra rt=1184610361 rg=party.bekanntmachungen
~#! tid=1184610361
Huhu,

ich hab eine betruebliche Nachricht bzgl. der Tassen.
Arathorn scherzte gestern ja schoen, naechstes Mal wuerden wir die Tassen
einfach selber machen, scheint es nun so, als muessten wir das tun, wenn wir
sie noch rechtzeitig haben wollten.
Also: Der Anbieter, bei dem bestellt werden sollte, braucht (unverbindliche
Auskunft) bis naechsten Mi oder Do. Da die Tassen aber spaetestens am Freitag
bei jemandem hier zugestellt sein muessten, ist das Risiko zu hoch, dass dies
nicht klappt. Und ich moechte ungern auf >30 Tassen nach der Party hier sitzen
und sie alle einzeln versenden muessen.
(Auf der Homepage stand uebrigens Lieferzeit 4 Tage, das waere noch ok
gewesen.)
Ich hab heut nochmal hier vor Ort was versucht, aber nix gefunden, was
geeignet waere (z.B. Magictassen nur ab 150 Stueck).
Also, Endergebnis ist jetzt: fuer diese Party gibt es nun doch keine Tassen
(es sei denn, jemand kennt lokal bei sich einen geeigneten Drucker, der sowas
macht).
Ich werde alle Graphiken aufbewahren und vor der naechsten Party rumfragen.
Sollte es dann noch Interesse an einer solchen Tasse geben, kuemmere ich mich
rechtzeitiger drum.
Letzendlich: Es tut mir leid, eure Erwartungen enttaeuschen zu muessen, es war
vermutlich ein Fehler, das noch so kurzfristig anzuleiern. Ich war die letzten
Wochen auch etwas mit anderen Probleme abgelenkt und beschaeftigt und offenbar
ging es nicht nur mir so, sodass wir da zulange nicht genug unternahmen.

Viele Gruesse,
Zesstra

P.S. Die 1 oder 2, die nicht zur Party kommen wollten und mir das Geld schon
ueberwiesen hatten, kriegen es natuerlich sofort zurueck. ;-)

Zesstra

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



Re: Re: Partytassen 2007: 'Black-Magic'-Tassen (Kessa, 19. Jul 2007, 22:31:16):
~#! rn=Zesstra rt=1184876654 rg=party.bekanntmachungen
~#! tid=1184610361
Naja, die zuendende Idee kam halt auch erst spaet, noch schneller waer das nu
nicht gegangen. Danke dir fuer die viele Arbeit, Zesstra! Die ja nicht umsonst
war, machen wir das halt das naechste Mal. Ich will die Tassen jedenfalls auch
dann noch :)

Kessa, dann eben noch etwas laenger die Vorfreude geniessend

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



Winterburg 2007 (Anysidora, 21. Sep 2007, 15:19:22):
Langsam kommt das Jahresende immer naeher und es wird Zeit, sich ueber eine
Winterparty Gedanken zu machen. Ich habe mich mal mit der Winterburg in
Verbindung gesetzt und es sind wirklich noch 2 Wochenenden frei, an denen das
grosse Haus zu haben ist. Ich habe die beiden Termine jetzt erstmal
festgehalten und muss bis Ende des Monats bescheid geben, welchen der beiden
wir in Anspruch nehmen wollen. Deshalb haette ich gerne eine kleine Tendenz,
welcher Termin euch besser passt. 
Die Termine sind:
23.-25.11.2007 und 30.11.-02.12.2007

Also los, sagt was dazu. ;)

Any*


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



Probleme: WiBu-Party 2007 (Anysidora,  8. Okt 2007, 13:02:10):
Die WiBu-Party-Organisation macht so ein paar Probleme und ich bin mir im
Moment nicht ganz sicher, ob ich das Risiko, das damit in Verbindung steht,
auf mich nehmen will.
Fakt ist, dass ich mit denen einen Vetrag machen muss, der hoffentlich in den
naechsten Tagen in meinem Briefkasten landet, damit ich ihn endlich mal lesen
kann. Das waer ja kein Problem, wenn ich mich darin nicht verpflichten
muesste, dass wir mind. 30 Personen sind, die an dem Wochenende das grosse
Haus bewohnen werden. Diese 30 Personen muessen auf jeden Fall bezahlt werden,
egal, wieviele wirklich da sind. Wenn wir also nur 25 sind, dann muesste ich
diese 5 Personen aus eigenener Tasche bezahlen und das ist finanziell bei mir
nicht drin. 
Nun dachte ich mir, ich spreche einfach mal die Leute an, die Interesse an
einer WiBu-Party haben, was die dazu meinen. Sie wuerde am Wochenende vom
23.11.-25.11.2007 stattfinden. Es wird halt auch immer spaeter, wir haben
schon den 8.Oktober. Meint ihr, wir bekommen 30 Leute zusammen? Und was ist,
wenn es doch weniger werden? Ich weiss nur, dass ich am Ende nicht die Bloede
sein will, die alleine in der Scheisse sitzt, schliesslich will ich ja nicht
alleine die Party.
Wuerde mich freuen, wenn sich ein paar Gedanken machen wuerden. :) Weiterhin
faende ich auch gut, wenn die, die wissen, dass sie auf jeden Fall zur Party
kommen wuerden, mir das schonmal mitteilten, damit ich den Ueberblick habe,
wieviele das schonmal waeren. Vielleicht sind das ja doch mehr, als ich denke.
Zu allererst muss ich eh noch auf die Antwort vom Morgengrauen-Verein warten,
ob ich die Burg unter dessen Namen mieten darf. An Privatpersonen vermieten
sie naemlich nicht. (Ich frage mich echt, wie das sonst immer funktioniert
hat... das naechste mal machst du das wieder, Montanus ;))

Any*

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



Partybretter (Anysidora,  9. Okt 2007, 09:06:33):
Die Partybretter stehen. Es ist zwar immer noch nicht sicher, ob die Party
stattfindet, aber erstens hat so jeder einen gewissen Ueberblick, wieviele
kommen wuerden und zweitens wird es von der Zeit her langsam doch immer
knapper.

Any*

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



WiBU 2007 (Xutelius,  9. Nov 2007, 18:35:02):
Hi zusammen,

wir sind im Vorstand zu dem Entschluss gekommen das die Party ueber den Namen
vom Verein laufen darf. Ich weis es ist etwas knapp aber ich hoffe noch frueh
genug. Leider hatten wir den Vertrag ja erst seit dieser Woche vorliegen.

Das sollte ja eigentlich klar sein, aber der Vollstaendigkeit halber muss ich
nochmal drauf hinweisen das der Verein fuer _keine_ Kosten aufkommen kann die
entstehen. Sei es weil zu wenig Leute da sind oder das irgendwas beschaedigt
wird.

Jetzt bleibt nurnoch im Namen des Vorstands eine tolle Party zu wuenschen :-)

LG Xut*

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



partybretter (Anysidora,  9. Nov 2007, 19:23:35):
Wie einige ja vielleicht im vorangegangenen Artikel lesen konnten ist die
Vereinshuerde genommen und auch die 30 Mindestanmeldungen sind im Sack (wehe
es nimmt wer seine Anmeldung wieder zurueck ;)). Die Partybretter haben jetzt
den richtigen Partyankuendigungstext, es lohnt sich also evtl., das Brett
nochmal zu lesen.
Desweiteren hoffe ich ja, dass sich vielleicht doch noch der ein oder andere
am Wochenende entschliesst, auf der Party zu erscheinen, ich wuerde mich
freuen. :)

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



Partybeitrag (Anysidora,  9. Nov 2007, 19:25:42):
Ich moechte die Leute, die sich fuer die Party angemeldet haben bitten, mir
das Geld moeglichst bis allerspaetestens naechsten Freitag zu ueberweisen, da
ich dann die Anzahlung wegschicken muss. 

Danke, Any*

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



Diverses (Anysidora, 15. Nov 2007, 16:31:20):
Als erstes wollte ich noch einmal dran erinnern, dass diejenigen, die den
Partybeitrag noch nicht bezahlt haben, das bitte schnellstmoeglichst (am
besten heute ;)) tun moegen.

Weiterhin noch einmal als Erinnerung, vergesst nicht, euch einen Becher und
Bettwaesche mitzubringen (Schlafsaecke werden vom Burgpersonal nicht
toleriert).

Sollten Jemand unbedingt mit einer bestimmten Person/bestimmten Personen in
ein Zimmer wollen, so ist die Bestellannahmestelle weiterhin geoeffnet. Werden
keine Wuensche geaeussert muesst ihr mit euren Zimmergenossen und -genossinnen
auskommen. ;)

Ansonsten kann ich nur sagen, bringt gute Laune und genug Spiele mit. :)

Achja, da faellt mir noch ein, wenn jemand ein Feuerzangenbowleset haben
sollte waere es toll, wenn er es mitbringen koennte, ich werde wieder die
Zutaten besorgen.

Any*

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



Fruehjahrsparty 2008 (Mesirii, 14. Jan 2008, 00:13:33):
Liebe Mitmudder,

wir hatten ja ueber eine Fruehjahrsparty nachgedacht. Da wir in
Hattingen mit dem Naturfreundehaus gute Erfahrungen gemacht haben,
dachten wir uns wir koennen ja mal in der Richtung gucken.  In
Hannover ist das NFH mitten in der Stadt und trotzdem gruen gelegen.

Ich wuerde da nochmal wegen Anzahl der Familienzimmer nachfragen und
ggf. das mit den Gruppenpreisen klaeren. Ihr koennt ja aber schonmal
auf die Seite gucken und Eure Meinung dazu sagen.

http://www.harz-herbergen.de/Hannover/hannover.html

Mesi

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



1tes Stuttgarter InterMUD-Treffen (Tassram,  8. Feb 2008, 14:12:16):
Ich wurde von der Unitopia-Treffen-Orga gebeten, folgendes hier
bekanntzugeben:

     1tes Stuttgarter InterMUD-Treffen 30. Mai bis 01. Juni 2008.

Ja, Ihr habt richtig gelesen. Die Mudgemeinschaft in Deutschland wird
- wie wir alle wissen - leider nicht groesser. Die meisten Treffen
schrumpfen und einige Muds machen gar keine eigenen Treffen mehr, da
sich nicht ausreichend Leute dafuer finden. Deswegen haben wir
beschlossen, unserer Treffen auch fuer alle anderen Muds zu
oeffnen. Falls Ihr Fragen dazu habt, wendet Euch per Mail an
Treffen@UNItopia.de oder fragt auf D-Chat.

Mehr Infos und eine Anmeldeliste gibts unter
www.unitopia.de/treffen/index.html

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



Re^8: Herbst-Party in ... Wernigerode? (Gloinson,  3. Okt 2008, 12:02:16):
~#! on=Gloinson ot=1222963658 og=party
~#! rn=Humni rt=1222892322 rg=party
~#! tid=1217800900
Moin,

langes Gegammel, wenig Sinn (im Gegammel). Ich schlage vor, dass wir uns
am WE vom 21. - 23. oder 28. - 30. November in Wernigerode treffen:

http://www.jugendherberge.de/jh/wernigerode/

Ich habe mal endlich dort angerufen: man kann vor Ort DJH-Mitglied werden
und dann dort naechtigen/essen. Wer moechte, kann die Mitgliedschaft
auch bequem schon vorher beantragen:

http://www.jugendherberge.de/de/mitgliedschaft/mitglied_werden/index.jsp
- 21,- Euro pro Person/eheaehnlicher Gemeinschaft (Adresse)  >26 Jahre
- 12,50 <= 26 Jahre
* Gueltigkeit: wenn jetzt beantragt, bis Januar 2010

Kosten darueber hinaus sind +3,50 fuer Bettwaesche und:
Ue/Fruehstueck: 16,50 pP + 3 pP (>26) = Fr-So: 39,-
HP:             20,80 pP + 3 pP (>26) = Fr-So: 47,60
VP:             25,10 pP + 3 pP (>26) = Fr-So: 56,20

Summa summarum ist man also bei Vollfressverpflegung bei ~80 Euro. Nicht
wenig, aber komfortabel.

Die Cafeteria dort ist recht geraeumig und wird nicht mit irgendwelchen
Veranstaltungen belegt. Ist also von uns nutzbar.

Terminfindung wie ueblich am besten gestern und schnell, weil angeblich
ganz viele Leute dieses Jahr etc.pp.
Also wieder Doodle: http://www.doodle.ch/k763typczgty3qn4
Ich wuerde gern am WE vom 10. Oktober (in einer Woche) anrufen und
reservieren.

Gloin


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



Re^9: Herbst-Party in ... Wernigerode? (Gloinson, 13. Okt 2008, 20:34:49):
~#! rn=Gloinson rt=1223028136 rg=party.bekanntmachungen
~#! tid=1217800900
So. Ich hab mal fuer 12 Leute drei 4-Bett-Zimmer vom 21.-23.Nov. gebucht. Das
ist in Grenzen aufstockbar, offensichtlich ist das WE aus mir unbekannten
Gruenden unglaublich beliebt fuer andere Gruppen (gna).

Ich werd heute Abend nochmal schauen, dass ich das Partybrett aufgestellt
bekomme (sprich: muss Texte tippeln) damit mehr Leute was mitbekommen.


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



Re^10: Herbst-Party in ... Wernigerode? (Gloinson, 13. Okt 2008, 21:41:57):
~#! rn=Gloinson rt=1223922889 rg=party.bekanntmachungen
~#! tid=1217800900
Winterparty 2008 in Wernigerode
+++++++++++++++++++++++++++++++

     Moin! Dieses Jahr wird das Herbstwintertreffenpartydings
                        vom

             21.Nov 2008 - 23.Nov 2008

                      in der
              Jugendherberge Wernigerode
        http://www.jugendherberge.de/jh/wernigerode/

                    stattfinden.

Meldeschluss: 1. November, oder wenn die JH keine Raeume mehr frei hat.

Anreise:
* Freitag, 21.11. ab ca. 14 Uhr moeglich
* http://www.jugendherberge.de/jh/wernigerode/Anreise.htm
* 51049'33.84"N 10045'14.43"E

Kosten:
* 40,-  bis 60,- Euro Unterkunft (je nach Verkoestigung)
* 12,50 bis 21,- Euro DJH-Mitgliedschaft
  http://www.jugendherberge.de/de/mitgliedschaft/mitglied_werden/index.jsp

  Die Vorkasse wird noch genauer bekanntgeben.
  Abendkasse ist nicht bevorzugt, da 14 Tage
  vorher Buchungsschluss.

Verkoestigung:
- Essen:                     Fruehstueck/HP/VP je nach Preis inklusive
- Getraenke darueber hinaus: Selbstversorgung in der JH (Cafeteria)
- Bettwaesche nicht vergessen
  (kann fuer 3,50 Euro ausgeliehen werden, keine Schlafsaecke)

Prinzipiell sind 4-Bett-Zimmer gebucht. Fuer Familien gibt es einige,
wenige Familienzimmer, solange diese noch buchbar sind.

Fuer Rueckfragen schickt Gloinson eine Mail. Notfallnummer ist:
01577 / 159 8421


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



Re^11: Herbst-Party in ... Wernigerode? (Zook, 15. Okt 2008, 12:08:10):
~#! rn=Gloinson rt=1223926917 rg=party.bekanntmachungen
~#! tid=1217800900
Partybretter stehen an bekannten Stellen.
Zook.

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



Re^12: Herbst-Party in ... Wernigerode? (Gloinson, 27. Okt 2008, 11:30:09):
~#! rn=Zook rt=1224065290 rg=party.bekanntmachungen
~#! tid=1217800900
Partyanmeldungen sind hiermit bei mir geschlossen, da ich den Vertrag
abschicken muss. Alle weiteren Interessenten ueber die bei mir gemeldeten 8
Personen muessten sich direkt bei der JH melden und anmelden. Respektive bei
mir melden, falls noch so viele Leute zusammenkommen.


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



Re^13: Herbst-Party in ... Wernigerode? (Gloinson, 27. Okt 2008, 12:02:16):
~#! rn=Gloinson rt=1225103409 rg=party.bekanntmachungen
~#! tid=1217800900
Addendum fuer anderweitig Anreisende/Anwesende:

Prinzipiell haben die JH-Schlaefer HP. D.h. wir essen Fruehstueck und
Abendbrot in der JH. Mittags ist Selbstversorgung. Da die Stadt ganz
interessant ist und man auch prima wandern kann, duerfte das sinnvoll sein.
Am Samstag Abend hatte ich angedacht, in eine nahegelegene Studentenkneipe,
das "Blue" (www.meinblue.de) zu gehen. Bei 8 Personen ist das alles recht
unproblematisch. Falls also jemand spontan anreist und in Hotels naechtigt,
kann man sich ganz sicher irgendwie treffen.


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



Fruehjahrsparty + Vereins-Versammlung in Dresden (Mesirii,  2. Jan 2009, 00:15:59):

Gesundes Neues Jahr,

nachdem das letzte Jahr partymaessig ja nicht so berauschend war, die
Sommerparty ist wegen familiaerer Probleme der Organisation nicht zustande
gekommen und die Winterparty in Wernigerode war nur sehr duerftig besucht,
wollen wir im Neuen Jahr einen erneuten Versuch starten.

Da ich jetzt in Dresden die Moglichkeit habe, fur die spartanischen Schlafer
eine kostenfreie Unterkunft zu bekommen, und einen Raum habe, in dem man die
Party machen kann, moechte ich vorschlagen, eine Wochenend-Party +
Mitgliederversammlung in Dresden abzuhalten.

Terminlich denke ich, ist Mitte Februar bis Maerz drin (Vorlaufzeit fuer
Vorbereitungen und Einladungen).

Hier ist ein Doodle-Abstimmungs-Link fuer den Termin, bitte dort Eure
Verfuegbarkeit, und Kommentare eintragen.
http://doodle.com/participation.html?pollId=97y5qffxxexbmked

Kommet Zuhauf

Mesi

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



Sommerparty 2009 (Gloinson,  6. Jan 2009, 13:40:54):
Hallo,

nachdem Mesirii schon vorgelegt hat, hat mich Guard geschubst, doch auch
schnell die Terminumfrage f|r die Sommerparty anzustossen, solange ihr
doch schon den Browser aufhabt.
Hier also mal die kompatiblen Wochen/Wochenenden im Juli und August:

http://doodle.com/yrc3dfdqvxbi82cr

Wir Berliner suchen (bis etwa Ende Januar) einen partykompatiblen Ort
bei Berlin. Dabei sind Familienkompatibilitaet (feste Unterkuenfte)
und Erreichbarkeit mit dem Nahverkehr sehr wichtig. Hilfe ist
willkommen, ob nun hier oder in den Kommentaren der Doodle-Seite.

(Brieselangs finanzielle Konditionen sind leider nicht so vorteilhaft,
 die Mietung des gesamten Komplexes auf Vorrat lohnt nicht.)

Die letzte Sommerparty in den 0er-Jahren diesen Jahrhunderts! Eine
einmalige Gelegenheit! Ork-Orgien bei Vollmond!

Falls wir hier in Berlin partout nichts finden sollten, nehmen wir
die Umfrage als generelle Terminfindungsumfrage fuer andere Partymacher.
Also, tragt euch ein :)

iA Gloin


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



Fruehjahrsparty in Dresden am 28. Maerz (Mesirii, 31. Jan 2009, 01:59:35):
Doodle hat gesprochen :) Es haben sich 21 Leute fuer den 28. Maerz angemeldet
Sorry fuer diejenigen von Euch die an diesem Termin nicht koennen.
Wir werden demnaechst die Partybretter aufstellen, MV-Mitglieder per E-Mail
und Post benachrichtigen und alle Sicherheitsvorkehrungen in die Wege
leiten.
Kommet zuhauf
Mesi

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



Re: Fruehjahrsparty in Dresden am 28. Maerz (Ennox,  3. Feb 2009, 00:55:39):
~#! rn=Mesirii rt=1233363575 rg=party.bekanntmachungen
~#! tid=1233363575
Partybretter sind aufgestellt. Es ist preiswert :) Kommt alle.
Mesi

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



Re: Re: Fruehjahrsparty in Dresden am 28. Maerz (Ennox,  3. Feb 2009, 23:45:37):
~#! rn=Ennox rt=1233618939 rg=party.bekanntmachungen
~#! tid=1233363575
MG-Merchandise: Ich koennte bei Interesse, aus Acryl gelaserte MG-Drachen
produzieren lassen und MG-Logos/Karten whatever auf Lego oder andere
Dinge drucken (Beispiele siehe: http://print-on-things.com).
Meldet mal Euer Interesse an.
Mesi

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



Partydetails (Mesirii, 23. Mar 2009, 02:18:41):
Partydetails

Hallo Mitmudder,

sorry, dass die Infos erst so spat kommen, aber ich war eine Woche in London
und hatte letzte
Woche Stress :)

Hier nochmal die Planung

Freitag:
Ankunft tagsuber, Sachen abladen im Blauen Haus
Ab 18:30 schrag uber die Strasse an der Elbe beschaulicher Abend im
"Johannstadter" (http://www.johannstaedter.de).

Samstag:
Fur die Ubernachter im blauen Haus Fruhstuck von 8:00 - 12:00. Unkostenbeitrag
mit Kasse des Vertrauens :)

Ich muss sehen, ob ich noch die RL-Quest zusammenbekomme, war ein Revival der
von 2000, mit Aktualisierung der 
Punkte, die es nicht mehr so gibt (ca die Halfte).
Die ware dann von 11-15:00.
Ansonsten Rumtreiben in der Stadt / Zoo. Wenn Interesse besteht, kann ich fur
den Samstag auch eine Besichtigung der
Dresdner VW Manufaktur anfragen.

Ab 16:00 Vereinsversammlung in der Buchbar (http://die-buchbar.de). Ich
versuche mich kurz zu fassen, dann schaffen wir das sicher bis 18:00.
Ab 18:00 Party bis wir keine Lust mehr haben. Verpflegungstechnisch wirds
Pizza geben.

Am Sonntag fruh gibts ggf. die Reste vom Samstagsfruhstuck.
Ab 12:00 bis 14:00 gibts im Cuchi am Wallgasschen Sushi + asiatische Speisen
"All You Can Eat".

Dann trauriges Verabschieden bis zur nachsten Party.

Locations:
** Blaues Haus - Schlafsaal -
Florian Geyer Str. 13, An der Elbe, ehemaliger Kindergarten
Ich bin da am Freitag tagsuber dort um die Ankommlinge engegenzunehmen.
Autos konnen auf dem Gelande parken

** Johannstadter (http://www.johannstaedter.de)
Familienkneipe an der Elbe, Kathe Kollwitz Ufer 19b
http://www.johannstaedter.de/anfahrt/anfahrt.html

Schrag gegenuber vom Blauen Haus, also am Abend fur die Betrunkenen und "Zu
Spat Kommenden" kein Problem mit der Erreichbarkeit.

** Die Buchbar, Mesi's Ladenspielekneipe (http://die-buchbar.de)
Dresdner Neustadt, Alaunstr 66/68 HH (Sonnehof, hinten rechts).
Erreichbarkeit
Straba 3, 6, 7, 8, 11 Albertplatz, schrag uber die Strasse die Alaunstr nach
oben reinlaufen
oder Straba 13 Alaunplatz dann nach unten die Alaunstr. reinlaufen
Hinter dem blauen Schild mit der organgenen Kuh ist das der nachste Eingang.
Ich werde den MG-Aufsteller auf die Strasse stellen.
Autoparkplatze sind in der Neustadt schlecht, meist Privatparkplatze gegen
Geld

** Cuchi Dresden, Sushi + Mehr (http://www.cuchi-dresden.de/)
Wallgaschen 5, 01097 Dresden
Erreichbarkeit per Straba 3, 6,7, 8, 11 Albertplatz nach unten in die
Konigsstr laufen
alternativ 4 Palaisplatz dann aber nach oben in die Konigsstr laufen
ist etwas versteckt in der Nahe der Kirche. Das Wallgasschen geht von der
Konigsstr nach Westen ab.
Soweit erstmal
Mesi

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



Sommerparty in Wetzlar (Srabi, 23. Mar 2009, 16:23:02):
So meine Lieben,

nachdem Berlin als Ort wegfaellt, uebernehme ich mal das Ruder der
Partyplanung fuer die Sommerparty in Wetzlar.

Am besten waere ein Wochende im Juli. Bitte MAILT mir mal, wenn Ihr so Zeit
habt, damit ich mal ne grobe Uebersicht erstellen kann.

Fuer alle Bahnfahrer: Wetzlar hat einen Bahnhof und liegt auf der Strecke
Giessen-Koeln.
Fuer alle Autofahrer: Wetzlar hat direkten Anschluss an die A45.

So nun munter Mailen, damit ich anfangen kann zu planen. 

Srabi

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



Link zur Terminplanung (Srabi, 23. Mar 2009, 16:34:42):
Also,

nachdem mich einige nach Doodle verwiesen habe, ist dann hier der Link zur
Terminplanung der Party.

http://www.doodle.com/participation.html?pollId=viqf4sadb22d665d


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



Re: Sommerparty in Wetzlar (Vector, 27. Mar 2009, 15:23:54):
~#! rn=Srabi rt=1237821782 rg=party.bekanntmachungen
~#! tid=1237821782
verlaengertes wochenende oder komplette woche durch?
wenn komplette woche dann frag ich mal vorsichtig schon
nach wlan :)

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



Partyfotos (Mesirii, 30. Mar 2009, 22:28:42):
Da Zesstra auf der Party erzaehlt hat, dass zur Zeit in /var kein Platz fuer
Partyfotos ist und diese daher draussen bleiben muessen, werde ich mal 
den Part uebernehmen.
Im Wiki gibts schon eine Seite dafuer, das Foto von Gnome war das erste.
Zu finden dann unter:
http://wiki.morgengrauen.info/index.php?n=MorgenGrauen.Parties
Ich habe auch einen incoming-user auf dem server angelegt um die Fotos
hochzukopieren.
Hier nicht per ftp sondern scp/sftp:
scp incoming@wiki.morgengrauen.info
Passwort ist der Name unseres Seher/Magier-Erhoehe-Onkels.
Ich werde dann moeglichst zeitnah das script auf die Partyfotos werfen und
diese bereitstellen.
Gruss Mesi
P.S. scp fuer windows - Nutzer mit WinScp

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



Re: Partyfotos (Amaryllis, 30. Mar 2009, 22:33:29):
~#! rn=Mesirii rt=1238444922 rg=party.bekanntmachungen
~#! tid=1238444922
Die URL ist kaputt.

Ama*

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



Re: Re: Partyfotos (Mesirii, 30. Mar 2009, 22:34:11):
~#! rn=Amaryllis rt=1238445209 rg=party.bekanntmachungen
~#! tid=1238444922
wenn die ip umgestellt ist, dauert noch dns-timeout
Mesi

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



Party in Wetzlar (Srabi,  6. Apr 2009, 09:02:45):
Hi Mudder,
hier ist noch einmal der Link fuer die Terminabstimmung fuer die diesjaehrige
Sommerparty in Wetzlar:

http://www.doodle.com/viqf4sadb22d665d 

Bitte stimmt fleissig mit ab, denn je mehr Leute kommen koennen, desto besser
:-)

Euer Hexenmeister Srabi von Angmar

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



Sommerparty in Wetzlar (Srabi, 16. Apr 2009, 08:42:18):
Hi Ihrs,

nun kann ich Euch schon mal Angaben ueber Zeit und Ort der Sommerparty in
Wetzlar nennen.

Zeit: 24.07.2009 bis 26.07.2009
Ort: Wetzlar Dutenhofen (Campingplatz)

Wenn Ihr Euch mal einen ersten virtuellen Eindruck ueber den campingplatz
verschaffen wollt, koennt Ihr dies gerne tun.

http://www.dutenhofenersee.de

Nach Ruecksprache mit dem Betreiber des Platzes bekommen wir eine abgelegene
Parzelle und koennen das dortige WLAN kostenlos nutzen.
In kuerze werden von Zesstra die Partybretter aufgestellt.
Dutenhofen liegt ca. 3 km von Wetzlar enfernt, besitzt einen Bahnhof und auch
einen direkten Autobahnanschluss.

So, das waren die ersten Informationen, weitere folgen in kuerze.

Hexenmeister Srabi von Angmar

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



Re: Sommerparty in Wetzlar (Zesstra, 16. Apr 2009, 22:07:43):
~#! rn=Srabi rt=1239864138 rg=party.bekanntmachungen
~#! tid=1239864138
Partybretter zur Anmeldung stehen an den ueblichen Orten ab jetzt.

Kommet zuhauf!

Zesstra

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



Party in Wetzlar (Srabi, 18. Apr 2009, 10:40:16):
Also...

die Umfrage bezueglich des Termins ist AB SOFORT micht mehr online. Seit 2
Tagen sind die Partybretter fuer die Sommerparty in Wetzlar scharf (Zitat:
Zesstra) und ich bitte um zahlreiche Anmeldungen :-)

Fragen beantworte ich euch gerne ueber Mail oder auch ueber tm.

Also ran an die Bretter und anmelden bis die Finger gluehen...(jeder aber
bitte nur einmal!)

Euer Organisator Srabi

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



Partyanmeldungen fuer Wetzlar (Srabi, 20. Apr 2009, 15:30:14):
Hi Partypeople,
also bitte meldet Euch mal langsam fuer die Party an, denn da ich langsam mit
den Planungen anfangen muss, braeuchte ich mal langsam eine ungefaehre Zahl
der Anmeldungen. Leider haben sich bis jetzt erst 5 Leute auf dem Partybrett
angemeldet und ich denke, das es nicht bei diesen 5 bleiben wird.

Da ich Schlafplaetze und Partylocation schon gefunden habe, waere ich langsam
ueber eine ungefaehre Teilnehmerzahl echt dankbar. Ich kann schlecht den
Leuten sagen, wir kommen mit ca. 5 bis 15 Leuten. :-)

Wenn Ihr Fragen habt, dann fragt einfach, Antworten geben ich Euch gerne.

LG
Partyplaner und Hexenmeister Srabi von Angmar

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



Party in Wetzlar (Srabi, 27. Apr 2009, 17:42:51):
Also noch einmal ...

da ich ne genaue Zahl der Personen brauche, um das mit dem Platzbesitzer
abmachen zu koennen, benoetige ich Eure Anmeldungen. Ihr koennt gerne schon ab
dem 20.07. anreisen, die Party ist am 25.07.

Partybretter sind ja bekannt wo die stehen. Bitte bei Uebernachtung dann
einfach den Wunsch einer festen Unterkunft vermerken, das ich PLANEN kann.

Srabi

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



Oertliche Verlegung der Party (Srabi,  5. Mai 2009, 17:08:51):
Hi Leute,
da der Campingplatz am Dutenhofener See wegen doppelten Buchungen fuer uns
leider nicht mehr zur Verfuegung steht, wird die Party einfach mal verlegt.

Neuer Ort: Campingplatz Wetzlar

Auch hier koennt Ihr Euch einen virtuellen Eindruck verschaffen:
http://www.campingplatz-wetzlar.de

Leider kann dort mit Ferienwohnungen nicht gedient werden, aber die
Moeglichkeit besteht, das man sich einen Wohnwagen mieten kann.
Wenn jemand allerdings unbedingt in eine noch festere Unterkunft moechte,
bitte bei mir per Mail melden.

Auch auf diesem Campingplatz haben wir eine Ecke fuer uns alleine und ein
gemauerter Grill ist ebenfalls vorhanden :-)

Eure Anreisedaten bleiben alle wie sie sind...NUR DER ORT WIRD VERLEGT.

Unannehmlichkeiten bitte ich zu entschuldigen.

Srabi

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



Party am Wochenende 10. April (Mesirii, 30. Jan 2010, 22:03:07):
Da ihr Euch jetzt mit der Mehrheit (19+Vanir) fuer den 10. April entschieden
habt, findet die MG-Fruehjahrsparty dann statt.
Alles wie gehabt, ich organisier was besseres fuer Freitag Abend, bei Fragen
an mich, teuer wirds nicht.
MG-Vereins-Einladungen organisiert Guard.
Kommet zuhauf.
Mesi

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



Re: Party am Wochenende 10. April (Ark, 30. Jan 2010, 23:49:48):
~#! rn=Mesirii rt=1264885387 rg=party.bekanntmachungen
~#! tid=1264885387
Hm, "dummerweise" ist da jetzt meine weite Reise fuer dieses Jahr, hat sich
aber auch erst herauskristallisiert. Deshalb: -1.


              *** ARK * the * Magnificent ***


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



Re: Re: Party am Wochenende 10. April (Vanhelsing, 10. Feb 2010, 00:52:16):
~#! rn=Ark rt=1264891788 rg=party.bekanntmachungen
~#! tid=1264885387
Huhu auch von mir.
Ich wuerde gerne auch hin, nur ist mein Job etwas doof. Koennte erst Freitag
nachmittag los. Und Zuege lohnen da nich, und Fluege sind zu teuer.
Wenn einer aus meiner Gegend die Moeglichkeit haette, mich (und auch Yuli)
mitzunehmen, waeren wir froh. Genauere Zeiten koennen wir ja dann noch
klaeren. ;)
CU
VH
P.S. Gebiet ist Ddorf (wer fragt)

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



Terminsuche fuer die Sommerparty in Brieselang (Gloinson, 10. Apr 2010, 18:12:09):
Huhu!

Mesirii und Cakey haben sich bereit erklaert, die Sommerparty in Berlin /
Brieselang dieses Jahr in Juli/August zu organisieren. Bitte helft den
beiden, indem ihr euch an der Terminfindung beteiligt, damit die beiden
sicher planen koennen:

http://tinyurl.com/brieselang
http://www.doodle.com/tz8dzcnqarbpye3r

Brieselang wurde von uns schon mehrmals be-/heimgesucht, bietet 
familienkompatible Bungalows (die aber sicher gebucht werden muessen),
einen tollen Zeltplatz am Wald, einen Volleyballplatz und einen See,
von dem Vanion noch Wochen danach schwaermte.

Google Maps:
http://tinyurl.com/brieselangmap


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



Re: Terminsuche fuer die Sommerparty in Brieselang (Zesstra, 12. Apr 2010, 22:55:33):
~#! rn=Gloinson rt=1270915929 rg=party.bekanntmachungen
~#! tid=1270915929
Hinweis zur Abstimmung fuer Leute, die noch keine MG-Party besuchten: Die
Party wird am angebenen WE am Samstag sein, die gemeinsame Zeltwoche in der
Woche _davor_.

Zesstra

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



Sommerparty Brieselang 31. Juli - wie wollt ihr schlafen (Mesirii, 12. Mai 2010, 23:07:49):
Moin,
nachdem die Doodle Ergebnisse jetzt schon eine Weile feststehen, haben wir mit
der Platzleitung in Brieselang gesprochen.
Der August-Termin ist leider schon mit einem Ferienlager belegt, auch die
ganze Woche davor.

Fuer den 31. Juli ist aber noch alles frei, sie werden es uns bis Montag frei
halten, bis dahin muessen wir uns festlegen, wer wie wo schlafen will.

Daher benoetigen wir dringend bis Sonntag Abend Eure Rueckmeldung, ob Ihr
* im Zelt
* im Bungalow
* im Familienbungalow uebernachten wollt.

Und von wann an ihr plant nach Brieselang zu kommen.

Vielen Dank

Mesi, der sich schon ganz doll drauf freut

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



webseite brieselang (Mesirii, 12. Mai 2010, 23:44:54):
http://herbergezumbrieselang.de/

Mesi

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



partyinfos (Ennox,  2. Jul 2010, 00:44:44):
Sommerparty 2010 in Brieselang                                                
 
+++++++++++++++++++++++++++++++                                               
 
                                                                             
 
Das diesjaehrige Sommer-MG-Camp findet mal wieder                             
 
in Brieselang bei Berlin statt.                                               
 
Vom 26. Juli bis zum 1.August koennt Ihr Euch da tummeln.                     
 
                                                                             
 
Preise und Infos zur Herberge hier:                                           
 
http://www.herbergezumbrieselang.de/                                          
 
                                                                             
 
Wir haben fuer die Leute die sich bei Doodle angemeldet                       
 
und uns die Unterkunftswuensche (Bungalow, Zelt) geschickt haben,             
 
entsprechend reserviert.                                                      
 
                                                                             
 
Anreise:                                                                      
 
* Montag bis Samstag, je nach Doodle Anmeldung ist reserviert                 
 
                                                                             
 
Kosten:                                                                       
 
* Abrechnung der Uebernachtungs und Fruehstueckskosten individuell            
 
  mit der Herberge                                                           
 
* Party: noch unbekannt, wird dann direkt eingesammelt                        
 
                                                                             
 
Planung:                                                                      
 
- Woche: Entspannung & Urlaub                                                 
 
- Samstag Abend: Party                                                        
 
- Sonntag: Mittagessen und Abreise                                            
 
                                                                             
 
bisher sind noch keine Vortraege oder aehnliches geplant, wer                 
 
Interesse oder Themen hat, her damit                                          
 
                                                                             
 
Wir haben als diesjaehriges Party-Mitnehmsel ein Besteck mit individueller    
 
Namensgravur angedacht, wer ein solches moechte (Kosten muss ich noch klaeren,
 
um die 10-12 EUR) melde sich bitte bei Mesirii.                               
 
                                                                             
 
Fuer Rueckfragen schickt Mesirii oder Cakey eine Mail. Notfallnummer ist:     
 
0176 / 21 60 49 10                                                            
 
                                                                             
 
Kommet zuhauf                                                                 
 
                                                                             
 
Mesi                                                                          
 
 .

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



Re: partyinfos (Zesstra,  3. Jul 2010, 22:12:07):
~#! rn=Ennox rt=1278024284 rg=party.bekanntmachungen
~#! tid=1278024284
Es gab zumindest zeitweise und zumindest in der Abenteurergilde 2
Partybretter, davon eines fuer die letzte Fruehjahrsparty in Dresden. Ich hab
da mal aufgeraeumt (wenn wir irgendwo 2 stehen, bitte Bescheid sagen), aber
vielleicht solltet ihr nochmal nachgucken/nachdenken, ob ihr euch
versehentlich fuer die falsche Party angemeldet habt. ;-)

Zesstra

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



Re: Re: partyinfos (Zesstra,  3. Jul 2010, 22:24:41):
~#! rn=Zesstra rt=1278187927 rg=party.bekanntmachungen
~#! tid=1278024284
Offenbar hatte ich das Problem unterschaetzt. Durch die doppelten Bretter
wurden die aktuellen Anmelderdaten durch die alten aus Dresden ueberschrieben.
Tut mir jetzt furchtbar leid, aber wer sich fuer Brieselang angemeldet hat,
muss das jetzt nochmal tun. :-(

Zesstra

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



Fruehjahrsparty 2011 in Dresden (Mesirii, 30. Jan 2011, 22:47:01):

Moin,
Ich wuerde gern wieder eine Fruehjahrsparty machen. Zum einen wegen
Vereinsversammlung
zum anderen weil ich Euch alle gern mal wiedersehen will. 

Leider ist mir die Uebernachtungsmoeglichkeit im blauen Haus abhanden
gekommen, da mein
Freund Mattcher da jetzt mit Grossfamilie eingezogen ist.

Sylvia, die Betreiberin meiner Buchbar hat mir zwei Hostels der Neustadt
empfohlen.
Einmal 3min von der Buchbar weg: http://www.lollishome.de/ 
die haben nette preise, auch ein Appartment in dem man mit 8 Leuten fr 100,-
schlafen kann.
(sollten wir nur rechtzeitig kommen)

Ausserdem noch: http://www.mondpalast.de

Ich hab auch noch einen Doodle Link aufgesetzt, bitte in den Kommentar
schreiben, wie ihr
uebernachten wollte: http://doodle.com/tzgh3xcbymkmemy8


Ich freu mich

Mesi

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



Re: Fruehjahrsparty 2011 in Dresden (Tassram, 31. Jan 2011, 15:49:28):
~#! rn=Mesirii rt=1296424021 rg=party.bekanntmachungen
~#! tid=1296424021
http://www.lollishome.de/ wirbt damit, dass dort keine Gruppen
uebernachten, sollte man nochmal klaeren, was die davon halten wenn wir
da mit 8 Leuten ankommen

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



Re: Re: Fruehjahrsparty 2011 in Dresden (Maharet, 31. Jan 2011, 16:06:32):
~#! rn=Tassram rt=1296485368 rg=party.bekanntmachungen
~#! tid=1296424021
Da steht "keine grossen Gruppen". Die sollten nichts gegen eine Gruppe von 8
Leuten haben, wenn sie ein 8-Bett-Zimmer anbieten.

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



Dresden-MG Party am 8.April (Mesirii,  8. Feb 2011, 09:22:31):
Wie einstimming bei Doodle festgestellt, passt der 8. April allen soweit.
Also machen wir das dann.

Ich lass die Umfrage noch offen, wer noch was anmerken will kann das gern
tun. Ich wuerde mal das 8-Leute Zimmer buchen (versuchen) fuer das WE.

Gruss Mesi

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



uebernachtung zur fruehrjahrsparty (Mesirii, 25. Feb 2011, 11:46:04):
Schlechte Nachrichten, leider ist das 8-Leute Appartement schon seit
einiger Zeit gebucht fuer dieses WE. Sie haben aber noch 2 komplett
leere 5-Bett-Zimmer, 1x6-Bett und diverse andere Zimmer frei.
Da ich jetzt nicht weiss, wie ihr Euch das organisieren wollt, wuerde
ich von der zentralen Buchung Abstand nehmen und es Euch ueberlassen
ggf. in der Gruppe da was zu buchen. Hier ist nochmal die URL, da kann
man auch gleich direkt buchen:
http://www.lollishome.de Phone: 0351 810 84 58

Sorry

Mesi

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



Re: uebernachtung zur fruehrjahrsparty (Macli, 25. Feb 2011, 20:23:42):
~#! rn=Mesirii rt=1298630764 rg=party.bekanntmachungen
~#! tid=1298630764
Also ich wuerde gerne in einem moeglichst grossen Zimmer naechtigen um die
Kosten so gut es geht zu senken. Falls es noch mehr preisbewusste Mudder gibt
die es 2 Naechte mit fremden Muddern in einem Zimmer aushalten koennen bitte
ich um Handzeichen. Ansonsten buche ich Montag in einer Woche solo. 

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



Re: Re: uebernachtung zur fruehrjahrsparty (Gloinson, 25. Feb 2011, 20:26:18):
~#! rn=Macli rt=1298661822 rg=party.bekanntmachungen
~#! tid=1298630764
April sollte man doch schon in der Saechsischen Schweiz poofen koennen ;)

Man koennte ja die DD-Mudder fragen, ob sie noch Plaetze irgendwo haben.
Spontan fallen mir noch Vardion und Calish ein, Mesi und Maha sind sicher
schon ausgebucht.


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



Re^3: uebernachtung zur fruehrjahrsparty (Krstfrs, 27. Feb 2011, 21:23:45):
~#! rn=Gloinson rt=1298661978 rg=party.bekanntmachungen
~#! tid=1298630764
Huhu,

ich habe mich spontan auch entschlossen, nach Dresden zu kommen und suche noch
Mitschlaefer, da ein Einzelzimmer fuer mich unbezahlbar ist. Hat schon jemand
was geplant? Oder eine Uebernachtungsmoeglichkeit?

Grus,
da fehlt noch ein s, das reiche ich hier nach: s,
Krstfrs

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



Re^4: uebernachtung zur fruehrjahrsparty (Macli, 28. Feb 2011, 20:14:15):
~#! rn=Krstfrs rt=1298838225 rg=party.bekanntmachungen
~#! tid=1298630764
Wenn Du nichts gegen getrennte Betten hast und die Preise im Lolli OK sind
waeren wir schon zu zweit, Krstfrs. Vielleicht koennen wir Zesstra gewinnen,
damit waeren wir dann schon zu dritt. 

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



Re^5: uebernachtung zur fruehrjahrsparty (Orktoeter, 28. Feb 2011, 20:15:57):
~#! rn=Macli rt=1298920455 rg=party.bekanntmachungen
~#! tid=1298630764
Du kennst den Unterschied zwischen party und party.bekanntmachungen?

Wo ist Grimm-ich-verlege-Artikel-schneller-als-sie-geschrieben-werden-born?

OrkT.

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



Re^6: uebernachtung zur fruehrjahrsparty (Vector, 28. Feb 2011, 20:18:20):
~#! rn=Orktoeter rt=1298920557 rg=party.bekanntmachungen
~#! tid=1298630764
grimmborn gibbet nimmer und somit keinen, der die mpa pflegt.
sieht man doch daran, dass du schreibrechte fuer die zeitung hast....

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



Artikel Biete Wokpfanne (Orktoeter, 28. Feb 2011, 20:33:39):
Hallo zusammen!

Ich biete eine Wokpfanne. Stahlblech, Rundboden. Abzuholen in der Naehe von
Wien.

Angebote bitte per mudmail oder tm.

OrkT.

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



Re: Artikel Biete Wokpfanne (Zesstra, 28. Feb 2011, 20:34:47):
~#! rn=Orktoeter rt=1298921619 rg=party.bekanntmachungen
~#! tid=1298921619
Ich seh da uebrigens noch nen klaren Unterschied zwischen Deinem und Maclis
Artikel. Ich will uebrigens keine Wokpfanne.

Zesstra

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



Re^6: uebernachtung zur fruehrjahrsparty (Amaryllis, 28. Feb 2011, 20:50:44):
~#! rn=Orktoeter rt=1298920557 rg=party.bekanntmachungen
~#! tid=1298630764
Der hat sich nach seiner Entgleisung und entsprechender Strafe als schmollende
Leberwurst nicht mehr eingeloggt.
Ich kann damit leben. Und die Befuerchtung, dass die MPA ohne seine Zensur zu
einem Haufen unlesbaren, chaotischen Muells verkommt, hat sich imho nicht
bewahrheitet.

Ama*

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



Re^7: uebernachtung zur fruehrjahrsparty (Gloinson, 28. Feb 2011, 20:57:01):
~#! rn=Amaryllis rt=1298922644 rg=party.bekanntmachungen
~#! tid=1298630764
Die e-Exponentialfunktion startet auch mit kleinen Schritt und jagt dann knapp
vor Meter 20 mit Lichtgeschwindigkeit am Mond vorbei. Will sagen: ab jetzt
geht es abwaerts.

Gnops! Gnops! Ich bin Zesstras Testmagier! Gnops!
> xload /obj/joint
> clone /obj/joint


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



Re^8: uebernachtung zur fruehrjahrsparty (Amaryllis, 28. Feb 2011, 21:00:41):
~#! rn=Gloinson rt=1298923021 rg=party.bekanntmachungen
~#! tid=1298630764
Das xload ist ueberfluessig ;)

Ama*

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



Re^9: uebernachtung zur fruehrjahrsparty (Gloinson, 28. Feb 2011, 21:01:28):
~#! rn=Amaryllis rt=1298923241 rg=party.bekanntmachungen
~#! tid=1298630764
Zesstra wuerde niemals Code einfach so vertrauen!


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



Re^10: uebernachtung zur fruehrjahrsparty (Orktoeter,  7. Mar 2011, 11:37:07):
~#! rn=Gloinson rt=1298923288 rg=party.bekanntmachungen
~#! tid=1298630764
Frueher war alles besser!

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



Vortraege in Dresden (Zesstra,  9. Mar 2011, 00:20:15):
Ich biete fuer die kommende Party in Dresden an, eine Diskussionsrunde zum
Thema git (und Versionsverwaltung) und eine zu (ausgewaehlten) Fragen zur
Mudlib abzuhalten.
Speziell zu zweiterem bietet es sich natuerlich an, mir vorher Bescheid
zusagen und mir mitzuteilen, was euch speziell interessiert, dann ich mich
(und ggf. Material) vorher vorbereiten. Es geht auch viel spontan, denk ich.
Sprecht mich da einfach an, wenn ihr Interesse habt.

Zesstra

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



Parties vergangener Jahre... (Zesstra, 14. Mar 2011, 01:14:36):
Ich habe die Partyseiten von 4 Parties von 2007 bis 2010 auf der Homepage
ergaenzt. Mit dabei sind auch Bilder:
Winterparty auf der Winterburg 2007 von McDee
Fruehjahrsparty Dresden 2009 von Gloinson
Sommerparty Wetzlar 2009 von Gloinson
Sommerparty Brieselang 2010 von Gloinson

Wenn ihr noch Fotos von Mudparties haben, ueberlegt doch mal, ob ihr sie fuer
http://mg.mud.de/realworld/party.shtml beisteuern wollt. ;-)

Zesstra

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



Re: Parties vergangener Jahre... (Gloinson, 15. Mar 2011, 05:46:08):
~#! rn=Zesstra rt=1300061676 rg=party.bekanntmachungen
~#! tid=1300061676
Fuer kurze Zeit auf meinem Webspace, bis Zesstra die Unterstuetzung des
Skriptes fuer Video-Dateien angepasst hat:

http://flunzel.de/pics/dd10/

Sprich: die Bilder sind wirklich neu.

(Etwaige Einsprueche bitte ASAP, bei 50 Bildern fand ich das Risiko
eingehenswert.)


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



Partybrett Dresden 2011 (Zesstra, 18. Mar 2011, 21:00:36):
Huhu,

Mesi hat mich gebeten die Partybretter aufzustellen. Hab ich jetzt hiermit
erledigt.

Zesstra

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



Re: Re: Parties vergangener Jahre... (Zesstra, 20. Mar 2011, 22:29:03):
~#! rn=Gloinson rt=1300164368 rg=party.bekanntmachungen
~#! tid=1300061676
Gloinsons Bilder von Dresden 2010 ist jetzt auch.
Ausserdem je ein kurzes Filmchen aus Dresden 2009 und Dresden 2010.

Zesstra

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



Dresdenen 2011: Schluessel-Signierung und CaCert.org (Zesstra, 21. Mar 2011, 21:38:30):
Huhu,

falls wer auch dieses Jahr Interesse am gegenseitigen Signieren von
GPG/PGP-Schluesseln hat oder noch einige Punkte fuer CaCert.org[1] benoetigt,
biete ich beides auch dieses Jahr wieder an.

[1]http://www.cacert.org/

Zesstra

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



kurze planung (Mesirii,  6. Apr 2011, 15:39:54):
Freitag Abend im Dueruem: http://bit.ly/dueruem
Samstag Versammlung und Party in der Buchbar: http://die-buchbar.de
Sonntag Mittagessen im Cuchi: http://cuchi-dresden.de/

Mesi, Tel 0176 21604910

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



Re: kurze planung (Vanir,  6. Apr 2011, 17:35:51):
~#! rn=Mesirii rt=1302097194 rg=party.bekanntmachungen
~#! tid=1302097194
Ist das Duerum dieser Doenerladen um die Ecke, wo wir mal waren? Sieht mir
zumindest ganz gefaehrlich danach aus.
V.

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



Re: Re: kurze planung (Maharet,  6. Apr 2011, 17:43:52):
~#! rn=Vanir rt=1302104151 rg=party.bekanntmachungen
~#! tid=1302097194
Genau, der, der 23 Stunden am Tag geoeffnet hat und den besten Doener und
Dueruem ueberhaupt hat!

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



Re^3: kurze planung (Vanir,  6. Apr 2011, 17:47:44):
~#! rn=Maharet rt=1302104632 rg=party.bekanntmachungen
~#! tid=1302097194
Ja, das mit dem Doener kann ich bestaetigen. Aber gibts da auch Bier?
V.

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



Re^4: kurze planung (Maharet,  6. Apr 2011, 17:55:04):
~#! rn=Vanir rt=1302104864 rg=party.bekanntmachungen
~#! tid=1302097194
Klar doch, warum sollte es da kein Bier geben? Das ist ne Gaststaette. So
richtig mit Bedienung am Tisch.

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



Re^5: kurze planung (Vanir,  6. Apr 2011, 17:57:14):
~#! rn=Maharet rt=1302105304 rg=party.bekanntmachungen
~#! tid=1302097194
Ich kenn Pakistaner und auch Tuerken, die Tische haben und leckeres Essen
servieren und so feste an irgendwelchen Kram glauben, dass die auch ihren
Kunden kein Bier servieren.
V.

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



Re^6: kurze planung (Maharet,  6. Apr 2011, 18:00:21):
~#! rn=Vanir rt=1302105434 rg=party.bekanntmachungen
~#! tid=1302097194
Nee, also die glauben eher an Umsatz.

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



Re^7: kurze planung (Gloinson,  6. Apr 2011, 18:14:17):
~#! rn=Maharet rt=1302105621 rg=party.bekanntmachungen
~#! tid=1302097194
Koennte sein, dass die im Norden, wo sie frisch mit Schiffen ankommen, noch so
komische Ideen haben.


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



Re^3: kurze planung (Zesstra,  6. Apr 2011, 19:16:03):
~#! rn=Maharet rt=1302104632 rg=party.bekanntmachungen
~#! tid=1302097194
Cool. Das klingt gut, ich freu mich schon auf Freitag abend! Und alles so
schoen nah an der Schlafstaette, da kann ja nie was schiefgehen mit dem Finden
des Bettes.

Zesstra

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



Re^4: kurze planung (Gloinson,  6. Apr 2011, 19:30:00):
~#! rn=Zesstra rt=1302110163 rg=party.bekanntmachungen
~#! tid=1302097194
Darf ich dir mal 10 Bier ausgeben, um diese Theorie zu testen? ;)


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



Re^5: kurze planung (Croft,  6. Apr 2011, 19:51:55):
~#! rn=Gloinson rt=1302111000 rg=party.bekanntmachungen
~#! tid=1302097194
Ich wuerd mich auch als Theorietester zur Verfuegung stellen :-)

Croft

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



Re^6: kurze planung (Vanir,  6. Apr 2011, 21:01:56):
~#! rn=Croft rt=1302112315 rg=party.bekanntmachungen
~#! tid=1302097194
Ich wuerde mich gerne zur Verfuegung stellen um Nachzuweisen, dass die
Behauptete Kausalitaet wirklich existiert.
V.

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



Re^7: kurze planung (Gloinson,  6. Apr 2011, 22:01:33):
~#! rn=Vanir rt=1302116516 rg=party.bekanntmachungen
~#! tid=1302097194
Hrhr. Ich kenne da ein Getraenk, es wird Bier genannt, traegt die genaue
Bezeichnung "Sachsengold" ... tuedelue. Mal sehn, ob ich einen Kasten
auftreiben kann und das Wetter im Alaunpark mitspielt :D


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



Re^8: kurze planung (Gloinson,  6. Apr 2011, 22:07:45):
~#! rn=Gloinson rt=1302120093 rg=party.bekanntmachungen
~#! tid=1302097194
PS: Bei sehr gutem Wetter sollten wir uns vielleicht eh am Freitag Nachmittag
an die Elbe verkruemeln, vielleicht sogar mit Billig-Grill. Aber das koennen
wir spontan entscheiden.

http://goo.gl/maps/fLsX ist die Bruecke, ueber die wir immer zum Blauen Haus
laufen durften. anno dazumal war das ein recht geeigneter platz fuer wildes
Grillen direkt am Wasser.


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



Re^9: kurze planung (Maharet,  6. Apr 2011, 22:09:41):
~#! rn=Gloinson rt=1302120465 rg=party.bekanntmachungen
~#! tid=1302097194
Also die 21 Grad wurden abgesagt, die gibt es nur morgen, dann nicht mehr. Wir
koennen von Glueck sagen, wenn es trocken bleibt. Sorry. Ich habe wirklich
immer brav aufgegessen!

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



Re^10: kurze planung (Zesstra,  6. Apr 2011, 22:10:54):
~#! rn=Maharet rt=1302120581 rg=party.bekanntmachungen
~#! tid=1302097194
Ah, schade. Aber Shaky und ich haetten es wohl leider eh nicht geschafft,
schon am Nachmittag dazu zu sein. Ich schaetz eher, dass es so 18:00 wird.
Aber nen Bier nehm ich auch unter 21 Grad (und selbst bei Regen). *g*

Zesstra

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



Re^10: kurze planung (Gloinson,  6. Apr 2011, 22:11:11):
~#! rn=Maharet rt=1302120581 rg=party.bekanntmachungen
~#! tid=1302097194
WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH!

Plan B: wir ziehen um die Haeuser ;)


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



MUD-Party in Salem am Bodensee: Terminfindung (Gloinson,  9. Apr 2011, 18:44:02):
Hallo, 
aller guten Dinge sind drei ... also zu finden: ein Termin fuer eine
Party-Woche in Salem am Bodensee. Laufzeit der Umfrage bis etwa 25. April.

Umfrage: http://www.doodle.com/hauvdbh8i3yxwxya
Ortsvorschlag: http://www.campinghof-salem.de/

Ich wuerde das Anmelden am Platz den Einzelnen ueberlassen. Mit dem Platz
mache ich aus, dass unter "Morgengrauen" gesammelt wird. Dementsprechend
laeuft das Erlangen einer festen Unterkunft unter "first come, first serve".

Je nach Auslastung durch andere Gruppen kann es sein, dass ich dann ggf
noch ein paar Termine sperre.

# Unterkunft #
Der Campingplatz ist in Salem Stefansfeld und
* etwas kleiner als Wetzlar/Hattingen,
* hat prinzipiell Erfahrung mit groesseren Gruppen, diese werden meist
  am anderen Ende im Grillbereich positioniert
* liegt nahe einer tagsueber gut befahrenen Landstrasse
* ist in Laufreichweite (2 km) von Penny und Aldi-Filialen

Es gibt verschiedene ueberdachte Unterkuenfte:
* Wohnwagen wochenweise
* Blockhuetten auch nachtweise
* Radzimmer (Kabinen in einer laengeren Baracke)
* Heuhotel (Strohballen-Kompartments in ebendieser Baracke)

Fuer die Party am Samstag muss ich klaeren, ob wir die Gaststaette nutzen
koennen oder ein groesseres Zelt aufbauen sollten.

# Anfahrt #
Salem am Bodensee hat
* einen Bahnhof in Laufreichweite vom Platz (2,5 km, suedwestlich))
* Bus-Haltestellen in Laufreichweite (Linie 7397 ~100m, Linie 7396 ~1 km)
  - Liniennetzplan: http://goo.gl/18jzH

Zum Bodensee kommt man mit Bahn, Flugzeug (http://www.fly-away.de) in
FNHafen oder natuerlich dem von den Schwaben heissgeliebten Auto.

Aus Berlin ueber Erfurt (1258, 1259), Amsterdam ueber Koeln (40419, 40478),
Prag ueber DD (458, 459) und Hamburg ueber Hannover (478, 479) fahren
Nachtzuege bis Basel Badischer Bahnhof, danach ist man in ~2h mit einem
weiteren Mal Umsteigen in Salem.

# Umgebung #

In Salem Mimmenhausen selbst ist ein Badesee (http://goo.gl/maps/vTR9),
oeffentlich nutzbar (Schlosssee) in 1km Entfernung vom Platz.
Salem selbst liegt circa 10km vom Bodensee entfernt, die Gegend faellt
zum See nochmal circa 50 Hoehenmeter ab. Mit dem Fahrrad kann man
eigentlich alles sinnvoll erreichen - ansonsten Bus und Bahn nutzen.

# Politik #

Hier sind alle schwarz, bis auf die Landesregierung, die koennte noch
gruen-rot sein. Der Bodensee liegt - wichtiges Detail - nur mit einem
Zipfel in Bayern (Lindau).


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



Re: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson, 12. Apr 2011, 15:43:22):
~#! rn=Gloinson rt=1302367442 rg=party.bekanntmachungen
~#! tid=1302367442
Momentan sieht Ende August praeferiert aus, daher hab ich mal angerufen: zu
der Zeit ist die Situation wohl recht entspannt, und da wir uns zu benehmen
wissen sollten (familienfreundlicher Platz) sieht es also gut aus.

Ich hatte vergessen die Alternativen zu nennen:
- Hotel Recks am Bahnhof: http://www.recks-hotel.de/
- Pensionen, zB Gaestehaus Salem (http://www.gaestehaus-salem.de/)
  (noerdlich vom See)
- Bikers Inn fuer die Motorradfahrer (http://www.bikers-inn-salem.de/)
  (vielleicht hat Shaky bis dahin eine Harley)


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



Re: Re: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson, 28. Apr 2011, 20:04:12):
~#! rn=Gloinson rt=1302615802 rg=party.bekanntmachungen
~#! tid=1302367442
Einladung zur Sommerparty

# Termin: Woche vom 15.-21. August
# Ort:    Campinghof Salem (http://www.campinghof-salem.de/)
          in Salem Neufrach Naehe Bodensee

# Unterkunftsoptionen:
a) Zelt: der Campinghof reserviert Platz fuer 20-30 Leute nahe Grill
b) Campingwagen/Bungalow/Radhotel/Heuhotel: je nach Verfuegbarkeit
c) sonstiges (*1)

Wir haben mit dem Campinghof abgemacht, dass ihr euch selbst bei denen
anmeldet (was gerade bei den Bungalows und Wohnwagen (wochenweise) besser
zuegig passiert) und dabei "Morgengrauen" als Referenz angebt.
Bitte meldet euch am Partybrett an, damit wir mit dem Campinghof bei
Ueberschreiten der Schaetzung rechtzeitig reden koennen.

# Party:
Mit dem Campinghof ist schon mal der 20. August als Termin fuer ein
Grillfest vereinbart, wir haetten dann also den Hauptgrill verfuegbar.
Sie gucken, ob sie fuer schlechtes Wetter selbst Pavillon-Zelte parat
haben. Gaststaette ist ansonsten immer Option (aber eben geteilt).

# Vereinssitzung:
Die kann prinzipiell entweder bei uns in der Wohnung oder in der
Gaststaette am Campinghof nachmittags stattfinden.

# Sonstige Termine:
12. August: Weinfest Salem
13. August: Seenachfest Konstanz

*1):
Hotel: http://www.recks-hotel.de/
FeWo:  http://www.gaestehaus-salem.de/ (...)


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



Re^3: MUD-Party in Salem am Bodensee: Terminfindung (Zesstra, 28. Apr 2011, 20:31:00):
~#! rn=Gloinson rt=1304013852 rg=party.bekanntmachungen
~#! tid=1302367442
Partybretter stehen ausnahmsweise dann auch mal frueh genug. ;-)
Also: meldet euch an!

Zesstra

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



Re^4: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson, 20. Jun 2011, 23:28:18):
~#! rn=Zesstra rt=1304015460 rg=party.bekanntmachungen
~#! tid=1302367442
Moin,

Zesstra hatte mich gebeten, nach Stromanschluss zu fragen. Kein Problem, sowas
machen die da auch dann zentral. Ich soll mich ohnehin nochmal 10 Tage vorher
melden, dann koennen wir eventuell schon Gebiet abstecken.

Da der Bodensee heissbegehrt ist, warnte der Besitzer nochmal, dass es nicht
mehr als die von mir gepeilten 15 Zelte werden sollte, da waere einfach kein
Platz fuer.


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



Re^5: MUD-Party in Salem am Bodensee: Terminfindung (Zesstra, 20. Jun 2011, 23:47:18):
~#! rn=Gloinson rt=1308605298 rg=party.bekanntmachungen
~#! tid=1302367442
Mhmm. Ich hatte denen mal ne Mail geschrieben wegen Reservierung und keine
Antwort gekriegt. Wie sieht denn eure Erfahrung damit aus? Wenn ihr alle ne
Antwort kriegtet, schreib ich mal besser nochmal.

Zesstra

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



Re^6: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson, 20. Jun 2011, 23:50:33):
~#! rn=Zesstra rt=1308606438 rg=party.bekanntmachungen
~#! tid=1302367442
Im Zweifelsfall anrufen. Heute hatte ich jemand anderen da, der guckte etwas
bedroeppelt aber ich hab uns auf einem Papierbogen im offiziellen Kalender
eingtragen gesehen ;)


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



Re^5: MUD-Party in Salem am Bodensee: Terminfindung (Zook, 21. Jun 2011, 08:39:40):
~#! rn=Gloinson rt=1308605298 rg=party.bekanntmachungen
~#! tid=1302367442
Wobei es interessant ist, dass die auf meine "Ich komme!"-E-Mail so 
gar nicht reagierten.
Zook.

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



Re^6: MUD-Party in Salem am Bodensee: Terminfindung (Zesstra, 21. Jun 2011, 10:39:37):
~#! rn=Zook rt=1308638380 rg=party.bekanntmachungen
~#! tid=1302367442
Ah, dann sieht das wohl so aus, dass das mit den modernen
Kommunikationsmitteln nicht so dolle funktioniert. Also, alle die Mails
geschrieben haben, sollten wohl nochmal anrufen...

Zesstra

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



Re^7: MUD-Party in Salem am Bodensee: Terminfindung (Zook, 21. Jun 2011, 10:40:07):
~#! rn=Zesstra rt=1308645577 rg=party.bekanntmachungen
~#! tid=1302367442
Ich glaub, ich druck meine Mail aus und leg sie aufs Fax ;) 
Z

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



Re^8: MUD-Party in Salem am Bodensee: Terminfindung (Zesstra, 21. Jun 2011, 10:51:43):
~#! rn=Zook rt=1308645607 rg=party.bekanntmachungen
~#! tid=1302367442
Muhahaha. Vergiss nicht, sie zu versiegeln.

Zesstra

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



Re^9: MUD-Party in Salem am Bodensee: Terminfindung (Zook, 21. Jun 2011, 10:52:50):
~#! rn=Zesstra rt=1308646303 rg=party.bekanntmachungen
~#! tid=1302367442
Schon verfaxt.
Z

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



Re^10: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson, 21. Jun 2011, 13:47:03):
~#! rn=Zook rt=1308646370 rg=party.bekanntmachungen
~#! tid=1302367442
Ich moechte das Siegel sehen!


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



Re^11: MUD-Party in Salem am Bodensee: Terminfindung (Rumata, 21. Jun 2011, 13:49:25):
~#! rn=Gloinson rt=1308656823 rg=party.bekanntmachungen
~#! tid=1302367442
Muss nicht "den Siegel" heissen?

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



Re^12: MUD-Party in Salem am Bodensee: Terminfindung (Croft, 21. Jun 2011, 15:45:53):
~#! rn=Rumata rt=1308656965 rg=party.bekanntmachungen
~#! tid=1302367442
Den Siegel moechte ich nicht sehen.

Croft

PS: Falsche Rubrik

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



Re^13: MUD-Party in Salem am Bodensee: Terminfindung (Vanhelsing,  9. Jul 2011, 11:18:18):
~#! rn=Croft rt=1308663953 rg=party.bekanntmachungen
~#! tid=1302367442
Ich hab damals auch eine Reservierungsmail geschrieben gehabt, und keine
Antwort bekommen. Nach ca. 3-4 hab ich da mal angerufen und nachgefragt, und
da sagte man mir, ist alles ok so, ich bekomme keine Bestaetigungsmail von
denen. Dann mal schauen. ;)

VH

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



Re: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson, 14. Jul 2011, 18:07:55):
~#! rn=Gloinson rt=1302367442 rg=party.bekanntmachungen
~#! tid=1302367442
Moin,

ich war nochmal am Zeltplatz um beiderseitig Missverstaendnisse auszuraeumen:

* Anmeldung mit Zelt erfolgt bei Anreise
  -> wir haben ein Kontingent/Platz fuer etwa 15 Zelte
  -> etwa eine Woche vorher gehe ich hin, um ggf Platz abzustecken
     (ich sollte also wissen, wie viele Zelte -> Brett)
* wir sind keine komischen Internetjunkies ;)
* Hunde sind nur an der Leine erlaubt


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



Re: Re: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson, 21. Jul 2011, 05:19:34):
~#! rn=Gloinson rt=1310659675 rg=party.bekanntmachungen
~#! tid=1302367442
Machen wir mal Zelte mit Zeltnaegeln:
http://wiki.morgengrauen.info/index.php?n=MorgenGrauen.SommerpartyXXXX
* enthaelt die Fakten und die Fiktion

http://wiki.morgengrauen.info/index.php?n=MorgenGrauen.ZeltlisteParty40
* ist eine Zeltliste, damit wir im Fall des Falles schieben koennen


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



Re^3: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson,  2. Aug 2011, 21:38:57):
~#! rn=Gloinson rt=1311218374 rg=party.bekanntmachungen
~#! tid=1302367442
Essen:
* Sonntagsessen: wir sind geschaetzt >=25, also melde ich den Brunch an
* generell: ich werde mal eine kleine Karte mit Mampfversorgern erstellen

Gepaeck:
* bei Bedarf kann Gepaeck an uns vorgeschickt werden (Adresse per tm/Mail)


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



Re^3: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson,  9. Aug 2011, 14:33:21):
~#! rn=Gloinson rt=1311218374 rg=party.bekanntmachungen
~#! tid=1302367442
http://wiki.morgengrauen.info/index.php?n=MorgenGrauen.SommerpartyXXXX

Alte Neuigkeiten:
* Brunch ist gebucht:
** ab 10 Uhr in Salem Beuren, erreichbar mit Bus
** 16,50 pP
** momentan sind 21(+3+2 Kinder) gemeldet. Liste?

* Zeltplatz hat:
** WLAN, aber nicht dort, wo die Zelte sind
** Gemeinschaftskueche mit Kuehlschrank/Gefriere
** Broetchenservice

http://www.panoramio.com/photo/57051608


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



Re^4: MUD-Party in Salem am Bodensee: Terminfindung (Gloinson, 11. Aug 2011, 23:21:32):
~#! rn=Gloinson rt=1312893201 rg=party.bekanntmachungen
~#! tid=1302367442
Fuer den Fall der Faelle:
01577/1598421
07553/2194848
in absteigender Prioritaet.


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



Fruehjahrsparty in Dresden (Mesirii, 22. Jan 2012, 21:52:18):

Moin Mud,

wie jedes Jahr wuerde ich gern wieder die Fruehjahrsparty in Dresden machen.
Wieder einmal mit Vereinsversammlung.

Dieses Jahr feiern wir ja 20 Jahre MG. Da sollten wir etwas auf die Beine
stellen.

Wegen der Terminplanung tragt Euch bitte bei Doodle ein.

Danke,

Mesi

http://www.doodle.com/i94hstpsnssurdxe

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



Re: Fruehjahrsparty in Dresden (Mesirii, 12. Feb 2012, 00:37:31):
~#! rn=Mesirii rt=1327265538 rg=party.bekanntmachungen
~#! tid=1327265538
So, die Terminplanung ist abgeschlossen. Es hat sich der 17. Maerz als das
Wochenende mit den meisten Zusagen herausgestellt.
Sorry fuer all jene, die da leider nicht kommen koennen, ggf. kann man ja noch
eine Oster-Nach-Party ansetzen oder man sieht sich im Sommer.
Fuer diejenigen, die kommen koennen und wollen, ihr duerft Euch jetzt um
Uebernachtungen kuemmern, wenn es dazu Fragen gibt, schickt mir bitte eine
mail an mg at mesirii.de
Ich kuemmer mich noch ums Partybrett.

Kommet zuhauf

Mesi

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



Re: Re: Fruehjahrsparty in Dresden (Rumata, 11. Mar 2012, 20:07:25):
~#! rn=Mesirii rt=1329003451 rg=party.bekanntmachungen
~#! tid=1327265538
Kannst du nochmal die Lokationen durchgeben, an denen die "Partevents"
stattfinden? Ich finde momentan nix hier %-)

Rum**

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



Re: Re: Fruehjahrsparty in Dresden (Ennox, 12. Mar 2012, 00:13:15):
~#! rn=Mesirii rt=1329003451 rg=party.bekanntmachungen
~#! tid=1327265538
Ich habs jetzt doch noch geschafft, ein Partybrett aufzustellen.
Damit koennt Ihr Euch jetzt endlich anmelden.
Um Rumata's Frage zu beantworten, die Events finden in und um die "Buchbar"
statt,
das ist mein eigener Laden, also nicht verwirren lassen von dem Blog-Eintrag
auf
http://die-buchbar.de es hat nur die Betreiberin aufgehoert.

Ich hoffe ich sehe Euch alle in ein paar Tagen hier in Dresden, laut Maharet
soll
das Wetter toll werden.

LG
Mesi/Ennox

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



Re^3: Fruehjahrsparty in Dresden (Ennox, 14. Mar 2012, 22:15:58):
~#! rn=Ennox rt=1331507595 rg=party.bekanntmachungen
~#! tid=1327265538
Fuer Samstag Abend gibts ein Buffet, ihr koennt Vorschlaege fuer die Vor und
Hauptspeisen machen
als Beilage nehme ich Kuskus:

Wunsch-Buffet aus fuenf Vorspeisen, zwei Hauptgerichten und einer Beilage nach
Wahl selbst zusammenstellen:

Hausgemachte Vorspeisen (vegetarisch)
Muecver - Zuccinifrikadelle mit Ei und Mehl verschiedene Tuerkische Gewuerze
Gebratene Moehren, gewuerzt in Joghurtsauce
Gebratene Paprika, gewuerzt in Joghurtsauce
Aciezme - scharfes Dip mit Tomaten, Zwiebeln, Peperoni und verschiedenen
Kronen
Kichererbsensalat
Saksuka - gebratenes Gemuese in Tomatensauce
Russalatasi - Kartoffelsalat mit Majonaise auf tuerkischer Art
Sigara Boeregi - Teigroellchen gefuellt mit Kaese
Gefuellte Weinblaetter mit Reis
Zaziki
Peynirezme - puerierter Weisskaese mit Wallnuesse
Peynirezme - puerierter Weisskaese mit Peperoni und Paprika
Gruene Oliven Paste mit Weisskaese
Weisse Bohnen in Tomatensauce
Frittierte Rinderleber nach tuerkischer Art
Kuskussalat - Hartweizengriesssalat
Rote Linsen Baellchen

Hauptgerichte
Tuerlue - Kalbfleisch mit verschiedenes Gemuese in Tomatensauce
Rindfleisch mit Champignons in Tomatensauce
Hackbaellchen mit Kartoffeln und Tomaten ueberbacken
Hackbaellchen mit Champignons in Tomatensauce mit Kaese ueberbacken
Haenchenkeulen mit Kartoffeln in Tomatensauce ueberbacken
Putenfleisch mit verschiedenen Gemuesesorten in Sahnesauce mit Kaese
ueberbacken
Musakka Obergine mit Hackfleisch in Tomatensauce ueberbacken
Gefuellte Paprika mit Hackfleisch und Reis
Vegetarische Hauptgerichte nach Wunsch:
Gebratenes Gemuese in Tomatensauce ueberbacken
Broccoliauflauf in Sahnesauce mit Kaese ueberbacken

Beilagen
Gemuesereis
Kuskusreis (tuerkische Art)
Gekochte Kartoffel mit Kraeuterbutter

Mesi

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



Planungsdaten Fruehjahrsparty Dresden (Mesirii, 15. Mar 2012, 19:54:03):
~#! rn=Ennox rt=1331759758 rg=party.bekanntmachungen
~#! tid=1327265538
Planung fuer die MG-Fruehjahrsparty in Dresden 2012

Freitag Abend ab 18:00 Treffen beim Mexikaner Espitas 
in der Naehe der Buchbar (Louisenstr 39, Ecke Alaunstr)

Samstag
* tagsueber freies Spielen in der Stadt, den Parks
  oder an der Elbe
* Buchbar ist tagsueber auch offen, Yuli ist dort
* Nachmittag ab 16:00 Mitgliederversammlung in der
  Buchbar (Hinterhof, Alaunstr 66/68 rechts hinten)
* Abend ab ca. 18-19:00 Party in der BB, 
  mit Essen + Trinken

Sonntag
* Mittag ab 12:00 (puenktlich!), beim Japaner
  Sushi + Chinesisch Buffet fuer 10,50, bei dem
  tollen Wetter koennen wir hoffentlich draussen 
  sitzen

Kommet zuhauf
Mesi

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



Fruehjahrsparty Dresden (Mesirii, 10. Feb 2013, 09:16:53):
Hallo,

wer Lust hat nach Dresden zur Party zu kommen, moege sich bitte hier
eintragen: http://doodle.com/29mtdw65ckwpf6q5

Danke 

Mesi

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



Re: Fruehjahrsparty Dresden (Maharet,  1. Mar 2013, 17:49:10):
~#! rn=Mesirii rt=1360484213 rg=party.bekanntmachungen
~#! tid=1360484213
Zur Erinnerung: Bitte eintragen!
http://doodle.com/29mtdw65ckwpf6q5#table

Danke :)

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



Fruehlingsparty in Dresden am 20. April (Mesirii, 23. Mar 2013, 15:04:56):

Nach allgemeiner Abstimmung und Verbummelung meinerseits ist der 20. April 
als Partytermin herausgekommen.

Also kommet zuhauf, wie gehabt nach Dresden in der Buchbar, Alaunstr. 66/68 
am Samstag. Freitag Abend denke ich wieder im Estancia, Alaunstr. das war 
ganz ok. Und am Sonntag auch wie gehabt im Cuchi am Wallgaesschen.

Aufgrund der kurzen Vorlaufzeit wirds keine Mitgliederversammmlung geben, die 
muessen wir dann auf den Sommer verschieben. Aber ich wuerde gern ein paar 
Vereinssachen trotzdem diskutieren wollen.

Kommet zuhauf. Und ueberzeugt die Zweifler und Unentschlossenen doch auch 
einfach mitzukommen. Im April ist dann hoffentlich der Winter vorbei.

Ich freu mich auf Euch.

Mesi

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



Naegel mit Koepfen (Miril,  7. Apr 2013, 18:47:31):
~#! on=Miril ot=1365351831 og=party
Huhu!

Soeben haben wir den Campingplatz in Hattingen fuer die Sommerparty 2013
gebucht. Anders als bei den vergangenen Partys in Hattingen haben wir nicht
die Wiese direkt am Fluss, sondern ein abgetrenntes Stueck, das weiter vom
Wasser entfernt ist. Grund dafuer ist zum einen, dass man dort besser unter
sich ist und dass es fuer Familien mit kleinen Kindern sicher besser geeignet
ist.

Die Party findet in der Woche vom 22.7.-28.7.2013 statt. Wer den Platz noch
nicht kennt, hier der Link: http://www.camping-hattingen.de/. Surfen findet
auch wieder statt, evtl. gibts da auch wieder die Moeglichkeit mitzumachen und
nen Surfschein zu erwerben. Das haben wir allerdings noch nicht geklaert,
Interessenten sollten sich dann bei mir melden.

Kommet zuhauf :)

Miril

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



Re: Fruehlingsparty in Dresden am 20. April (Vardion, 17. Apr 2013, 17:27:38):
~#! rn=Mesirii rt=1364047496 rg=party.bekanntmachungen
~#! tid=1364047496
Korrektur nach Ruecksprache mit Mesi: wir Treffen uns am Freitag (wie letztes
Jahr) im Espitas in der Alaunstrasse. Das Estancia ist wo anders...

Vardion

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



Sommerparty in HATTINGEN (Humni,  5. Mar 2014, 21:03:45):
Liebe MitmudderInnen,

in altbekannter Tradition (begruendet 2013) werden wir die diesjaehrige
Sommerparty in HATTINGEN durchfuehren.

Sie wird vom 21.-27.7. stattfinden.

Wir campen auf dem Campingplatz von Jutta Stolle unter der Ruhrbruecke dort:

http://www.camping-hattingen.de/

Kurz zu Hattingen:

Hattingen liegt je nach Sichtweise im Bergischen Land, im Sauerland oder im
Ruhrgebiet - da es bei der "Kulturhauptstadt" mitgemacht hat, wohl am ehesten
letzteres. Begruendet wurde der Ort, als ein paar Kinder auf einer Wiese Ball
spielten. Damals hatten die Kinder noch keine so schoenen Ballspiele wie heute
(Fussball, Volleyball, Beach-Volleyball, Rugby, Kicker) sondern nur "Ball
fangen". Und eines der Kinder war Inge. Inge hatte eine Kuh namens Else, und
Else schlug den ganzen Tag mit dem Euter aus, und darum gab sie keine Milch,
sondern Butter, demzufolge hatte Inge immer "Butterfinger", da sie immer Else
melken musste. Es endete, wie es kommen musste: Die anderen Kinder haenselten
Inge. "Na, hat Inge den Ball? Hat Inge den Ball? Hat Inge ihn? Hat Inge 'n?
Hattingen?" - und damit hatte der Ort seinen Namen.

Ansonsten faehrt die Strassenbahn 308 direkt nach Bochum hinein, dort kann man
dann Dinge tun, die man in Bochum tun kann (Bier trinken, Doener essen). Das
geht aber auch in Hattingen. Man kann vom Campingplatz aus auch Fahrrad fahren
oder in der Ruhr schwimmen. 

Der Platz, den wir letztes Jahr hatten und den wir auch dieses Jahr wieder
kriegen, ist weit genug von der Ruhr weg, dass kleine Kinder nicht einfach so
da reinrennen koennen. Es sei denn, sie sind laenger ausser Sicht.

Humni

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



Re: Sommerparty in HATTINGEN (Arathorn, 25. Jun 2014, 19:15:36):
~#! rn=Humni rt=1394049825 rg=party.bekanntmachungen
~#! tid=1394049825
Kurze Info fuer alle, die mit dem Rad herkommen bzw. in und um Hattingen
mit dem Rad fahren wollen: es sind momentan noch sehr viele oeffentliche
Radwege aufgrund des Unwetters gesperrt und nicht befahrbar. Wenn ihr
eine Radtour plant, solltet ihr das beruecksichtigen und euch ggf. recht-
zeitig vorher erkundigen, ob die Wege (wieder) frei sind.

Arathorn.

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



Re: Re: Sommerparty in HATTINGEN (Zook, 30. Jun 2014, 09:25:24):
~#! rn=Arathorn rt=1403716536 rg=party.bekanntmachungen
~#! tid=1394049825
Ah, danke. Wie schaut's denn mit normalen Strassen aus?

Zook

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



Re: Sommerparty in HATTINGEN (Zesstra,  7. Jul 2014, 20:28:56):
~#! rn=Humni rt=1394049825 rg=party.bekanntmachungen
~#! tid=1394049825
Falls mehrere Leute irgendwann in der Partywoche die "Toedlichen Fragmente"
(SR5-Abenteuer) spielen moegen, liesse sich das einrichten. Kurzes Interesse
vorher signalisieren waer nuetzlich, von wegen Vorbereitung - sonst lese ich
es naemlich noch nicht.

Zesstra

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



Re: Re: Sommerparty in HATTINGEN (Arathorn, 23. Jul 2014, 13:39:40):
~#! rn=Arathorn rt=1403716536 rg=party.bekanntmachungen
~#! tid=1394049825
Update, Stand 18.07.2014. Beim Regionalverband Ruhr gibt's Infos zu den
Radwegen: http://www.metropoleruhr.de/presse/unwetterfolgen.html

Weiterhin haben die ein PDF mit einer Sperrungsliste: http://bit.ly/1x0ijTm
Beachte: das sind nur die, die der RVR selbst unterhaelt. Es gibt weitere
Radwege, die nicht darunter fallen und ueber die der RVR demzufolge keine
Infos bereitstellen kann. Die Liste ist also nur als Positivliste zu 
verstehen und bedeutet nicht, dass alles andere frei waere.

Arathorn.

P.S.: Zum Ruhrtalradweg hier noch was ausfuehrlicher:
http://www.ruhrtalradweg.de/Sturmschaeden/Befahrbarkeit-des-RuhrtalRadweges

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



Re^3: Sommerparty in HATTINGEN (Arathorn, 23. Jul 2014, 13:43:41):
~#! rn=Arathorn rt=1406115580 rg=party.bekanntmachungen
~#! tid=1394049825
Ah, noch ein Nachtrag. In dieser Woche wird wohl aktuell daran gearbeitet, 
den Zollvereinweg und die Kray-Wanner Bahn freizumachen, siehe hier:
http://bit.ly/UnAWUL

Arathorn.

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



Re^4: Sommerparty in HATTINGEN (Arathorn, 23. Jul 2014, 13:47:04):
~#! rn=Arathorn rt=1406115821 rg=party.bekanntmachungen
~#! tid=1394049825
Und Dunst macht mich drauf aufmerksam, dass bei der Route Industriekultur
eine ausfuehrlichere Liste zu finden ist, die auch konkrete Infos ueber
befahrbare Wege enthaelt:
http://www.route-industriekultur.de/route-per-rad.html

Arathorn, jetzt endlich fertig mit Updates. ;-)

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



MorgenGrauen Sommerparty 2015 (Miril, 26. Feb 2015, 21:21:26):
Liebe Mitmudder,

auch in diesem Jahr wird es wieder das allseits beliebte MorgenGrauen
Sommercamp geben. Freut euch auf eine Woche Camping an der Ruhr mit netten
Leuten, auf Rollenspielrunden, Rumhaengen, meist zuviel Essen, Ausfluege in
den Ruhrpott und vieles mehr. Wer weiss, falls genug kommen, lohnt sich
vielleicht sogar mal wieder eine RL Quest.

Nun aber zu den Dingen, die euch besonders interessieren:

Wann: 20.-26.7.2015 (d.h. die Woche vor Wacken)
Wo:   Campingplatz Ruhrbruecke, Hattingen

In der Vergangenheit gab es auch schon die Moeglichkeit, da einen Surfkurs
mitzumachen, falls jemand das moechte, kann er das kundtun und ich versuche,
es zu organisieren. Alle weiteren Infos findet ihr in Kuerze auf dem
Partybrett.

Miril

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



Hattingen 2016 (Humni,  6. Mai 2016, 23:32:40):
Hallo ihr,

wie auch im letzten Jahr wollen wir wieder in Hattingen eine Mudparty
veranstalten.

Hattingen liegt an der Ruhr, das heisst, da ist ein Fluss in der Naehe.
Dieser Fluss gibt der Region seinen Namen ("Ruhrgebiet"). Darum kann man 
dort auch in dem Fluss schwimmen oder in einer Surfschule das Surfen
erlernen. Falls das jemand moechte, kann ich auch gerne nach Kursen fragen
(oder ihr tut das selbst ;-) )

Wir sind jedenfalls hier:

http://www.camping-hattingen.de

Abgerechnet wird ueber den Campingplatz, sprich, wir haben wie ueblich
kein Konto, auf das im Voraus Geld ueberwiesen wird. Die Dinge, die fuer
alle gekauft werden, werden wie ueblich umgelegt.

Was noch? Ach ja, das Datum: Wie immer werden auch dieses Jahr quasi "direkt
von da aus" einige nach Wacken aufbrechen (oder, naja, 2 Tage spaeter). 
Sprich, die Woche ist vom 25.-31.7. Die eigentliche "Party" ist dann am
30.7. - aber eigentlich feiern wir die ganze Woche, ist ja klar.

Damit das Ganze dann auch entsprechend koordiniert werden kann, werde ich
bald die Partybretter aufstellen, damit der Anmeldeprozess auch in Gang
kommt.

Wir freuen uns schon!

Humni, auch i.A. der anderen Ruhrgegendbewohnern

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



Re: Hattingen 2016 (Zaphob,  7. Mai 2016, 19:32:35):
~#! rn=Humni rt=1462570360 rg=party.bekanntmachungen
~#! tid=1462570360
Partybrett behauptet, Party am 31. Was stimmt nun?

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



Re: Re: Hattingen 2016 (Humni,  8. Mai 2016, 15:19:48):
~#! rn=Zaphob rt=1462642355 rg=party.bekanntmachungen
~#! tid=1462570360
Stimmt. Am 30. Habs geaendert. Danke fuer den Hinweis.

Humni

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



25.3.2017 (Miril, 28. Jun 2016, 19:49:27):
Liebe Mudgemeinde,

wie einige von euch vielleicht wissen und man auf der Homepage (oder bei
finger miril) erkennen kann, hat das MUD im naechsten Jahr einen besonderen
Geburtstag. Es wird 25. Das dazugehoerige Datum, naemlich der 25.3.2017 faellt
erfreulicherweise auf einen Samstag.

Wir moechten diesen Tag nutzen, um eine 25-Jahresparty zu veranstalten und
moeglichst viele Altmudder und natuerlich auch Neumudder zu diesem Termin
einladen. Das derzeitige (selbsternannte) Partykomitee (bestehend aus einigen
EMs) wuerde als Veranstaltungsort das Ruhrgebiet  vorschlagen und hier
speziell eine passende Lokalitaet in Bochum und Umgebung (bis 20 km) suchen. 

Da viele von euch bekanntermassen nicht  mehr unbedingt Freunde von Zelten (im
Maerz eh unpopulaer) und  Uebernachtung in Turnhallen sind, gehen wir davon
aus, dass die sich meisten von euch selbst um Uebernachtungsmoeglichkeiten
kuemmern werden. 

Fuer weniger zahlungskraeftige Mudder koennen wir auch einige kostenlose
Schlafplaetze zur Verfuegung stellen.

Um das Ganze genauer planen und euch mit entsprechenden Informationen
versorgen zu koennen, brauchen wir jedoch verbindliche Anmeldungen fuer die
Party. Es ist nicht sinnvoll einen Raum fuer 100 Leute zu mieten und einen
entsprechenden Cateringservice zu beauftragen, wenn dann nur 20 Leute kommen. 

Daher werden wir in der naechsten Zeit Einladungen per Email verschicken, mit
der Bitte, sich verbindlich fuer die Party anzumelden. Diese verbindliche
Anmeldung waere dann auch mit einem Partybeitrag verbunden, der fuer Essen und
Raummiete verwendet werden wird. Getraenke koennen wir da aus
nachvollziehbaren Gruenden nicht mit rein nehmen ;).

Also Kurzzusammenfassung:

25 Jahresparty am 25.3.2017 in Bochum (oder Umgebung).
Einladung per Email folgt.
Verbindliche Anmeldung erforderlich (mit Anzahlung).
 
Falls ihr noch Kontakt zu Altmuddern habt, deren Kontaktadresse uns nicht
bekannt ist, immer her damit.

Falls sich jemand dem Partykomitee anschliessen moechte: Gerne.

Arathorn, Humni, Miril, Zesstra


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



Freitagsanreise (24.3.) (Zesstra, 26. Feb 2017, 18:38:50):
Huhu...

Fuer alle, die bereits Freitag abend anreisen wollen, wuerde ich in Kuerze
eine Lokalitaet zum Treffen in Witten aussuchen. Damit ich weiss, fuer
wieviele aber eigentlich, sagt ihr mir bitte bis zum 10.3. Bescheid...

Zesstra

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



Kultur am Partysamstag (Zesstra, 16. Mar 2017, 23:24:35):
Huhu...

also, wenn am Samstag der Party (25.3.) am Mittag-Nachmittag Interesse
besteht, sich kulturell oder touristisch zu betaetigen, biete ich an, Leute
auf Zollverein (bzw. Ruhrmuseum) in Essen oder auf Zeche Zollern in Dortmund
zu schleppen/begleiten.
Links:
https://www.ruhrmuseum.de/
https://www.lwl.org/industriemuseum/standorte/zeche-zollern

Zesstra

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



25J Morgengrauen: Letzte Infos (Zesstra, 20. Mar 2017, 20:26:02):
Hallo liebe Partygaeste,

fuenfmal werden wir noch wach, heissa, dann ist Partytach! :-)

Wir haben noch einmal alles Wichtige zur Party gesammelt fuer Dich
zusammengestellt:

- Fuer das Partybufett sammeln wir an dem Abend fuer jeden Erwachsenen
noch einmal 5 Euro ein, fuer Kinder zwischen 11 und 15 jeweils 10 Euro.
Kinder bis 10 Jahre essen kostenfrei mit. (Wer bisher den Partybeitrag
noch nicht ueberwiesen hat, bringt bitte 20 Euro pro Person mit.)

- Das Partygoodie kostet 6 Euro, solange der Vorrat reicht. Vorbesteller
werden bevorzugt (fuer diese sind auch ausreichend Goodies da). Fuer
Nachbestellungen werden wir ggf. eine Namensliste auslegen.

- Getraenke koennen einzeln bestellt und bezahlt werden oder ueber die
folgenden Pauschalen:
  1) Getraenkepauschale 15,00 Euro:
     AFG (alkoholfreie Getraenke)
  2) Getraenkepauschale 19,90 Euro:
     AFG & Bier
  3) Getraenkepauschale 24,90 Euro:
     AFG, Bier, Wein, Sekt, Likoer, Schnaps & Longdrinks
  4) Getraenkepauschale 29,90 Euro:
     AFG, Bier, Wein, Sekt, Likoer, Schnaps, Longdrinks & Cocktails

- Am Freitag Abend treffen sich frueh Anreisende und Interessierte Leute im
Finnegan's Irish Pub in Witten (neben dem HBf). Reserviert ist ab 20:00, offen
hat der Laden aber natuerlich auch schon vorher.
Bitte an zesstra@zesstra.de schreiben, wann ihr eintreffen wollt.
Adresse: Bellerslohstrasse 12, 58452 Witten

- Am Samstag tagsueber wuerde Zesstra ggf. mit Kulturinteressierten einen
Ausflug zur Zeche Zollverein + Ruhrmuseum (Essen) oder Zeche Zollern
(Dortmund) machen (Ziel: nach Mehrheitswunsch).
Treffpunkt: 10:50 am Bahnhof Witten, Abreise 11:00
Anreisende Samstag koennen auch direkt dorthin kommen, einfach telefonisch
fragen, wo wir sind (s.u.)
(Wer mit dem Auto fahren will: geht sicher auch, nehmt dann aber doch noch wen
ohne Auto mit. ;-)
Rueckkehr in Witten: nach Wunsch
http://www.zollverein.de/
https://www.lwl.org/industriemuseum/standorte/zeche-zollern

- Kontakttelefon
02052 1223 (Miril + Humni)
0171 3711667 (Miril)
0160 4634667 (Zesstra)
Die Mobilnummern sind auch via Signal (https://sgnl.link/1LoIMUI) zu
erreichen.

Die Party beginnt um 18:00 Uhr und findet im Excalibur in der Marienstrasse 13
in 58455 Witten statt.

Gruss,
[Team:Orga]

Zesstra

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



Re: 25J Morgengrauen: Letzte Infos (Zook, 28. Mar 2017, 11:46:36):
~#! rn=Zesstra rt=1490037962 rg=party.bekanntmachungen
~#! tid=1490037962
Wer Bilder gemacht hat und die veroeffentlichen moechte, bitte einfach
bei mir melden und vorher 
http://mg.mud.de/realworld/hinweise.shtml
beachten. 

Ggf. auch etwaige Persoenlichkeitsrechte von Leuten beachten. Ich gehe 
davon aus, dass das gemacht wird, bevor man mir die Bilder gibt. :-)

Zook.

PS: Und ja, ich habe schon mal jemanden nachtraeglich aus >10J alten
Partybildern herausgekramt und die Bilder entfernt, das war kein Spass,
auch nicht fuer einen Junggott[tm].


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



Re: Re: 25J Morgengrauen: Letzte Infos (Gloinson, 28. Mar 2017, 12:13:31):
~#! rn=Zook rt=1490694396 rg=party.bekanntmachungen
~#! tid=1490037962
Teddy moechte ungern protraetiert werden. Beim Rest bin ich auf die uebliche
Indifferenz nach dem Blitz gestossen, dieses blinde, wirre Starren ins Leere.

Ansonsten waer es total toll, wenn mir irgendwer, der jetzt zu Sinnen gekommen
ist, mir kurz in einem Mail zukommen laesst, wenn er nicht veroeffentlicht
werden will. Die Pull-Methode funktioniert erfahrungsgemaess auch schlecht.


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



Re^3: 25J Morgengrauen: Letzte Infos (Perdita, 29. Mar 2017, 20:21:41):
~#! rn=Gloinson rt=1490696011 rg=party.bekanntmachungen
~#! tid=1490037962
ich schliesse mich dem Gloinson an - wer NICHT mit veroeffentlicht werden
moechte, moege mir doch bitte Bescheid geben.
Gruss
Perdita

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



Sommertreffen in Hattingen (Humni, 21. Apr 2017, 20:27:12):
Hallo ihr,

man kann sicher drueber streiten, ob man das "die offizeille MG-Party" nennen
soll. Und wir wollen sicher auch niemanden hindern, an anderen Orten diese
abzuhalten.

Aber so wie es aussieht, werden wir wohl die Woche vor Wacken (also vom
24.-30.7.) wieder in Hattingen campen. Und wie immer waere das toll, wenn ihr
dabeiseid. Und zwar moeglichst viele.

Wenn sich keine Konkurrenzveranstaltung findet, werden wir natuerlich auch
wieder ein Partybrett dafuer aufstellen.

Humni
(der dann den Artikel auch nach treffen.bekanntmachungen verschiebt, wenn
gewuenscht).

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



Re: Sommertreffen in Hattingen (Humni, 27. Jun 2017, 21:07:20):
~#! rn=Humni rt=1492799232 rg=party.bekanntmachungen
~#! tid=1492799232
So. Konkurrenz scheint es keine zu geben, also wird das Hattingen-Camp die
"offizielle" Sommerparty.

Ab sofort kann man sich auf Partybrettern anmelden.

Wir freuen uns auf euch!

Humni i.A. der Orga

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



SOMMERPARTY IN HATTINGEN! (Humni,  9. Feb 2020, 21:00:27):
Wie mir zugetragen wurde, campen wir dieses Jahr zum zehnten Mal in Hattingen.
Das sollte dadurch gefeiert werden, dass alle kommen und mitmachen!

Meldet euch also fleissig an. Wie immer ist die Partywoche in der letzten
vollen Juliwoche, also der Woche vor Wacken, sprich vom 20.-26.7.2020.

Wir sind wie immer auf dem Campingplatz Ruhrbruecke.

Details stehen auf den Partybrettern - und wie jedes Jahr: Wir freuen uns auf
euch!

Humni, i.A. der PartyorganisatorInnen, die ... den Platz reserviert haben.

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



Re: SOMMERPARTY IN HATTINGEN! (Humni, 25. Apr 2020, 23:33:20):
~#! rn=Humni rt=1581278427 rg=party.bekanntmachungen
~#! tid=1581278427
So, mal ein kurzes Update nach einigen Diskussionen:

Hattingen koennte zur Zeit nicht stattfinden. Aber "Zur Zeit" ist noch nicht
Juli. Und ja, alle Grossveranstaltungen sind abgesagt, aber das ist keine
Grossveranstaltung. Und ich traue uns im Zweifel zu, auch unterm Zelt Abstand
zu halten.

Langer Rede, kurzer Sinn: Ich wuerde zum derzeitigen Zeitpunkt ungerne sagen,
wir canceln das. Klar, vor allem darum nicht, da das der dritte Urlaub in
diesem Jahr fuer mich waere (von dreien), der gecancelt wuerde, da bin ich
Egoist ich weiss, dass ich damit natuerlich nicht alleine bin). Aber bis dahin
ist das Virus fast 4 Monate aelter und wir wissen mehr. Vielleicht haben wir
dann Regeln, die das erlauben. Vielleicht haben wir dann aber auch Regeln, die
es theoretisch erlauben, aber faktisch Empfehlungen, sowas nicht zu tun.

Ich wuerde das aber bis dahin - oder bis deutlich naeher oder bis wirklich
mehr absehbar ist - stehenlassen. 

Und nein, ich gehoere nicht zu der "Ach, mir passiert schon nix!"-Fraktion,
ich halte mich an die Regeln, halte Abstaende und gehe mit Schlauchtuch vor
der Nase ins Gesicht - jetzt schon, wo ich das noch gar nicht muss.

Sprich, wenn das "erlaubt aber ernsthaft risikobehaftet" ist, wuerde ich da
auch nicht hinfahren.

Andererseits mutet mir mein Landeschef zu, am Montag wieder vor Schuelern zu
stehen, um sie auf eine Pruefung vorzubereiten, die gar nicht mehr zentral
abgehalten wird ... aber gut, man sollte nicht mit "Das ist auch kacke, dann
koennen wir auch das machen" argumentieren.

Ich will halt jetzt noch nicht aufgeben. So. ;-)

Humni

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



Re: Re: SOMMERPARTY IN HATTINGEN! (Humni, 12. Jul 2020, 17:10:44):
~#! rn=Humni rt=1587850400 rg=party.bekanntmachungen
~#! tid=1581278427
Hallo ihr,

ich denke, ich packe das in diese Rubrik, weil es auch hier hingehoert:

* Wir koennen dieses Jahr in Hattingen zelten. Jutta Stolle, die
  Campingplatzbetreiberin, freut sich auch schon auf uns.
* Wir muessen im Haus (Klo, Dusche) und am Haus (Spuelbecken) Masken tragen.
  Manche Spuelbecken bzw. Waschbecken sind gesperrt, um Abstaende 
  einzuhalten.
* Das Ordnungsamt hat gesagt, dass wir nicht mit mehr als 10 Leuten eine
  Gruppe bilden duerfen. Sprich: Wir machen da nicht "eine Veranstaltung",
  sondern "drei Veranstaltungen", wenn ich mich nicht verzaeht habe. Das 
  heisst nicht, dass man nicht miteinander reden darf oder nicht auch mal 
  wechseln darf, aber wir sollten deutlich sichtbar mehrere Gruppen bilden, 
  die nicht mehr als 10 Personen haben.
* Sprich, wir sollten auch die Zelte sichtbar gruppieren. Da ist eine Gruppe
  von Zelten, da noch eine, da noch eine. Dadurch kann es passieren, dass 
  dieses Jahr das ein oder andere Zelt in der Sonne steht, das sonst im 
  Schatten haette stehen koennen. Ist doof, kann ich nachvollziehen, aber 
  muessen wir beachten.
* Wir werden nicht alle unter unseren Pavillon passen. Wir brauchen also noch
  mehr.
* Bitte kommt dieses Jahr nicht spontan vorbei, sondern meldet euch an.
  Aus genannten Gruenden.
* Dieses Jahr gibt es also am Samstag abend auch keine eigentliche "Party" -
  da zelten nur Leute in einem Bereich.
* Kommt keinesfalls, wenn ihr irgendwelche Krankheitssymptome habt. Das
  faellt irre schwer, wuerde es mir auch. Aber das sollte niemand riskieren.

Hoffen wir, dass das dieses Jahr eine Ausnahme ist und wir naechstes Jahr alle
durchgeimpft sind ... und, wir wissen ja nun auch: Draussen ist die Gefahr
deutlich geringer als drinnen. Von daher mache ich mir keine grossen Sorgen,
wenn alle die Regeln einhalten. Aber nochmal: Ihr kommt da alle auf eigene
Gefahr hin - eine Sicherheitsgarantie kann euch niemand geben.

Ihr koennt die Regeln gerne hinterfragen - Jutta hat diese Auflagen vom
Ordnungsamt und wird sie durchsetzen muessen. Punkt. Und darum sollten wir uns
auch daran halten, auch wenn ihr denkt, dass es nicht sonderlich logisch ist,
dass wir "draussen" die Bereiche trennen muessen.

Bis dann - wir freuen uns schon auf den einzigen Jahresurlaub, der wohl
hoffentlich zumindest annaehernd so verlaeuft, wie man das Anfang des Jahres
gehofft hat und der nicht einfach so ausfaellt ...

Humni

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



Re^3: SOMMERPARTY IN HATTINGEN! (Saray, 23. Jul 2020, 18:22:05):
~#! rn=Humni rt=1594566644 rg=party.bekanntmachungen
~#! tid=1581278427
So, hier noch mal fuer alle, die es interessiert:
Rhovan und ich sind ab morgen da!!!! *freufreufreu*
Der Test war also negativ.

Saray

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



Hattingen 2021 (Humni, 19. Feb 2021, 19:13:53):
Hallo ihr,

so, ihr werdet Staunen und das Unerwartete wird euch jetzt voellig uebermannen
und ...

Also, auch dieses Jahr wird es eine Party in Hattingen geben. Oder zumindest
ein gemeinsames Zelten. Voraussetzung ist natuerlich, die Pandemie erlaubt uns
das, aber da hoffen wir jetzt einfach mal drauf.

Auch, wenn Wacken wohl ... zumindest fraglich ... erscheint, wird es wie immer
in der Woche davor stattfinden, also in der letzten vollen Juliwoche:
19.-25.7.

Details und Bretter folgen, dies als erstes "Save the date". Die Modalitaeten
sind wie immer, wir kriegen die Wiese.

Humni

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



Re: Hattingen 2021 (Humni,  6. Jul 2021, 09:07:43):
~#! rn=Humni rt=1613758433 rg=party.bekanntmachungen
~#! tid=1613758433
Hallo ihr!

Nun mal ein Update:

Bisher sieht alles gut aus, Jutta freut sich auch schon auf uns. Wir haben
wieder den Platz vom letzten Mal, das geht also alles klar. Nun kann noch das
Wetter bloed sein, hoffen wir mal, dass das nicht der Fall ist - nach 40 Grad
sieht es dieses Jahr aber nicht aus.

Bei der Ankunft muesst ihr einmal eine nicht aelter als 48 Stunden altes
negatives Testergebnis vorlegen, oder euren Impfausweis, wenn ihr durchgeimpft
seid und das laenger als 2 Wochen her ist, oder einen Nachweis, dass ihr vor
mehr als 28 Tagen positiv wart. Testzentren sind aber genug in der Naehe.

Unter der Woche muesst ihr euch dann nicht mehr testen, empfehlenswert ist das
natuerlich doch. Ich bringe einige Tests mit (ich stell die eh auf youtube vor
und hab darum noch so einige rumfliegen ...), wir sollten also erstmal damit
versorgt sein. Zettel ausstellen darf ich natuerlich nicht, aber Testzentren
sind hier wirklich an allen Ecken.

Wir freuen uns auf euch und natuerlich nochmal danke an Zaphob fuer die ganze
Kuemmerei!

Humni

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



Re: Re: Hattingen 2021 (Humni, 12. Jul 2021, 20:27:45):
~#! rn=Humni rt=1625555263 rg=party.bekanntmachungen
~#! tid=1613758433
Und noch ein Update: Da es so aussieht, als duerfte ich keine Zertifikate
ausstellen, muesst ihr vermutlich ein offizielles Testzentrum aufsuchen. Das
ist aber auch bei der Ankunft kein echtes Problem, es sei denn, ihr kommt nach
20 Uhr oder so an - dann haben die zu, dann solltet ihr vorher unterwegs eins
aufsuchen.

Kommt ihr aus Richtung Ortszentrum Hattingen, also "ueber die Bruecke", dann
ist nach der grossen zentralen Kreuzung (mit dem Reschop-Karee, am S-Bahnhof
Hattingen Mitte) die erste Ausfahrt links ein Testzentrum ausgeschildert. Das
findet ihr, ich bin sicher.

Auch auf der Hattinger Strasse, wenn ihr von Bochum reinkommt, ist ein
Testzentrum, da muesst ihr auch kurz vor dem Campingplatz links abbiegen.

Ich weiss gerade nicht sicher, ob man von der Wuppertaler Strasse auch an das
Testzentrum drankommt (das ist zwischen Hattinger und Wuppertaler Strasse). Da
kann es sein, dass ihr an der Kreuzung direkt am Campingplatz (an der
Campingplatz-Ampel, quasi) dann rechts fahren muesst, wieder rechts und dann
noch ein Stueck Richtung Bochum, dann muesst ihr rechts abbiegen zum
Testzentrum.

Wenn wir abends rausgehen wollen, und man dann einen Test braucht (gerade
braucht man keinen, aber wer weiss, was Delta und Lambda in einer Woche
veranstalten), ist im Bermudadreieck auch direkt ein Testcenter.

Sollte also alles auffindbar sein. Aber gut, Googeln koennt ihr auch selbst.

Humni

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



Re^3: Hattingen 2021 (Ark, 13. Jul 2021, 16:18:44):
~#! rn=Humni rt=1626114465 rg=party.bekanntmachungen
~#! tid=1613758433
Heute und die naechsten Tage wuerde ich mir eher ueber Wasser Gedanken machen,
hier ist der Regen schon beinahe da ... wollte heute frueh noch giessen
*muahaha* hab aber dann doch noch was gemerkt :-)


              *** ARK * the * Magnificent ***


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



Re^4: Hattingen 2021 (Deaddy, 13. Jul 2021, 16:43:34):
~#! rn=Ark rt=1626185924 rg=party.bekanntmachungen
~#! tid=1613758433
Das macht eigentlich nichts, Bier sollten wir schon irgendwie kuehl halten
bekommen und Wasser koennen wir zur Not in die Ruhr schuetten.

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



Absage (Humni, 15. Jul 2021, 15:26:51):
Hallo ihr,

es tut mir wirklich furchtbar leid, aber wir werden die Sommerparty und das
Sommercampen in der Form in diesem Jahr nicht machen koennen. Jutta vom
Zeltplatz hat mir eben eine Mail geschrieben, das Haus steht bis unten unter
Wasser, da geht erstmal gar nichts, saemtliche Raeumlichkeiten, die wir sonst
als Infrastruktur hatten, sind auch ueberflutet.

Ich habe ihr geschrieben, dass ich mich naechste Woche noch einmal melden
will, ob wir spontan noch was machen koennen (ich zweifle ein wenig, dass das
Wochenende danach gehen wird, aber vielleicht die Woche drauf) - aber klar ist
auch, dass dann viele nicht koennen. Und ja, ich weiss, dass einige dafuer
Urlaub genommen haben - aber dieses Unwetter hat, denke ich, niemand so kommen
sehen.

Humni

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



Umbuchung (Bugfix, 16. Jul 2021, 16:43:18):
Moin,

Nachdem ich jetzt ein bisschen in der Gegend herumtelefoniert habe, konnte ich
in Datteln etwas fuer uns festmachen.

https://www.freizeitpark-klaukenhof.de/

Preislich duerfte das grob in die selbe Richtung gehen wie in Hattingen,
ansonstne kann ich bisher wenig sagen, weil grade im Fokus stand ueberhaupt
etwas zu finden. Mir konnte nicht garantiert werden, dass wir unsere Pavillons
aufstellen koennen, aber wir sollen sie ruhig einfach mal mitbringen,
vermutlich wird das gehen.

Vielen Dank an alle, die jetzt bei der Suche unterstuetzt haben.

Bugfix

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



Re: Umbuchung (Bugfix, 16. Jul 2021, 16:46:40):
~#! rn=Bugfix rt=1626446598 rg=party.bekanntmachungen
~#! tid=1626446598
Achja, falls ihr eine der vorhandenen Unterkuenfte gegenueber einem Zelt
bevorzugen solltet, dann gebt bitte bei der Buchung an, dass ihr zu der Gruppe
gehoert, die von Henning Ullrich gebucht wurde und sagt dazu, dass
dementsprechend ein Zelt weniger dabei ist.

Bugfix

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



Re: Re: Umbuchung (Bugfix, 16. Jul 2021, 21:52:39):
~#! rn=Bugfix rt=1626446800 rg=party.bekanntmachungen
~#! tid=1626446598
Da hier die Frage aufkam: Ich hab angemeldet, dass ungefaehr 28 Personen +
Kinder kommen. Ihr braucht euch also nicht vorab beim campingplatz zu melden,
es muss sich dann aber da jeder selbststaendig an- und abmelden fuer die
Abrechnung.

Bugfix

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



Re^3: Umbuchung (Bugfix, 17. Jul 2021, 08:15:03):
~#! rn=Bugfix rt=1626465159 rg=party.bekanntmachungen
~#! tid=1626446598
Und noch eine Info, da bei uns grade die Frage aufkam: aktuell braucht man
fuer den Campingplatz wegen der niedrigen Inzidenzwerte keinen Coronatest,
sollte man unter der Woche einen brauchen, gibt es aber auch Testzentren in
der Gegend.

Ist natuerlich trotzdem sinnvoll, wenn ihr euch alle vorher testet oder testen
lasst.

Bugfix

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



Re^4: Umbuchung (Humni, 18. Jul 2021, 19:45:08):
~#! rn=Bugfix rt=1626502503 rg=party.bekanntmachungen
~#! tid=1626446598
Hallo,

das Vorauskommando hat soeben vermeldet, dass an dem Platz in Datteln
irgendwas gebaut wird. Darum kann man nicht mit Karte zahlen. Es waere also
schlau, Bargeld mitzubringen.

Ja, ist unueblich. Diese komischen Scheine und Muenzen und so ...

Humni

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



Hattingen 2022 (Humni,  2. Apr 2022, 18:40:11):
Liebe Mudgemeinde,

ich habe soeben mit Jutta vom Campingplatz gemailt. Und - was soll ich sagen -
dieses Jahr duerfen wir wiederkommen!

Wie immer habe ich uns die Woche "vor Wacken" reserviert. Da Wacken dieses
Jahr recht spaet ist, ist das die Woche vom 25.-31.7.
Sprich, ein wenig spaeter als gewohnt.

Ich soll alle schoen von Jutta gruessen und werde demnaechst auch Partybretter
aufstellen, hier aber schonmal das "Save the Date!"

Was? 
Mudparty und grosses Jahrestreffen des MorgenGrauen

Wo? 
Campingplatz unter der Ruhrbruecke in Hattingen
http://www.camping-hattingen.de/

Wann?
25.-31.7.2022

Es gelten bisher 2G-Regeln und natuerlich Maskenpflicht, den aktuellen Stand
kann man kurz vorher auf der Homepage begutachten.

Humni

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



Eilmeldung: Gloinsons Bilder von der 25 Jahre Party in Witten sind online! (Zook, 29. Jul 2023, 15:20:53):

Hallo zusammen,

Gloinsons tolle Bilder von der 25 Jahre Party in Witten sind nun auf der
Homepage zu finden:


http://mg.mud.de/realworld/Party.48/fotos.gloinson/

Zook

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



Re: Eilmeldung: Gloinsons Bilder von der 25 Jahre Party in Witten sind online! (Zesstra, 30. Jul 2023, 14:08:41):
~#! rn=Zook rt=1690636853 rg=party.bekanntmachungen
~#! tid=1690636853
Yeeaaahhhh. :-)

Zesstra

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



