ATB -> CTB

[Caledoriv]

Das Problem ist halt, dass die Aktionsdauer angewendet wird, aber für den nächsten Rechendurchgang schon wieder aufgehoben ist.

...

Ganz doofe Frage von meiner Seite: Warum wird da überhaupt etwas aufgehoben?

Das sollte eigentlich auch so funktionieren. Genau das ist ja das Elegante an der Idee, einfach die Dauer als zusätzlichen Malus draufzurechnen .
Beim Erreichen des Ready-Limits wird neben dem Ready-Limit zusätzlich noch die Dauer der Aktion abgezogen. Mehr muss dann eigentlich nicht gemacht werden, weil die Berechnung der Züge wie gehabt weitergehen kann... Die Verzögerung entsteht dann durch diesen Malus, d.h. es dauert länger, bis der Ready-Wert erreicht ist, weil zuerst dieser Malus "abgearbeitet"

Oder übersehe ich da etwas?

[IndependentArt]

Ich bin zwar glaub ich einen Schritt weiter, aber es spackt immer noch rum. Wenigstens mit einem bestimmten Wert für die Aktionsdauer hat es funktioniert.
Noch ein Video mit einer Aktionsdauer von 200 (Rechnung siehe unten) für Zauber:

Man sieht, dass ein Zug des Gegners zwischendrin geschluckt wird.

Evtl übersiehst du bei dem Malus tatsächlich etwas. Ich versuche mal zu erklären warum:
Ich habe das momentan so geregelt, dass ich die Aktionsdauer auf 2 Variablen festlege (1848, 1849). 2 Variablen, weil ich eine davon für das Preview brauche.
Preview Codeblock:

Code:

 @> Conditional Branch: Switch [1733:CTB PREVIEW] is ON
      @> Conditional Branch: Variable [1849:R CTB Aktionsdauer%] > 0
        @> Control Variables: [1806:CTB Ready Abzug] = Variable [1805]
        @> Control Variables: [1806:CTB Ready Abzug] *= Variable [1849]
        @> Control Variables: [1806:CTB Ready Abzug] /= 100 
        @> Control Variables: [1855:R-CTB Order Preview] -= Variable [1806]
        @> Control Variables: [1849:R CTB Aktionsdauer%] = 0 
        @>
       : Branch End
      @> Comment: 
      @> Control Variables: [1855:R-CTB Order Preview] += Variable [1815]
      @> Conditional Branch: Variable [1855:R-CTB Order Preview] >= Variable [1805:CTB Ready]
        @> Control Variables: [1855:R-CTB Order Preview] -= Variable [1805]

Der erste Teil ist quasi die Malus-Rechnung. Wenn eine Aktionsdauer festgelegt wurde, diese also größer als 0 ist, wird die Rechnung durchgeführt. Für eine StandardAktion nehme ich aus gewissen Gründen eine Aktionsdauer von 0 an. Die Rechnung wird also nur ausgeführt, wenn die Dauer drüber liegt.
Der Malus wird errechnet und vom Preview-Wert abgezogen. Außerdem wird die Aktionsdauer 0 gesetzt, weil das ganze nur 1 Mal durchgeführt werden soll. Ich glaube, das funktioniert auch soweit ganz gut. Wenn ich zB einen Aktionswert von 100 festlege, bekommt der Gegner genau einen Zug mehr.
Ich bin nicht sicher, in wie weit das mit eurem Ansatz überein stimmt. Ich fand es wichtig, dass der Malus vor der sonstigen Rechnung abgezogen wird. Passiert das erst danach, könnte ja zwischendrin schon ein Zug berechnet und ein Slot gefüllt worden sein.

Code der eigentlichen Berechnung des Malus nach dem Zug:

Code:

@> Conditional Branch: Variable [1848:R CTB AD% SAVE] > 0
    @> Control Variables: [1806:CTB Ready Abzug] = Variable [1805]
    @> Control Variables: [1806:CTB Ready Abzug] *= Variable [1848]
    @> Control Variables: [1806:CTB Ready Abzug] /= 100 
    @> Control Variables: [1807:R-CTB Order] -= Variable [1806]
    @> Control Variables: [1848:R CTB AD% SAVE] -= 100

