Weitere Teile:
DirectQB Teil 1 - Installation
DirectQB Teil 2 - Primitive Drawroutinen
DirectQB Teil 3 - Mouse und Sound
DirectQB Teil 4 - Sprites
DirectQB Teil 5 - Keyboard

DirectQB Teil 4 - Sprites
 
 

In diesem Tutorial geht es nun um Sprites in DirectQB.
Aus QBasic selbst, kennt man nur die Befehle GET und PUT. Leider besitzen diese einige Nachteile. Sie sind starr, nicht transparent und dürfen nicht den Bildschirmrand verlassen. Obwohl gerade diese Effekte beim programmieren benötigt werden.
Bei DirectQB ist das anderes.
Die Palette der Grafikfunktionen ist sehr groß. Sprites können transparent dargestellt werden. Sie können den Bildschirm verlassen. Man kann Sprites drehen und in ihrer Größe ändern und sie können im RAM abgelegt werden.

Um Sprites ein zu scannen, kann man den Befehl DQBget benutzten. Er arbeitet genauso wie Get von QBasic nur dass der Syntax etwas anders ist.

DQBget Layer, X1, Y1, X2, Y2, SpriteSeg, SpriteOff

Mit Layer ist natürlich die Nummer des Layers gemeint, von dem das Bild eingescannt werden soll.
X1, Y1, X2 und Y2 sind die Koordinaten des Feldes. Aber was ist SpriteSeg und SpriteOff.
Diese beiden Werte geben die Speicherbereich des Arrays an. Keine Angst den muß und kann man gar nicht wissen. Den weiß nur QBasic selbst.
Mit VARSEG() und VARPTR() kann man diese Werte ermitteln.

Um nun das Bild auch wieder auf den Bildschirm zu bringen gibt es den Befehl DQBput.
Das ist der Syntax

DQBput Layer, X, Y, SpriteSeg, SpriteOff

X und Y sind die Koordinaten an denen das Sprite gemalt werden soll.
SpriteSeg und SpriteOff werden wieder mit VARSEG() und VARPTR() ermittelt.

Hier ist einfach mal ein kleines Beispiel:

'$INCLUDE: 'DIRECTQB.BI'

' Setzte Array mit der Länge 1000
DIM bild%(1000)

' Initialisiere DQB mit 2 Layern
IF DQBinit(2, 0, 0) THEN DQBclose: PRINT DQBerror$: END
' starte VGA Grafik Modus
DQBinitVGA

' male einfaches Muster
FOR Y%=0 TO 20
 FOR  X%=0 TO 20
  DQBpset(1, X%, Y%, (X%*Y%))
 NEXT X%
NEXT Y%

' Scanne Sprite ein und lege es auf dem Array „BILD%“ ab
DQBget 1, 0, 0, 20, 20, VARSEG(bild%(0)), VARPTR(bild%(0))

' Starte Schleife
DO

 ' Male Sprite an zufällige Position
 DQBput 0, RND * 100, RND * 100, VARSEG(bild%(0)), VARPTR(bild%(0))

' Verlasse Schleife wenn Taste gedrückt wird
LOOP UNTIL INKEY$ <> ““

' deaktiviere DQB
DQBclose
END

Nun gibt es ja noch viele andere Möglichkeiten, mit den man in DirectQB ein Sprite darstellen kann.
Zum Beispiel kann man es drehen. Das geht mit DQBrPut.
Syntax:

DQBrPut Layer, X, Y, SpriteSeg, SpriteOff, Winkel, Zoom

Layer ist wieder der Layer auf den das Bild gemalt werden soll.
X und Y sind die Koordinaten.
SpriteSeg und SpriteOff sind der Speicherbereich.
Winkel ist ein Wert zwischen 0 und 255. Bei 0 wird das Bild um 0° gedreht. Bei z.b. 128 wird das Bild um 180° gedreht. Bei 256 wird das Bild um 360° gedreht.
Zoom ist der Vergrößerungswert. Er wird in Prozent angegeben. 100 ist die Originalgröße. 200 ist die doppelte Größe und bei 50 wird das Bild halbiert.

Es gibt aber auch einen Befehl, mit dem man das Sprite mit veränderten Seitenlängen darstellen kann.
Es ist der Befehl DQBsPut
Der Syntax:DQBsPut Layer, X, Y, SpriteSeg, SpriteOff, Neue Breite, Neue Höhe

Layer, X, Y, SpriteSeg und SpriteOff sind wieder das selbe wie oben.
Mit „neuer Breite“ gibt man die Breite an mit der das Sprite dargestellt werden soll.
Mit „neue Höhe“ gibt man die Höhe an mit der das Sprite dargestellt werden soll.

Es gibt noch einen Put Befehl der dem von QBasic am ähnlichsten ist. Er ist zwar der schnellste, ist aber weder transparent  noch kann er den Bildschirmrand verlassen. Es ist DQBfPut
Syntax:

DQBfPut Layer, X, Y, SpriteSeg, SpriteOff

Alle Werte sind wieder die selben wie oben.

Alle diese Möglichkeiten sind zwar toll, haben  aber den Nachteil, dass sie sehr viel Speicher benötigen, von welchem, in QBasic, ja sowieso schon immer Mangel herrscht.
Wenn man also sehr viel Bilder hat, sollte man am besten DQBxPut benutzten.  Dieser Befehl scannt den Inhalt eines Layer ‘s ein und legt in auf einem anderen wieder ab ohne Speicher zu Benutzten.
Syntax:

DQBxPut  QuellLayer, X1, Y1, X2, Y2, ZielLayer, x, y

QuellLayer ist der Layer von dem das Bild eingescannt werden soll.
X1, Y1, X2 und Y2 sind die Eckkoordinaten des Sprits welches eingescannt werden soll.
ZielLayer ist der Layer auf den das Sprite gemalt werden soll und
x und y sind die Zielkoordinaten.
In der Breite gibt es keine Beschränkungen aber in der Höhe. Das Sprite darf höchstens 50 Pixel hoch sein.
Leider ist es ein bißchen langsamer als DQBput. Aber Transparens und und Clipping ist möglich.

Hier ist ein Beispiel:

'$INCLUDE: 'DIRECTQB.BI'

' Initialisiere DQB mit 2 Layern
IF DQBinit(2, 0, 0) THEN DQBclose: PRINT DQBerror$: END

' erstelle Bilder auf Layer 2
FOR i% = 0 TO 14

DQBbox 2, (i% * 16), 0, (i% * 16) + 15, 15, 4
DQBline 2, (i% * 16) + (15-i%), 15, (i% * 16) + i%, 0, 40
DQBline 2, (i% * 16) + 15, i%, (i% * 16), (15 – i%), 40

NEXT i%

' starte VGA Grafik Modus
DQBinitVGA

FOR i% = -16 TO 320

' lösche layer 1
DQBclearLayer 1

' Suche Frame aus
Frame% = ((i% + 16) \ 2) MOD 15

' Male Frame auf Layer 1
    DQBxPut 2, (Frame% * 16), 0, (Frame% * 16) + 15, 15, 1, i%, 92

' warte auf Bildschirm
    DQBwait 1

' Kopiere Layer 1 auf Bildschirm
DQBcopyLayer 1, VIDEO

NEXT i%
 

DQBclose
END