Drucken
Hauptkategorie: Entwicklung
Kategorie: yab
Zugriffe: 3116

Was ist ein Objekt?

Für eine offizielle Definition siehe hier: http://searchsoa.techtarget.com/definition/object

Ein Objekt ist einfach definiert, eine Sub- Routine oder eine Gruppe einer Sub- Routine, welche vom Hauptprogramm aufgerufen werden kann.

Wenn man als yab Programmierer an yab als Basic Interpreter denkt, kommt man nicht unbedingt auf die Idee das man in dieser einfachen Programmiersprache Objekte nutzen würde, aber genau das macht man.

Alle GUI (General User Interface) Elemente in yab sind Objekte.

WINDOW OPEN x1,y1 TO x2,y2, ID$, Title$


Hiermit erstellt man ein Fenster- Objekt. Man gibt diesen seine Position auf dem Desktop und benennt einen sichtbaren und einen programminternen Namen fest.

WINDOW SET WindowID$, "MoveTo", x,y


Hiermit wird ein Fenster mit dem Namen WindowID$ (Dies ist eine Variable, die den Namen enthält) von einer Position auf dem Desktop an eine andere bewegt.

Ok, damit haben wir gezeigt, dass yab Programmierer Objekte benutzt. Diese sind jedoch Teil des # Interpreters.

Nun lasst uns ein Objekt in yab erstellen und verwenden.

Unser Objekt wir sein eine di (Eigenname) für ein Spiel in denen man einen Würfel rollen muss.

Da Objekte oft mehrfach verwendbar sein sollten (dies ist eine der Grundideen hinter Objekten), verwenden wir eine Library- Datei für unser Objekt.

Zuerst werden wir erklären, was eine di ist und was man damit machen kann.

Eine di:

Eine di ist in der Regel eine Darstellung eines physikalischen Objekts mit sechs bemalten Seiten.

Die Anzahl der Seiten kann variieren, je nach Bedarf des Spiels. Dabei sind Vier Seiten das Minimum.

Jede Seite sollte mit einem Zeichen, Nummer, Wort, Farbe, Bild oder Punkten oder anderes bemalt sein.

Eine di kann:

Zeige eines der Seiten.

Geschüttelt oder gerollt, per Zufallsgenerator jeweils anderes bemalt.

Jetzt der Quellkode:

Erstelle eine neue Datei mit dem Namen di.yab im yab Library Verzeichnis:

Dies ist entweder... 

/boot/home/config/settings/yab

...oder...

/boot/home/cinfig/lib/yab

 

//______________________________________________ 
//Kopiere folgende Zeilen in die Datei di.yan 
 //______________________________________________ 

 doc Ein Objekt programmiert in yab 
 doc zur Demonstration der Idee des Programmierens eines 
 doc Objekt in yab. 
 doc 
 doc by Jim Saxton, April 10, 2014, MIT license 

 // Wir benötigen eine Sub- Routine um ein neue di Objekt zu erstellen 
 // num, field() und field$() müssen dem aufrufenden Programm nicht bekannt ist. 

 export sub di_new$(sides, id$,x,y, view$) 

     static num 
     if num = 0 then 
         bitmap 680,680, "Di" 
         err = draw image 0,0 to 675,450, "/boot/home/Dice.png", "Di" 
     end if 

     num=num+1 

     dim field$(num,2) // id$, view$ 
     dim field (num, 3) // sides,x,y 

     // bestimmt die standard Anzahl an Seiten     if sides < 4 sides = 6 
         field$ (num,1)=id$ 
         field$ (num,2)=view$ 
         field (num,1)=sides 
         field (num,1)=sides 
         field (num,2)=x 
         field (num,3)=y 
         VIEW x,y TO x+225,y+225, id$, view$ 
         for n=1 to field(num,1) 
             switch n 
                 case 1 
                     x=0:y=0 
                     break 
                 case 2 
                     x=225:y=0 
                     break 
                 case 3 
                     x=450:y=0 
                     break 
                 case 4 
                     x=0:y=225 
                     break 
                 case 5 
                     x=225:y=225 
                     break 
                 case 6 
                     x=450: y=225 
                     break 

     // Dies kann modifiziert werden, um mehr als 6 Seiten zu ermöglichen. 
     // Wenn dem so ist, muss die Di Bitmap dementsprechend angepasst werden. 
     // 
     // Die Bitmap muss größer sein als das Bild welches darauf gemalt werden soll. 
     // Beachtet man das nicht kommt eine Fehlermeldung ("out of bounds"). 

             end switch 

             bitmap get x,y to x+225, y+225,str$(n),"Di" 
     next 

     // Der Zufallsgenerator 
     x1 = ran(num+1) 

     // Rollt den di und wählt eine Seite 
     field (num,0) = int(ran(sides))+1 

     //Die Information, dass eine neue di erstellt wurde wird zurückgegeben (return "ok") 
    return "ok" 
 end sub 

 //________________________________________________ 

 export sub di_get_face(id$) 
     s=arraysize(field$(),1) 
     for x=1 to s 
         if (field$(x,1)=id$) num = x 
     next 
     return field(num,0) 
 end sub 

 //________________________________________________ 

 export sub di_show_face(id$) 
     n = di_get_face(id$) 
     DRAW BITMAP 0,0, str$(n), "copy", id$ 
 end sub 

 //________________________________________________ 

 export sub di_roll(id$) 
     s=arraysize(field$(),1) 
     for x=1 to s 
         if (field$(x,1)=id$) num = x 
     next 
     field (num,0) = int(ran(field(num,1)))+1 
     di_show_face(id$) 
     return 