Der Block befindet sich direkt am Anfang des Gesamtcodes. Dadurch war es einfacher, ihn nur 1 mal durchlaufen zu lassen. Eigentlich ist fast alles gleich wie bei dem für das Preview. Der Hauptunterschied ist, dass V1848 nicht 0 gesetzt wird, sondern 100 abgezogen wird, weil die Variable ja mehrere Züge, jeweils unter Abzug eines Zuges (-100%) in Benutzung ist.

Die Formel "Ready-Wert = Ready-Wert - Ready-Limit - (Aktionsdauer / Tempowert)" verstehe ich aber offen gesagt auch nicht so recht. Kann es sein, dass da ein falsches Zeichen drin ist?

btw: Irgendwelche Tipps, wie man bei sowas besser den Überblick behält? Ich hab das Gefühl, das ist einfach zu viel für mein gehirn. xD

Gesamtcode:

Code:

@> Conditional Branch: Switch [1733:CTB PREVIEW] is ON
  @> Control Variables: [1855:R-CTB Order Preview] = Variable [1807]
  @> Control Variables: [1856:M/B-CTBOrder Preview] = Variable [1808]
  @> Control Variables: [1857:C/V-CTBOrder Preview] = Variable [1809]
  @> Control Variables: [1858:G1-CTB Order Preview] = Variable [1810]
  @> Control Variables: [1859:G2-CTB Order Preview] = Variable [1811]
  @> Control Variables: [1860:G3-CTB Order Preview] = Variable [1812]
  @> Comment: 
  @>
 : Else
  @> Conditional Branch: Variable [1848:R CTB AD% SAVE] > 0
    @> Control Variables: [1806:CTB Ready Abzug] = Variable [1805]
    @> Control Variables: [1806:CTB Ready Abzug] *= Variable [1848]
    @> Control Variables: [1806:CTB Ready Abzug] /= 100 
    @> Control Variables: [1807:R-CTB Order] -= Variable [1806]
    @> Control Variables: [1848:R CTB AD% SAVE] -= 100 
    @>
   : Branch End
  @>
 : Branch End
@> Control Variables: [1804:Teilnehmer Abfrage] = Variable [1803]
@> Control Variables: [1814:current CTB slot] = 1821 
@> Control Variables: [1841:CTB Kapsel ID] = 2000 
@> Control Variables: [1842:CTB Kapsel X] = 116 
@> Control Variables: [1843:CTB Kapsel Y] = 227 
@> Jump to Label: 10
@> Label: 1
@> Conditional Branch: Switch [1005:Ramirez tot] is OFF
  @> Conditional Branch: Switch [1001:Ramirez nicht im K] is OFF
    @> Conditional Branch: Switch [1733:CTB PREVIEW] is ON
      @> Conditional Branch: Variable [1849:R CTB Aktionsdauer%] > 0
        @> Control Variables: [1806:CTB Ready Abzug] = Variable [1805]
        @> Control Variables: [1806:CTB Ready Abzug] *= Variable [1849]
        @> Control Variables: [1806:CTB Ready Abzug] /= 100 
        @> Control Variables: [1855:R-CTB Order Preview] -= Variable [1806]
        @> Control Variables: [1849:R CTB Aktionsdauer%] = 0 
        @>
       : Branch End
      @> Comment: 
      @> Control Variables: [1855:R-CTB Order Preview] += Variable [1815]
      @> Conditional Branch: Variable [1855:R-CTB Order Preview] >= Variable [1805:CTB Ready]
        @> Control Variables: [1855:R-CTB Order Preview] -= Variable [1805]
        @>
       : Else
        @> Jump to Label: 10
        @>
       : Branch End
      @>
     : Else
      @> Comment: 
       :               : 
      @> Control Variables: [1807:R-CTB Order] += Variable [1815]
      @> Conditional Branch: Variable [1807:R-CTB Order] >= Variable [1805:CTB Ready]
        @> Control Variables: [1807:R-CTB Order] -= Variable [1805]
        @> Control Variables: Variable [1814] = 1 
        @>
       : Else
        @> Jump to Label: 10
        @>
       : Branch End
      @>
     : Branch End
ANZEIGE R

      @>
     : Branch End
    @> Control Variables: [1814:current CTB slot] += 1 
    @> Control Variables: [1841:CTB Kapsel ID] += 1 
    @> Control Variables: [1842:CTB Kapsel X] += 14 
    @>
   : Branch End
  @>
 : Branch End
