;Autor:   Puccini
;Date:   18.08.2007
;
;#######################################################   Type-Tut   ######################
;In diesem Tutorial will ich versuchen zu erklären wie man Types
;splitten kann, um eine hohe Belastung der CPU entgegenzuwirken und
;um das Programm etwas schneller zu machen.
;Nützlich wird dies erst bei größere Anzahl von Einträgen.

;Ich versuch das ganze etwas Systematisch aufzubauen:

;##############################      1.

;benötigte Variablen (wahlweise auch Global zu definiren)
anzahlgesamt_test=0         ;zur Ermittlung der Bestehenden Type-Einträge   
                     ;hier für das Type-Feld "test"   
schrittweite=10            ;Wieviele Types sollen Pro schleifendurchlauf bearbeitet werden
laufindex_unten=0         ;Aktueller Ausschnitt (untere Grenze)
laufindex_oben=schrittweite   ;Aktueller Ausschnitt (obere Grenze)

;##############################      2.

;Type Initialisieren
Type test
   Field zahl
End Type


;##############################      3.

;bevor wir den Type Splitten können, müssen wir wissen wieviel Einträge
;existiren.
;Dazu gibt es zwei Möglichkeiten:
;1. Gesamte Typeliste durchgehen und gesamtanzahl setzen
;   For t.test=Each test anzahlgesamt_test=anzahlgesamt_test+1 Next
;Die muss wenigstens einmal passieren.
;2. Wenn dem Type während der Laufzeit weitere Einträge hinzugefügt/entfernt werden
;kann man an die entsprechende Position anzahlgesamt=anzahlgesamt-1 (oder +1) setzten
;zB:   Delete t:anzahlgesamt=anzahlgesamt-1

;zu Testzwecken
For i=0 To 100            ;Erzeugen neuer Types, gleich mit dem index versehen
   t.test=New test         ;um zu sehen obs auch klappt
      t\zahl=i
      anzahlgesamt_test=anzahlgesamt_test+1   ;Variante 2
Next
   
;##############################      4.

;Die Hauptschleife
;Hier wird nun an der entsprechenden Position das Type-Feld gesplittet.
;Dies erfolgt über den Laufindex+die Schrittweite
Repeat

   ;Die Schleife um den Type zu "Splitten"
   ;laufindex_oben-1  <-- "-1" muss gemacht werden, da sonst
   ;immer ein Element zuviel mit durchlaufen wird (weil wir ja bei
   ;laufindex_unten anfangen)
   For k=laufindex_unten To laufindex_oben-1
      If k=0                
         t.test=First test   ;Rücksetzen des Types auf den Index 0
                        ;um alle Type-Einträge bearbeiten zu können
      Else
         t=After t         ;jeweils der nächste Eintrag wird hergenommen
      End If
      ;überlauf des Types und rücksetzten der Indexe um von vorn beginnen zu können
      If k=anzahlgesamt_test-1 laufindex_oben=0
      
      ;zu Testzwecken die Ausgabe der einzelindexe
      Print "Typeindex: "+t\zahl+" Grenze unten: "+laufindex_unten+" Grenze oben: "+laufindex_oben
   Next
   
   Print "###################"
WaitKey()

;##############################      5.

;Aktualliesren der Indexe + test auf Bereichsüberschreitungen
   laufindex_unten=laufindex_oben
   laufindex_oben=laufindex_oben+schrittweite
;hier wird getestet ob der laufindex die Anzahl der Typeeinträge überschreiten würde
;gegebenen falls wird die Obergrenze dann herunter gesetzt
If laufindex_oben>anzahlgesamt_test laufindex_oben=anzahlgesamt_test

Forever
End

;Bei weiteren Fragen bin ich gern bereit zu Helfen.
;Wer noch tips hat zur Verbesserung, die nehm ich gern entgegen, schliesslich
;soll das ja ein Hilfe-Tutorial sein.
;
;Wenn dir dieses Tutorial geholfen hat würde ich mich über eine kleine PM freuen
;
;
;MfG Puccini