Infinity-Profan

// Richtungen per Gesten
p=0                          // Index Position Trennzeichen in xg, yg
tg = -1                      // Nr. Teilgeste
xg=""  yg=""  xge=[]  yge=[] // Teil-Geste:  Strings, Gestenfelder
xp=[0]  yp=[0]               // Positionen p Trennz ; in Strings xg, yg
ix=0  iy=0  dx=0  dy=0       // Koordinaten, Differenzen
var rtg =[                   //  z
["\u21d8" "\u21d7" "\u21d2"] //  0  nach rechts
["\u21d9" "\u21d6" "\u21d0"] //  1  nach links
["\u21d3" "\u21d1" "\u2299"] //  2  vertikal, Stillstand
]                            // Matrix der Richtungssymbole
//s 0        1         2
// runter   hoch   horizontal
print "Richtung von Gesten"

proc event id data
    global p tg xg xge yg yge xp yp
    case id==event.touchdown : gekoord data.x data.y // Koord. aufnehmen
    case id==event.touchmove : gekoord data.x data.y // Koord. aufnehmen
    if   id==event.touchend
        tg++            // Nr. der Teilgeste erhöhen
        xge[tg] = xg    // Teilgeste in x Gestenfeld
        yge[tg] = yg    // Teilgeste in y Gestenfeld
        // Teilgeste auswerten:
        // Regionen und Anstieg/Krümmung ermitteln / "Wende"punkte - teils offen
        kruemmung       // ... ist noch UNVOLLSTÄNDIG
        //   Abschluss-Teilgeste komplexer Gesten erkennen - ist noch offen
        case  tg==7 : tg=0    // 7 Teilgesten
        // je Teilgeste neu initialisieren
        xg=""    // x Koordinaten-String (; separiert)
        yg=""    // x Koordinaten-String (; separiert)
        p=0      // Index Position Trennzeichen (;)
        xp=[0]   // Datenfeld mit Positionen der Trennzeichen in xg
        yp=[0]   // Datenfeld mit Positionen der Trennzeichen in xg
    endif
endproc

proc gekoord x y    // Geste:  x y Koordinaten aufnehmen
    global p ix xp iy yp xg yg
    case y<0 : y=0  // wegen Infoleiste (.y negativ)
    p++             // Index Position Trennzeichen ;
    ix = round(x 0 true) + ";"    // integer x mit Semikolon
    xp[p]=xp[p-1] + str.len ix    // x Trennzeichenposition ablegen
    iy = round(y 0 true) + ";"    // integer y mit Semikolon
    yp[p]=yp[p-1] + str.len iy    // y Trennzeichenposition ablegen
    xg=xg+ix                      // ix an String anfügen
    yg=yg+iy                      // iy an String anfügen
endproc

proc kruemmung
    global tg xp yp xg yg dx dy rtg
    i=0  
    verlauf = ""
    case  tg==7 : cls
    print "x " + (str.len(xp)-1) +": " + xg
    print "y " + (str.len(yp)-1) +": " + yg
    while i < (len(xp)-2)
        // long per Vergleiche wichtig: unterschiedliche Stellenzahl!
        x1 = long str.mid xg  xp[i]+1    xp[i+1]-xp[i]-1  // Koordinaten auslesen
        x2 = long str.mid xg  xp[i+1]+1  xp[i+2]-xp[i+1]-1
        y1 = long str.mid yg  yp[i]+1    yp[i+1]-yp[i]-1
        y2 = long str.mid yg  yp[i+1]+1  yp[i+2]-yp[i+1]-1
        dx = x2-x1           // per Krümmungsverhalten VORBEREITET
        dy = y2-y1
        z=2   // x1==x2  Zeile  rtg Richtungssymbole
        s=2   // y1==y2  Spalte rtg Richtungssymbole
        case x1!=x2 : z = 0+(x1>x2)     // Zeilenwahl  z
        case y1!=y2 : s = 0+(y1>y2)     // Spaltenwahl s
        verlauf = verlauf  +  rtg[z][s] // Richtungssymbol anhängen
        // print " dx "+ dx  + "  dy "+ dy + "   " +  verlauf
        i++
    wend
    print verlauf
endproc