@> Jump to Label: 10
@> Comment: 
 :               : 
@> Label: 2
@> Conditional Branch: Switch [1009:Gegner 1] is ON
  @> Conditional Branch: Switch [1733:CTB PREVIEW] is ON
    @> Control Variables: [1858:G1-CTB Order Preview] += Variable [1818]
    @> Conditional Branch: Variable [1858:G1-CTB Order Preview] >= Variable [1805:CTB Ready]
      @> Control Variables: [1858:G1-CTB Order Preview] -= Variable [1805]
      @>
     : Else
      @> Jump to Label: 10
      @>
     : Branch End
    @>
   : Else
    @> Control Variables: [1810:G1-CTB Order] += Variable [1818]
    @> Conditional Branch: Variable [1810:G1-CTB Order] >= Variable [1805:CTB Ready]
      @> Control Variables: [1810:G1-CTB Order] -= Variable [1805]
      @> Control Variables: Variable [1814] = 4 
      @>
     : Else
      @> Jump to Label: 10
      @>
     : Branch End
    @>
   : Branch End
ANZEIGE G1

    @>
   : Branch End
  @> Control Variables: [1814:current CTB slot] += 1 
  @> Control Variables: [1841:CTB Kapsel ID] += 1 
  @> Control Variables: [1842:CTB Kapsel X] += 14 
  @>
 : Branch End
@> Jump to Label: 10
@> Comment: 
 :               : 
: Branch End
@> Comment: 
 :               : 
@> Label: 10
@> Conditional Branch: Variable [1814:current CTB slot] < 1838
  @> Control Variables: [1804:Teilnehmer Abfrage] += 1 
  @> Conditional Branch: Switch [1733:CTB PREVIEW] is OFF
    @> Control Variables: [1803:Teiln.Abfrage SAVE] = Variable [1804]
    @>
   : Branch End
  @> Conditional Branch: Variable [1804:Teilnehmer Abfrage] == 1
    @> Jump to Label: 1
    @>
   : Else
    @> Conditional Branch: Variable [1804:Teilnehmer Abfrage] == 2
      @> Jump to Label: 2
      @>
     : Else
      @> Conditional Branch: Variable [1804:Teilnehmer Abfrage] == 3
        @> Jump to Label: 3
        @>
       : Else
        @> Conditional Branch: Variable [1804:Teilnehmer Abfrage] == 4
          @> Jump to Label: 4
          @>
         : Else
          @> Conditional Branch: Variable [1804:Teilnehmer Abfrage] == 5
            @> Jump to Label: 5
            @>
           : Else
            @> Conditional Branch: Variable [1804:Teilnehmer Abfrage] == 6
              @> Control Variables: [1804:Teilnehmer Abfrage] = 0 
              @> Jump to Label: 6
              @>
             : Branch End
            @>
           : Branch End
          @>
         : Branch End
        @>
       : Branch End
      @>
     : Branch End
    @>
   : Branch End
  @>
 : Branch End

@> Control Switches: [1733:CTB PREVIEW] = OFF

[Caledoriv]

Die Formel "Ready-Wert = Ready-Wert - Ready-Limit - (Aktionsdauer / Tempowert)" verstehe ich aber offen gesagt auch nicht so recht. Kann es sein, dass da ein falsches Zeichen drin ist?

btw: Irgendwelche Tipps, wie man bei sowas besser den Überblick behält? Ich hab das Gefühl, das ist einfach zu viel für mein gehirn. xD

...

Für den Code ist es mir jetzt zu spät...

Zur Formel:
Die Idee dazu ist folgende: Wende die Formel an, soabld der Ready-Wert überschritten ist. Hier mal zwei Beispiele (das erste ohne Tempowert, um es einfach zu halten):

Ready-Wert = Ready-Wert - Ready-Limit - Aktionsdauer
Ready-Limit = 300
Ready-Wert nach dem neuen Update: 320
Tempo des Helden: 40

Schritt 1: Ziehe Ready-Limit ab, damit ganz normal die Reihenfolge berechnet werden kann.
Neuer Ready-Wert: 320 - 300 = 20

Schritt 2: Aktion wählen. Die Aktion hat eine Dauer von 100. Ziehe diesen Wert ebenfalls vom Ready-Wert ab:
Neuer Ready-Wert: 20 - 100 = -80

