Spielmodi ohne großen Aufwand

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Spielmodi ohne großen Aufwand

      Einen wunderschönen guten Abend,
      ich überlge seit einer Weile wie man schnell, einfach und ohne echten Aufwand (finanziell und zeitlich) die Dynamik beim Paintball ein bisschen verändern kann.
      Ich habe unter Dusche über Spielmodi nachgedacht, die man so testen könnte. Grundsätzlich würde ich das auch nur machen, wenn alle da Bock drauf haben.

      #1 Capture the Flag
      Kennt eigentlich jeder. In der Mitte des Feldes wird eine Poolnudel oder ähnliches hingestellt und die muss dann in die eigene Basis gebracht werden.
      Pro: Kennt eigentlich jeder
      Con: ?

      #2 Extraction
      Ein Spieler bekommt eine Markierung (z.B. einen Laborkittel) und diese Person muss dann zu einem bestimmten Punkt auf dem Feld gebracht werden. Bietet sich natürlich vor allem für Felder an auf denen Attrappen von Fahrzeugen stehen.
      Sollte das zu schwierig werden kann die Person ein zweites Leben bekommen.

      #3 Respawn
      Jedes Team bekommt eine festgelegte Anzahl an Leben und jeder getroffene Spieler geht in den Spawn zurück und kann sich dort wiederbeleben. Ich dachte daran Poker-Chips mitzunehmen und jedem Team entsprechend Chips an den Spawn zu packen, die dann in eine Dose geworfen werden.
      Pro: Unterschiedliche Teamgrößen werden ein bisschen ausgeglichen
      Con: Die Runde dauert evtl länger und andere Spieler müssen dementsprechend länger warten.

      #3.1
      Es werden Respawn-Chips auf dem Feld verteilt und wer es schafft die Chips zu seinem Start zu bringen, der kann seinem Team Respawns verschaffen.

      #4 Ammo Storage
      Für Hopper-Spiele. Es dürfen keine Pods aufs Feld gebracht werden, Vor dem Spiel werden x Pods verteilt, die erobert werden können, damit man nachladen kann.
      (Funktioniert halt nicht mit MagFed, LowCap, Pumpenspielern und so.)

      #5 Bombenentschärfung
      Ich könnte mir vorstellen ein relativ simples Programm für den ESP32 zu schreiben, das eine Zeit runterzählt wenn ein Taster gedrückt wurde: Aktivierung per Taster, Countdown startet, Deaktivierung per Taster, das Ganze in einer Kiste mit Zahlenschloss, damit es ein bisschen dauert bis man das Ding ein- oder ausschalten kann. Rote oder grüne LEDs zeigen Explosion/Entschärfung an.

      Was funktioniert? Was funktioniert nicht? Worauf muss ich achten? Wie gut funktioniert das mit Leuten, die zum ersten/zweiten Mal dabei sind? Wie gut klappt das ohne Funk? Macht das überhaupt Sinn?

      Danke für eure Antworten!

    • Ist alles umsetzbar,weil schon mal dagewesen....

      zu #4

      Funktioniert NATÜRLICH auch mit low cap(10er Röhrchen,50er pötte) und Mags (jeder packt seine an Punkt x y/Refs bringen sie/werden in die Mitte gelegt)...

      Gibt's sogar Videos...

      zu #5

      Hab sogar schon selbst in Garzau nen Event gemacht..."Defuse the Bomb"...kleine Geldkasette mitm bisschen blinki und pipsi und Tastenfeld sprengen auch dem kleinsten finanziellen Rahmen nicht zu sehr...

    • Klar kann mal viel mit Standart Feldausrüstung wie Leibchen und Flaggen machen.

      Eine gewisse Optik und Haptik bei den Gadgets hat aber einen eigenen Effekt ;)
      Natürlich kann man ne X-Beliebige Holzkiste als "Nuke" nutzen, aber wenn man ne alte BW-Munitionsbox nimmt, schön lackiert, Gewichte rein, vlt. Ne Drehlampe... hat das nen ganz anderes Feeling. Liebe zum Details macht sich bezahlt.

      Der Aufwand muss natürlich nicht für jede einzelnen Spielrunde betrieben werden, aber sowas sorgt für Aufsehen und motiviert den ein oder anderen Leihspieler zum wiederkommen :2cent:

      Die "Schachuhren" im Paintballpark Westfalen werden häufiger von Leihspielern angefragt, die nicht zum ersten mal da sind.
      (Munitionskiste mit 2 Buzzern, wer drückt für den zählt die zeit, meiste Zeit Gewinnt, steht mittig auf dem eher offenen Feld, mit respwawns)

      PS: kann sicher auch günstiger Nachgebaut werden, aber gerade bei Leihspielern muss Technik Idiotensicher und zuverlässig sein -> leider durchkreuzt das auch manche Spielidee
      Fashionball! Style for Function :gun:

    • Zu 5. hab ich was gebaut. 3D Druck Gehäuse, Innenleben ein arduino, lcd Display, Summer, 4xAA Batterien, paar Schalter. Der Rest ist arduino IDE.

      Wichtig für mich war , das man es mit einer Hand mitnehmen kann, zum Scharf machen und entschärfen aber beide Hände benötigt.

      Viele Grüße

      Matze

      IMG_8302.jpegIMG_8303.jpegIMG_8300.jpegIMG_8301.jpegIMG_8299.jpegIMG_8298.jpegIMG_8289.jpeg

    • @Schabe
      Danke für den Hinweis. Ich bin mir bei Videos halt nie sicher wie repräsentativ die sind. Niemand wird Videos hochladem bei denen es Scheisse war.
      Und wenn hier der Tenor wäre, dass es in 8 von 10 Fällen Mist ist, 1x okay und 1x geil, dann würde ich mir das stark überlegen.

      @V+Krombacher
      Gehe uch komplett mit, aber bevor ich in ein eh schon zeitaufwändiges und teures Hobby Ressourcen versenke, teste ich erstmal ein Konzept mit Kram, der eh da ist. Und was läuft wird ausgebaut, was nicht läuft wird ignoriert.

      @Smoudo
      Ich habe meine Python-Fähigkeiten offenbar massiv überschätzt, aber im Endeffekt möchte ich auch so eine Kiste. :S :grinser:
      Nuja, ich wollte das eh weitermachen, hatte aber wenig Motivation im letzten halben Jahr mich da ran zu setzen. Jetzt habe ich ein Ziel.

    • Die Schalter gehören ne Nummer größer gemacht, da mit Handschuhen schwer bedienbar, ansonsten ist das Ding top und funktioniert auch gut. Einzigst das booooom fehlt noch akustisch.

      Das Gehäuse ist aus thingiverse. Das Innenleben hab ich gezeichnet. Kann ich bei Bedarf teilen.
      Elektronik ist aus fernost. Alles in allem für <20€ Material machbar

    • Kein EOD'ler trägt Handschuhe....mach den scheiß so klein und fummelig wie es geht... :evil:

      Irgendwie muss man ja nen bisschen Druck aufbauen :angel:

    • Hi,

      ich hab da einiges gemacht in diesen Dingen. Allerdings nicht genau das was Du beschrieben hast. Das mit den Respawns zählen geht schon zuverlässig (vor allem bei Conquest) und dem "Sachen in den Spawn" bringen ist zur Zeit über RFID in Arbeit.

      Ansonsten kann das System einige Spielmodi wie man das von Battlefield oder so kennt. Ist alles opensource.

      Ein paar Videos für die Spieler (um Dir ein Bild zu machen) findest Du hier

      Falls Dich was interessiert, meld Dich.
      Real Life Gaming System flashheart.de

    • Riesen Vorteil von Poolnudeln:
      Ein "GOTCHA!" entfällt völlig. Nimmst einfach die Nudel und haust sie dem Kollegen über'n Schädel. Musst nur aufpassen, dass die Maske sitzen bleibt...
      Error 404: Signature not found

    • Für meine Version benötigst du 5 Taster und einen Switch
      Ich hab 2x rot leuchtend(scharf machen)
      2x grün leuchtend (entschärfen)
      1x weis (Spielmodi)
      1x An/Aus Schalter für Spannung

      bei Bedarf melden, schick ich dir den Sketch zu.
      Musst du halt für den esp die Ports entsprechend anpassen.

    • @Simon-D
      Die Headshots klingen gut, aber ich bin mir unsicher ob Bonusballing als Spielmodus so richtig gut ankommt.
      Da macht dann das Equipment noch größeren Unterschied, oder? Ich hab keine Erfahrung damit gemacht, aber so von außen wirkt es so als hätten EPneus (generell schnelle Semi-Autos) einen Riesenvorteil gegenüber den Leih-FT-12 (oder gar Pumpen).

    • Hallo,
      kurzes Update. Ich habe mich hingesetzt und quasi eine Schachuhr gebaut, Version 0.1 alpha, das Ganze in ein Gehäuse gepflanzt und mit Kabelbindern auf eine Powerbank gepflanzt.
      Wir waren gestern spielen und haben den Time-Domination Modus getestet. (Bomb Defuse ging irgendwie unter.)

      War geil. Kann ich echt empfehlen um die Dynamik komplett zu ändern, aber es ging schon hart zur Sache. Wir haben die Kiste in der Mitte eines Bunkers auf einen Hyperball-Feld platziert, sodass man halbwegs gedeckt war von allen Seiten , wenn man die Taster drücken wollte. Der Gedanke war, dass man dadurch die Zeit hat sich zu bücken um an die Kiste heranzukommen, aber es wurde ein absolutes CQB Horrorszenario indem der komplette Komplex umkämpft wurde. Gespielt haben wir 3v3 mit Respawn, 2 Minuten musste der Punkt gehalten werden, das Einnehmen bis jemand den Tiner aktivieren konnte hat mindstens genausolange gebraucht. :grinser:

      Die Box selber ist noch sehr einfach, da wird es definitiv Erweiterungen und Verbesserungen geben. Aber als erster Testlauf war das okay.20240815_200851.jpg

    • @V+Krombacher vielen, vielen Dank für deinen Input! Ich bin wieder dabei zu basteln und den Code schrittweise zu verbessern.

      Hier sind die Code-Schnipsel, die ich für die Box verwende. Roast me! :grinser:

      Python-Quellcode

      1. import time
      2. from machine import Pin, I2C
      3. import ssd1306
      4. import machine
      6. i2c = machine.SoftI2C(scl=Pin(5),sda=Pin(4), freq=10000)
      7. oled = ssd1306.SSD1306_I2C(128, 64, i2c)
      9. b1=Pin(12, Pin.IN, pull=None)
      10. b2=Pin(18, Pin.IN, pull=None)
      12. while True:
      13. oled.fill(0)
      14. oled.text("Bomb", 0, 0)
      15. oled.text("-> Red", 50, 0)
      16. oled.text("Dom", 0, 50)
      17. oled.text("-> Green", 50, 50)
      18. oled.show()
      19. while b2.value()==1:
      20. import bombdefuse2.py
      21. while b1.value()==1:
      22. oled.fill(0)
      23. oled.text("Point", 0, 0)
      24. oled.text("-> Red", 50, 0)
      25. oled.text("Time", 0, 50)
      26. oled.text("-> Green", 50, 50)
      27. oled.show()
      28. #time.sleep(3)
      29. while b2.value()==1:
      30. for i in range(3):
      31. i=i+1
      32. import domination2.py
      33. while b1.value()==1:
      34. for i in range(3):
      35. i=i+1
      36. import domination_time.py
      37. while b1.value()==0 and b2.value()==0:
      38. for i in range(10):
      39. i=i+1
      40. break
      Alles anzeigen
      Das ist das Hauptmenü, in dem man die Spieldmodi (Bombdefuse und Domination) wählen kann.

      Hardware ist ein ESP32 mit OLED-Display, zwei Buttons (rot und grün), zwei LEDs (rot und grün), ein Piepser.

    • Das hier ist der Bombenentschärfungsmodus:

      Python-Quellcode

      1. import time
      2. from machine import Pin, I2C, Timer
      3. import ssd1306
      4. import machine
      6. i2c = machine.SoftI2C(scl=Pin(5),sda=Pin(4), freq=10000)
      7. oled = ssd1306.SSD1306_I2C(128, 64, i2c)
      9. b1=Pin(12, Pin.IN, pull=None)
      10. b2=Pin(18, Pin.IN, pull=None)
      12. beep=Pin(13, Pin.OUT)
      14. lg=Pin(14, Pin.OUT)
      15. lr=Pin(25, Pin.OUT)
      17. lg.value(0)
      18. lr.value(0)
      19. beep.value(0)
      21. tim=Timer(0)
      22. led_state = False
      24. ta = 3 #Aktivierungszeit
      25. tb = 10 #Bombentimer
      26. td = 3 #Deaktivierungszeit
      28. a = 0
      29. b = 0
      30. d = 0
      32. x=1
      34. def restart():
      35. oled.text("Restart?",0,15)
      36. oled.text("Red: Yes", 0, 30)
      37. oled.text("Green: No", 0, 45)
      38. oled.show()
      40. def initiate():
      41. #oled.fill(0)
      42. oled.text("To initiate", 0, 0)
      43. oled.text("countdown hold", 0, 15)
      44. oled.text("B1 and B2 for",0, 30)
      45. oled.text(str(ta), 0, 45)
      46. oled.text("seconds", 30, 45)
      47. oled.show()
      49. def activate():
      50. #oled.fill(0)
      51. oled.text("Time to activate", 0,0)
      52. oled.text("the bomb:", 0, 15)
      53. #oled.text(str(ta-a), 90, 15, 0)
      54. oled.fill_rect(90,15,20,10,0)
      55. oled.text(str(ta-a), 90, 15)
      56. oled.rect(5, 50, 101, 10, 1) #xtop, ytop, breite, höhe, farbe
      57. oled.fill_rect(6, 51, aa, 8 , 1)
      58. oled.show()
      59. def countdown():
      60. #oled.fill(0)
      61. oled.text("Countdown:", 0,0)
      62. oled.fill_rect(80,0,30,10,0)
      63. oled.text(str(b), 80, 0)
      64. oled.text("s", 100, 0)
      65. oled.rect(5, 15, 101, 10, 1) #xtop, ytop, breite, höhe, farbe
      66. oled.fill_rect(6, 16, 100-bb, 8 , 1)
      67. #tim.init(period = 300, mode = Timer.PERIODIC, callback = Flash_LED)
      68. #Flash_LED()
      69. defusing()
      70. oled.show()
      71. def Flash_LED(timer):
      72. #global led_state
      73. #led_state = not led_state
      74. #lg.value(led_state)
      75. #lr.value(not led_state)
      76. #beep.value(led_state)
      78. if b%2 == 0:
      79. lg.value(1)
      80. lr.value(0)
      81. #beep.value(1)
      82. else:
      83. lg.value(0)
      84. lr.value(1)
      85. beep.value(0)
      86. def defusing():
      87. oled.text("Defuse:", 0,35)
      88. #oled.text(str(td-d), 80, 35, 0)
      89. oled.fill_rect(80,35,30,10,0)
      90. oled.text(str(td-d), 80, 35)
      91. oled.text("s", 100, 35)
      92. oled.rect(5, 50, 101, 10, 1) #xtop, ytop, breite, höhe, farbe
      93. oled.fill_rect(6, 51, dd, 8 , 1)
      94. def boom():
      95. oled.fill(0)
      96. oled.text("KA-BOOOOM!", 0,0)
      97. oled.show()
      99. def defused():
      100. oled.fill(0)
      101. oled.text("Defused!", 0,0)
      102. oled.show()
      104. while True:
      105. while x==1:
      106. ########################################
      107. lg.value(0)
      108. lr.value(0)
      109. beep.value(0)
      110. oled.fill(0)
      111. initiate()
      112. oled.fill(0)
      113. ########################################
      114. while(a < ta):
      115. #oled.fill(0)
      116. aa = int(a*100/ta-1)
      117. if b1.value()==1 and b2.value()==1:
      118. activate()
      119. time.sleep(1)
      120. a = a+1
      121. else:
      122. a=0
      123. time.sleep(3)
      124. ########################################
      125. lg.value(1)
      126. lr.value(1)
      127. time.sleep(2)
      128. oled.fill(0)
      129. ########################################
      130. for b in range(tb, -1, -1):
      131. bb = int(b*100/tb-1)
      132. dd = int(d*100/td-1)
      133. countdown()
      134. Flash_LED(b)
      135. time.sleep(1)
      136. if b1.value()==1 and b2.value()==1:
      137. d=d+1
      138. time.sleep(1)
      139. if(d==td):
      140. break
      141. else:
      142. pass
      143. else:
      144. d=0
      145. pass
      146. if (b==0):
      147. boom()
      148. a=0
      149. b=0
      150. d=0
      151. lr.value(1)
      152. lg.value(0)
      153. beep.value(1)
      154. time.sleep(5)
      155. else:
      156. defused()
      157. a=0
      158. b=0
      159. lr.value(0)
      160. lg.value(1)
      161. beep.value(0)
      162. time.sleep(5)
      163. x=0
      164. restart()
      165. while x==0:
      166. if b2.value()==1:
      167. x=1
      168. break
      169. elif b1.value()==1:
      170. import main.py
      171. else:
      172. pass
      Alles anzeigen
      Das ist die Bombenentschärfung in all ihrer Pracht. Die Aktualisierung des Displays benötigt etwas Zeit, daher "hakt" das Programm jedesmal, wenn das Display neu aufgebaut wird.
      @V+Krombacher hat mir bei der Optimierung geholfen. Jetzt ist es fast so wie ich es mir vorstelle :D :up:

    • Hier sind die beiden Domination/King of the Hill Modi:

      Die erste, ungetestete Version, bei der man den Knopf drücken muss um einen Punkt zu erzielen:

      Python-Quellcode: domination2.py

      1. import time
      2. from machine import Pin, I2C
      3. import ssd1306
      4. import machine
      6. i2c = machine.SoftI2C(scl=Pin(5),sda=Pin(4), freq=10000)
      7. oled = ssd1306.SSD1306_I2C(128, 64, i2c)
      9. b1=Pin(12, Pin.IN, pull=None)
      10. b2=Pin(18, Pin.IN, pull=None)
      12. lg=Pin(14, Pin.OUT)
      13. lr=Pin(25, Pin.OUT)
      16. def scoreboard():
      17. #oled.fill(0)
      18. oled.text("Score", 5, 10)
      19. oled.fill_rect(55, 10, 30, 10, 0)
      20. oled.text(str(v), 55, 10)
      21. oled.text("Red:", 5, 25)
      22. oled.fill_rect(60, 25, 30, 10, 0)
      23. oled.text(str(b), 60, 25)
      24. oled.text("Green:", 5, 40)
      25. oled.text(str(a), 60, 40)
      26. oled.show()
      28. def red_wins():
      29. oled.fill(0)
      30. oled.text("Team Red wins!", 0, 0)
      31. oled.text("Ka-POW!", 0, 15)
      32. oled.show()
      33. def green_wins():
      34. oled.fill(0)
      35. oled.text("Team Green wins!", 0, 0)
      36. oled.text("GG EZ", 0, 15)
      37. oled.show()
      38. def restart():
      39. oled.text("Restart?",0,30)
      40. oled.text("Red: Y, Green: N", 0, 45)
      41. oled.show()
      43. a=0
      44. b=0
      45. x=1
      46. lg.value(0)
      47. lr.value(0)
      49. v=10 #Anzahl nötiger Punkte
      50. cd=5 #Cooldown zwischen Punkten
      52. while True:
      53. while x==1:
      54. while a<v and b<v:
      55. scoreboard()
      56. lg.value(0)
      57. lr.value(0)
      58. if(b1.value()==1):
      59. a=a+1
      60. lg.value(1)
      61. lr.value(0)
      62. time.sleep(cd)
      63. elif(b2.value()==1):
      64. b=b+1
      65. lg.value(0)
      66. lr.value(1)
      67. time.sleep(cd)
      68. else:
      69. pass
      70. if a==v:
      71. green_wins()
      72. a=0
      73. b=0
      74. lg.value(0)
      75. lr.value(0)
      76. elif b==v:
      77. red_wins()
      78. a=0
      79. b=0
      80. lg.value(0)
      81. lr.value(0)
      83. x=0
      84. #restart()
      85. while x==0:
      86. restart()
      87. while b2.value()==1:
      88. x=1
      89. break
      90. while b1.value()==1:
      91. import main.py
      Alles anzeigen


      Und hier die klassische Variante. Einma drücken und die Zeit zählt hoch bis die Siegbedingungen erfüllt ist.

      Python-Quellcode: domination_time.py

      1. import time
      2. from machine import Pin, I2C
      3. import ssd1306
      4. import machine
      6. i2c = machine.SoftI2C(scl=Pin(5),sda=Pin(4), freq=10000)
      7. oled = ssd1306.SSD1306_I2C(128, 64, i2c)
      9. b1=Pin(12, Pin.IN, pull=None)
      10. b2=Pin(18, Pin.IN, pull=None)
      12. lg=Pin(14, Pin.OUT)
      13. lr=Pin(25, Pin.OUT)
      14. beep=Pin(13, Pin.OUT)
      16. x=1
      17. a=0
      18. b=0
      19. g=0
      20. r=0
      21. lg.value(0)
      22. lr.value(0)
      23. v=5 #Anzahl nötiger Punkte
      25. def scoreboard():
      26. #oled.fill(0)
      27. oled.text("Score", 5, 10)
      28. oled.text(str(v), 55, 10)
      29. oled.text("Red:", 5, 25)
      30. oled.fill_rect(55,25,30,10,0)
      31. oled.text(str(b), 55, 25)
      32. oled.text("Green:", 5, 40)
      33. oled.fill_rect(55,40,30,10,0)
      34. oled.text(str(a), 55, 40)
      35. oled.show()
      37. def red_wins():
      38. oled.fill(0)
      39. oled.text("Team Red wins!", 0, 0)
      40. oled.text("tss, git gud", 0, 15)
      41. #oled.text("not even tryin'", 5, 40)
      42. oled.show()
      43. def green_wins():
      44. oled.fill(0)
      45. oled.text("Team Green wins!", 0, 0)
      46. oled.text("EZ PZ", 0, 15)
      47. #oled.text("LMN SQZY", 5, 40)
      48. oled.show()
      50. def restart():
      51. oled.text("Restart?",0,30)
      52. oled.text("Red: Y, Green: N", 0, 45)
      53. oled.show()
      55. def count():
      56. if (g==1 and r==0):
      57. global a
      58. a=a+1
      59. time.sleep(1)
      60. if a %2 ==0:
      61. beep.value(1)
      62. else:
      63. beep.value(0)
      64. elif (g==0 and r==1):
      65. global b
      66. b=b+1
      67. time.sleep(1)
      68. if b %2 == 0:
      69. beep.value(1)
      70. else:
      71. beep.value(0)
      72. else:
      73. pass
      74. while True:
      75. while x==1:
      76. lr.value(0)
      77. lg.value(0)
      78. beep.value(0)
      79. while a<v and b<v:
      80. count()
      81. scoreboard()
      82. #time.sleep(cd)
      83. if(b1.value()==1):
      84. g=1
      85. r=0
      86. lg.value(1)
      87. lr.value(0)
      88. if(b2.value()==1):
      89. g=0
      90. r=1
      91. lg.value(0)
      92. lr.value(1)
      93. if a==v:
      94. green_wins()
      95. for i in range(21):
      96. i=i+1
      97. time.sleep(0.5)
      98. if i%2==0:
      99. beep.value(1)
      100. lg.value(0)
      101. else:
      102. beep.value(0)
      103. lg.value(1)
      104. a=0
      105. b=0
      106. g=0
      107. r=0
      108. #lg.value(1)
      109. #lr.value(0)
      110. elif b==v:
      111. red_wins()
      112. for i in range(21):
      113. i=i+1
      114. time.sleep(0.5)
      115. if i%2==0:
      116. beep.value(1)
      117. lr.value(0)
      118. else:
      119. beep.value(0)
      120. lr.value(1)
      121. a=0
      122. b=0
      123. g=0
      124. r=0
      125. #lg.value(0)
      126. #lr.value(1)
      128. x=0
      129. restart()
      130. while x==0:
      131. if b2.value()==1:
      132. x=1
      133. oled.fill(0)
      134. break
      135. elif b1.value()==1:
      136. import main.py
      137. else:
      138. pass
      Alles anzeigen
      Dieser Modus ist getestet worden.

      Ich bin noch blutiger Anfänger was das Programmieren angeht, daher sind die Lösungen bisher recht einfach und vermutlich optimierungsbedürftig. Aber es läuft erstmal. Über Konstruktive Kritik, Anmerkungen usw. freue ich mich immer!

      Grüße!

      PS: der Dreifachpost ist leider nötig, weil ich nicht alles in einen Post packen darf (Zeichenbeschränkung). Und es macht es evtl einfacher, wenn auf bestimmte Dinge geantwortet werden soll.