end sub 

//________________________________________________ 


Dieses Objekt wurde generiert für einen Sechsseitigen Würfel (di), kann aber auf einfachen Wege erweitert werden. Zum Beispiel für einen größeren Würfen, wie man diesen für Rollenspiele wie D&D benötigt.

Das Objekt verwendet einen festen Dateipfad für das Würfelbild (/boot/home/Dice.png). Man kann dies auch in eine variable Position ändern.

Ich nutze das Bild http://upload.wikimedia.org/wikipedia/commons/4/4c/Dice.png. Dieses habe ich auf eine Größe von 675 x 450 Pixel geändert.

Jede di Seite hat eine Größe von 225 x 225 Pixel

Das Objekt Testen:

Erstelle eine Datei Roll-Dice.yab und kopiere folgende Zeile hinein.

#!yab 

 import di 

 doc Zum testen des Programms 
 doc Zum Testen des di.yab Objekts. 
 doc Es verwendet keine des exportierten Sub- Routinen (di_get_face), 
 doc aber di_show_face macht es. 
 doc 
 doc Jim Saxton, April 10, 2014, MIT license 

 // set DEBUG = 1 um alle Benachrichtigungen auf der Konsole aus zu geben. 
DEBUG = 0 
 sleep .01 

 OpenWindow() 

 di_show_face("first") 
 di_show_face("second") 

 // Main Message Loop (Benachrichtigungs- Loop) 
 dim msg$(1) 
     while(not leavingLoop) 
         nCommands = token(message$, msg$(), "|") 

         for everyCommand = 1 to nCommands 
             if(DEBUG and msg$(everyCommand)<>"") print msg$(everyCommand) 

             switch(msg$(everyCommand)) 
                 case "roll": 
                     di_roll("first") 
                     di_roll("second") 
                     break 
                 case "_QuitRequested": 
                 case "MainWindow:_QuitRequested": 
                     leavingLoop = true 
                     break 
                 default: 
                     break 
             end switch 

     next everyCommand 
 wend 

 CloseWindow() 

 end 

 // Das Hauptfenster wird erstellt 
 sub OpenWindow() 
     window open 100,100 to 570,365, "MainWindow", "Main Window" 
         di_new$(6,"first",10,10,"MainWindow") 
         di_new$(6,"second",235,10,"MainWindow") 
         BUTTON 10,238 TO 460,263, "roll", "R O L L", "MainWindow" 
        return 
 end sub 

 // Schließt das Hauptfenster 
 sub CloseWindow() 
     window close "MainWindow" 
     return 
 end sub 


Hier kannst Du den kompletten Quellkode herunterladen: Archiv 

Tutorial von Jim Saxton, 10 April 2014 - MIT Lizens
Übersetzung durch Christian Albrecht (lelldorin), 10.05.2014
Bereitgestellt durch die BeSly, der Haiku, BeOS und Zeta Wissensbasis