Berechne jetzt ganz normal die Reihenfolge, indem in jeder Iteration der Tempowert auf den Ready-Wert draufgerechnet wird. Der Held braucht ca. 3 Runden, bis er diesen zusätzlichen Malus aufgeholt hat, sodass der Gegner früher wieder dran kommt.

...

Ready-Wert = Ready-Wert - Ready-Limit - (Aktionsdauer / Tempowert)
Das hier macht genau das Gleiche wie oben, allerdings ist die Aktionsdauer (und damit der Malus) jetzt nicht immer konstant, sondern hängt vom Tempowert des Helden ab. D.h. wenn der Held ein höheres Tempo hat, hat er auch einen niedrigeren Malus. (Allerdings muss hier die Aktionsdauer wesentlich höher sein als oben!)

Ready-Limit = 300
Ready-Wert nach dem neuen Update: 320
Tempo des Helden: 40

Schritt 1: Ziehe Ready-Limit ab, damit ganz normal die Reihenfolge berechnet werden kann.
Neuer Ready-Wert: 320 - 300 = 20

Schritt 2: Aktion wählen. Die Aktion hat eine Dauer von 4000, d.h. der Bruch (Aktionsdauer / Tempowert) hat einen Wert von 4000/40 = 100. Ziehe diesen Wert vom Ready-Wert ab.
Neuer Ready-Wert: 20 - 100 = -80

-----
Der Held levelt auf und hat jetzt Tempo 50 (statt 40). In Schritt 2 ändert sich damit die Rechnung:
Schritt 2: Aktion wählen. Die Aktion hat eine Dauer von 4000, d.h. der Bruch (Aktionsdauer / Tempowert) hat einen Wert von 4000/50 = 80. Ziehe diesen Wert vom Ready-Wert ab.
Neuer Ready-Wert: 20 - 80 = -60

...

Die Idee dahinter ist quasi, dass der Malus sich mit der Zeit verringert, d.h. der Held kann die Aktion über die Zeit schneller ausführen. Da müsste aber wohl noch etwas bei der Berechnung nachjustiert werden, weil der Effekt marginal ist...


Tipps:
Du kannst dir das ggf. mit einem Diagramm bzw. Automaten veranschaulichen:
https://de.wikipedia.org/wiki/Zustandsdiagramm_(UML)
https://de.wikipedia.org/wiki/Determ...licher_Automat
Der ganze mathematische Hintergrund kann ignoriert werden... Scroll einfach zu den Bildern und lies die Überschiften dazu . Diese Dinger sind zwar nicht genau das, was du möchtest, gehen aber in die richtige Richtung.

Genau geht es mit einem Aktivitäsdiagramm, weil du damit den Code quasi "grafisch" vor dir hast:
https://de.wikipedia.org/wiki/Aktivit%C3%A4tsdiagramm
Ich fand es aber am Anfang relativ schwer, mir sowas aufzumalen. Ggf. reichen ein paar einfache Kreise mit ein paar Pfeilen wie oben ja auch schon aus, um den Überblick nicht zu verlieren.

[IndependentArt]

Ready-Wert = Ready-Wert - Ready-Limit - Aktionsdauer
Ready-Limit = 300
Ready-Wert nach dem neuen Update: 320
Tempo des Helden: 40

Schritt 1: Ziehe Ready-Limit ab, damit ganz normal die Reihenfolge berechnet werden kann.
Neuer Ready-Wert: 320 - 300 = 20

Schritt 2: Aktion wählen. Die Aktion hat eine Dauer von 100. Ziehe diesen Wert ebenfalls vom Ready-Wert ab:
Neuer Ready-Wert: 20 - 100 = -80

Berechne jetzt ganz normal die Reihenfolge, indem in jeder Iteration der Tempowert auf den Ready-Wert draufgerechnet wird. Der Held braucht ca. 3 Runden, bis er diesen zusätzlichen Malus aufgeholt hat, sodass der Gegner früher wieder dran kommt.

...

Ich denke, das ist im großen und ganzen das, was ich versucht habe einzubauen. Wir müssen nur ein bisschen aufpassen, dass wir mit den Namen für die Werte nicht durcheinander kommen.
Deine Bezeichnungen dürften bei mir so heißen:
Ready-Limit = CTB Ready
Ready-Wert = R-CTB Order (Preview)
Ich bin nicht sicher, ob du das bedacht hast: Wenn erst im Schritt 2 die Aktionsdauer abgezogen wird, wurde ja vorher mit Erreichen des Ready-Limits schon ein Zug berechnet. Vielleicht hängt das aber auch von der Reihenfolge des ganzen Ablaufs ab.
Außerdem: Bei mir wird die Aktionsdauer prozentual auf das Ready-Limit bezogen. Bei Ready-Limit 300 und Aktionsdauer von 100 (%) wäre das also -300. Eine feste Aktionsdauer von 100 wäre ja bei sich veränderndem Ready-Limit etwas schwierig, aber das hast du vmtl. Auch nicht so vorgesehen.
Außerdem muss man da auch wieder unterscheiden zwischen Preview und eigentlicher Berechnung (wie ich es oben getan habe):
Preview:
Hier kann natürlich bequem einfach die komplette Aktionsdauer abgezogen werden. Ich setze wie oben beschrieben anach die Aktionsdauer 0, damit das nur 1 Mal geschieht. Damit also die nächsten Züge wieder mit normaler Dauer berechnet werden.

Eigentliche Berechnung:
Angenommen nach dem Zug des Charakters hat der Gegner 3 Züge, weil die Aktion so lang dauert. Für den ersten Zug ist die Rechnung im Prinzip genau so wie beim Preview: die volle Aktionsdauer wird abgezogen. Nach dem ersten Zug des Gegners wird alles wieder neu berechnet. Die Aktionsdauer muss also sozusagen um 1 Zug verringert werden, so wie oben beschrieben.

Ich hoffe, wir verstehen uns irgendwie. ^^
Danke auch für die Links, mal sehen, ob ich damit was anfanen kann.

[Ken der Kot]

Puh, langsam wird das schwierig zu durchschauen. Ich meld mich, sobald ich der Meinung bin, dass ich da noch halbwegs gut genug durchblicke, um dazu was sagen zu können. Aber wär's nicht Stand Jetzt deutlich einfacher, wenn du jemanden bittest, dir ein C-Programm zu schreiben, das sich so verhält wie du es gerne hättest? Ich meine, es ist sehr löblich, dass du das komplette KS über Events realisieren willst, aber bei einem so großen Projekt ist das vom Arbeitsaufwand doch unverhältnismäßig? Frag mal Brei -- der Kerl, der zur Zeit die Spielanalysen streamt. Der scheint von Dyn-Programmen sehr viel Ahnung zu haben. Vielleicht sind das mit C nur ein paar Zeilen Code, während das bei Events echt ausufernd wird. Nur mal so als kleinen Gedankenanstoß, falls du partout nicht weiterkommen solltest.

[IndependentArt]

Ich denke, ich hab jetzt ne relativ genaue Vorstellung, wo das Problem liegt. Ich versuche das mal in aller kürze darzulegen:
Das Preview fängt ja immer beim gleichen Wert an und rechnet dann alle Slots bis zum Schluss aus.

Angenommen, es werden nach dem Zug des Charakters 3 Züge für den Gegner berechnet, siehe hier:

Die fixe Berechnung (also nicht das Preview) findet nach den Zügen statt. Direkt nachdem der Charakter seinen Zug beendet hat, ist die Berechnung noch synchron mit dem Preview.
Der 2. Durchgang der fixen Berechnung findet nach dem Gegnerzug statt und es wird ein Zug des Charakters weiter vorn berechnet oder anders gesagt: ein Zug des Gegners fällt weg. Warum?

Ganz einfach: Beim 2. Durchgang sind die Ausgangswerte anders. Nachdem die Berechnung 1 Mal durchgeführt wurde (und alle Slots bis nach hinten gefüllt wurden), bleibt der aktuelle Wert ja irgendwo stehen. Und dieses irgendwo unterscheidet sich vom Startpunkt der Preview-Berechnung, so dass bei der nächsten fixen Berechnung etwas anderes rauskommen muss. edit: Außerdem könnte es auch problematisch sein, dass zwischendrin die Abfragepriorität der Teilnehmer irgendwie wechselt (ich fürchte, das hat sogar noch nen größeren Einfluss als die veränderte Startposition).

Eigentlich relativ logisch, ich bin nur noch nicht sicher, wie ich das löse.

@Ken

Das einzige, was hier zu beschränkt ist, ist die Rechenleistung meines Gehirns. ^^
Eigentlich ist der Code ja nicht besonders lang, nur etwas komplex/kompliziert.
Davon abgesehen benutze ich kein DynRPG mehr, sondern easyrpg (mit interierten DynPlugins). Sicher könnte man da auch irgendwas eigenes schreiben, aber ich sehe da nicht wirklich einen Grund dazu bzw. muss ich es ggf. Ja auch selbst noch modifizieren können.
Aber trotzdem danke, dass du noch versuchst mitzudenken.

[Cornix]

Ein paar Fragen zum Verständnis:

1. Wie genau sieht deine Formel im Moment aus? Bitte einmal die genaue Rechnung mit allen beteiligten Variablen, deren Bedeutung und Beispielwerten beschreiben.
2. Hast du einmal alles von Hand nachgerechnet? Bekommst du ein anderes Ergebnis wenn du von Hand rechnest?
3. Verstehe ich es richtig, dass du die Werte zweimal ausrechnest; einmal für die Zugberechnung und einmal nur für das UI? Wenn ja: warum?
4. Hast du schon versucht dir einmal alle Werte nacheinander als Textausgabe anzeigen zu lassen? Schreib doch einmal was du dabei ausgegeben bekommst in Reihenfolge.

[maniglo93]

Ok, ich bin nun, glaube ich, durch dein Code durchgestiegen und... Naja er ist halt individuell meine codes sind vermutlich genauso kompliziert, deswegen nimm mein Rat mit etwas Salz

Du solltest den Code mehr nach Funktion trennen um einen besseren Überblick zu bekommen. Aktuell ist, so wie es für mich aussieht, jede Funktion in einander vermischt, wodurch es schwer ist Fehler / Bugs unabhängig zu betrachten.

Letztendlich brauchst du 3 Funktionen (mal Graphische Implementation ausgeschlossen) :
-Sortierung
-Berechnung Reihenfolge
-Berechnung Individueller Aktionsdauer

Eine Preview Rechnung brauchst du nicht zwangsläufig (kommt drauf an wie genau du diese später haben möchtest, führe ich unten weiter aus). Denn letztendlich ist die Preview-Rechnung = Aktuelle Rechnung. Dies zu splitten, wie du es gemacht hast, führt zu zwei Funktionen und somit zwei potentielle Fehlerquellen. Als erstes würde ich dir empfehlen, schon bei der Auswahl der Aktion die normal Rechnung auszuführen und diese anzeigen zu lassen. Vielleicht behebt sich da schon dein Fehler. Dann würde ich ein Check machen, wann die Reihenfolge neu berechnet werden soll. Also wenn die Reihen folge ist R - G - G - G - R, dann ist ja schon klar, dass der G 3x an der Reihe ist, weshalb dann neu die Reihenfolge berechnen?

Wenn dein Ziel ist, dass die Gegner auch schnellere bzw langsamere Aktionen durchführen kann, dann wirst es kompliziert für dich und du solltest jetzt schon dein System darum planen, denn aus dem Standpunkt des Designs bringt mir die Info, dass der Gegner 3x dran ist nur dann was, wenn er wirklich 3x dran ist und nicht nur 2x weil er bei der 2ten Aktion ein sehr langen Zauber macht. Dann muss das Preview schon die Auswirkung von Tempo Veränderung der zukünftigen Zauber einbrechnen und das wird mit den Events knifflig. Besonders wenn es Buffs gibt, die das Tempo erhöhen. Und lass uns gar nicht über Chancen reden (50% Chance den Gegner zu verlangsamen). Ein Preview ist nur dann sinnvoll, wenn es so genau wie möglich ist.

Deswegen mein Rat: Glieder deinen Code mehr um vielleicht überflüssige Funktionen herausziehen und Probleme genauer zu identifiziert.

Ich hoffe ich konnte dir helfen

Cheers
Maniglo

[IndependentArt]

Danke für die Antworten. Ich muss mir das nochmal in Ruhe durch den Kopf gehen lassen und melde mich dann die Tage wieder.

@Cornix: Nur zur Sicherheit: Ist meine letzte Mail angekommen? ^^ Ist jetzt erstmal kurz aufgeschoben, aber es erscheint mir am sinnvollsten, wenn man das mal per Bildschirmübertragung durchgeht, im Gegensatz dazu, dass man es immer versucht zu verschriftlichen.