Types Verwendung für Anfänger

Übersicht BlitzBasic FAQ und Tutorials

Neue Antwort erstellen

Midimaster

Betreff: Types Verwendung für Anfänger

 BeitragDo, Dez 31, 2009 11:45
Antworten mit Zitat
Benutzer-Profile anzeigen
Types Verwendung für Anfänger

Dies ist ein Tutorial für blutige Anfänger. Es erklärt was Types sind und wo und wie man sie in eigenen Programmen verwenden könnte.

(Ich bitte alle, sich mit eigenen Einträgen rauszuhalten und dafür lieber den Thread "Kritik an Midimaster-Tutorials" zu nutzen. Dieses Tutorial soll den Anfänger möglichst durch keine Diskussionen irritieren.) Kritik hier hin: Kritik-Thread

Allen Anfängern lege ich wärmstens ans Herz dieses Tutorial durchzuarbeiten. Es spart euch viele Fehler in späteren Programmen. Fragen von Hilfesuchenden bitte ins BB-Beginners-Corner (https://www.blitzforum.de/forum/viewforum.php?f=18), aber auf keinen Fall hier hin posten!

Das Tutorial ist didaktisch konzipiert aufgebaut. Die Lektionen bauen aufeinander auf. Die Befehle werden nie vollständig erklärt, sondern immer nur soweit man es für diese Lektion unbedingt braucht.


Lektion I: Types erstellen Arrow zur Lektion I

Lektion II: Variablen aus TYPEs Arrow zur Lektion II

Lektion III: Mit TYPEs Heerscharen von Gegnern erzeugen Arrow zur Lektion III

Lektion IV: Auch TYPES sterben! Arrow zur Lektion IV

Lektion V: Types und Funktionen Arrow zur Lektion V

Lektion VI: Types in Arrays, Array in Types Arrow zur Lektion VI
  • Zuletzt bearbeitet von Midimaster am Sa, Feb 20, 2010 23:31, insgesamt 6-mal bearbeitet

Midimaster

Betreff: Lektion I: Types erstellen

 BeitragDo, Dez 31, 2009 14:14
Antworten mit Zitat
Benutzer-Profile anzeigen
Lektion I: Types erstellen

Du hast schon Variable verwendet, z.B. A%=15 oder B$="Tarzan". Hier ist erste Variable vom Typ Zahl und die zweite vom Typ Zeichenkette. Genau genommen ist die erste Variable vom Typ INTEGER (für Ganzzahlen), die zweite von Typ STRING. Außerdem kennst Du vielleicht noch den Typ FLOAT für Fließkommazahlen.

Mit diesen drei Variablen-Typen kannst du schon viel programmieren. Doch manchmal wünscht man sich, man hätte eine Variable vom Typ "gemischt", die sich eine Zahl und eine Zeichenkette merken kann. Etwa wenn Du Deinem Spieler zwei Eigenschaften mitgeben möchtest: Name und Leben.

Dies geht natürlich durch zwei unabhängige Variable:

BlitzBasic: [AUSKLAPPEN] 
SpielerName$="Tarzan"
SpielerLeben%=100

Aber man kann es auch durch Erschaffen eines neues Variablen-Typs:

BlitzBasic: [AUSKLAPPEN] 
Type SpielerTyp
   Field Name$
   Field Leben%
End Type


Dies nennt man dann einen TYPE. Das Wort TYPE ist also nicht in dem Sinn zu verstehen "Da drüben stehen zwei Typen rum...". Es meint viel mehr eine neu Art Variable.

Definiere neue TYPEs immer am Anfang deines Codes. Die Schreibweise ist immer gleiche und Du brauchst hierfür 3 Befehle:

TYPE
...beginnt den Definitionsblock, dahinter steht der Typname, den Du frei wählen kannnst. Gewöhne dir an, immer die Buchstaben TYP in den Namen einzubringen. so heißt ein Typ für Spieler SpielerTyp oder TypSpieler oder PlayerTyp oder TPlayer. Die offizielle BlitzBasic-Schreibweise ist übrigens das vorangestellte "T" (für "Typ"): TPlayer, TAlien, TStream

FIELD
...legt nun die Eigenschaften deines neuen Typs fest. Du kanst so viele Fields erstellen, wie Du Lust hast. Die Namen sollen eine der "Eigenschaften". Deines Typs beschreiben. Denkbar wäre hier X% oder Leben% oder DateiName$. Vergiß aber nie, diesen Eigenschaften wieder einen Typ zuzuordnen: X als INTEGER X%, DateiName als Zeichenkette DateiName$

END TYPE
...markiert das Ende der Type-Beschreibung.

TYPES "definieren" nur ?!?

TYPES selbst sind noch keine Variablen, ebenso wie das "%" (aus "A%") oder das "$" (aus "B$") auch noch keine Variablen sind, sondern nur den Typ der Variablen festlegen. Über Typ-Variablen mehr in Lektion II.


Hier nun einige Beispiele aus typischen Spielen:

BlitzBasic: [AUSKLAPPEN] 
Type PlayerTyp
   Field X#, Y#, Speed#
   Field Waffen$
   Field Leben%
End Type

Type GegnerTyp
   Field X#, Y#
   Field WaffenTyp%
   Field Leben%, KampfPower%
End Type


Wie du siehst, kann man auch mehrere Eigenschaften auf eine Zeile schreiben. Das macht keinen Unterschied.

Du kannst auch so viele Typen erstellen, wie Du willst, oder versuchen alle Spielfiguren mit einem einzigen Typ zu beschreiben. Dann hast Du FIELDs, die manche Spielfiguren nie verwenden. Das macht aber auch nix. Arbeite aber zunächst so, dass du für jeden Teilnehmergruppe deines Spiels einen TYPE erstellst. Das erleichtert Dir die Vorstellung von dem was geschieht.
  • Zuletzt bearbeitet von Midimaster am Do, Dez 31, 2009 17:21, insgesamt 2-mal bearbeitet

Midimaster

Betreff: Lektion II: Variablen aus Typen

 BeitragDo, Dez 31, 2009 15:18
Antworten mit Zitat
Benutzer-Profile anzeigen
Lektion II: Variablen aus TYPEs

In der vorherigen Lektion haben wir gelernt, wie man einen neuen TYPE beschreibt. Hier nun definieren wir eine Variable dieses TYPEs. Als Vergleich lasse ich immer noch eine altbekannte Variable A in den Beispielen mitlaufen:

BlitzBasic: [AUSKLAPPEN] 
Type SpielerTyp
   Field Name$
   Field X%, Y%, Leben%
End Type

Global Spieler.SpielerTyp
Local Gabi.SpielerTyp
Global A%


Das wars schon. Hier haben wir zwei Spieler "Spieler" und "Gabi" und beide sind ab jetzt für SpielerTyp-Variable geeignet. Zum Vergleich siehst Du darunter eine Variable A%, die für INTEGER vorbereitet wäre.
Entscheide Dich immer, ob Du die Variable GLOBAL oder LOCAL brauchen wirst. Vergißt du dies, wird die Variable LOKAL erstellt.


Einen Wert wie Du es kennst von "A%=6" hat Gabi.SpielerTyp noch nicht. Das machen wir so:

BlitzBasic: [AUSKLAPPEN] 
Gabi= New SpielerTyp
A=6


auch diese Schreibweise ist möglich, aber unnötig (weil Gabi ja schon in der GLOBAL-Zeile definiert wurde):

BlitzBasic: [AUSKLAPPEN] 
Gabi.SpielerTyp= New SpielerTyp
A%=6


In einer Liste aller Variablen vom Typ SpielerTyp wurde nun eine neue hinzugefügt. Du kannst sie über "Gabi" ansprechen und verwenden


Eigenschaften ansprechen

So, nun wird es endlich spannend. Wir haben also einen Spieler vom Typ SpielerTyp und der hat die Eigenschaften X,Y und Speed. Was können wir daraus machen:

BlitzBasic: [AUSKLAPPEN] 
Type SpielerTyp
    Field X#, Y#, Speed#
End Type

Graphics 800,600
Global Spieler.SpielerTyp

Spieler=New SpielerTyp
Spieler\Speed=1.5
Spieler\Y =200 

Repeat
   Cls
   Spieler\X = Spieler\X +Spieler\Speed
   Oval Spieler\X, Spieler\Y, 10, 10
   Flip
Until KeyHit(1)


Die Eigenschaften einer Typ-Variablen werden immer mit einem Schrägstrich angesprochen:

Spieler\X steht für das das Field X#. Du kanst diese Eigenschaften wie normale Variable zum Rechnen benutzen, verändern oder für Mal-Ausgaben heranziehen.
  • Zuletzt bearbeitet von Midimaster am Do, März 31, 2011 9:10, insgesamt einmal bearbeitet

Midimaster

Betreff: Lektion III: Mit TYPEs Heerscharen von Gegnern erzeugen

 BeitragDo, Dez 31, 2009 18:20
Antworten mit Zitat
Benutzer-Profile anzeigen
Lektion III: Mit TYPEs Heerscharen von Gegnern erzeugen

Bei dem Beispiel der letzten Lektion hast du dir vielleicht gedacht, dies lässt sich alle auch noch mit "normalen" Variablen bewerkstelligen. Jetzt aber zeige ich die Vorteile der Types auf.

Jeder neue Gegner wird beim Erstellen zu einem neuen Element einer solchen TYPES-Liste:
BlitzBasic: [AUSKLAPPEN] 
Type GegnerTyp
    Field X#, Y#
End Type

Global Feind.GegnerTyp= New GegnerTyp
Global Brutalo.GegnerTyp= New GegnerTyp


Jetzt sind schon zwei Gegner in dieser Liste. Mit einem speziellen FOR/NEXT kannst Du sie alle durchlaufen lassen:

BlitzBasic: [AUSKLAPPEN] 
Local Gegner.GegnerTyp
For Gegner = Each GegnerTyp
   Gegner\X=10
Next
Print Brutalo\X

Durch das Definieren der neuen Variable Gegner ohne den Zusatz "=New GegnerTyp" erstelltst Du noch kein drittes Element. Vielmehr erhältst Du die Möglichkeit über diese Variable auf die bestehenden Elemente zuzugreifen, ohne deren Namen zu kennen. In diesem Beispiel erhalten alle Elemente den X-Wert "10". Anschließend kannst du beobachten, wie Brutalo\X wirklich 10 geworden ist.

Hier nun die typsichen Vorgehendsweisen in Spielen:

BlitzBasic: [AUSKLAPPEN] 
Function GegnerErschaffen()
   Local Feind.GegnerTyp
   Feind = New GegnerTyp
End Function

Diese Funktion erschafft einen "namenlosen" Gegner. Dieser lässt sich nur noch über solche For/Next-Schleifen nutzen. Zwar existiert die lokale Variable Feind nicht über die Funktion hinaus, aber das Element, das damit erschaffen wurde, bleibt in der Liste.


BlitzBasic: [AUSKLAPPEN] 
AlleGegnerErschaffen 100
Function AlleGegnerErschaffen(Wieviele%)
   Local Feind.GegnerTyp
   Local i%
   For i=1 To Wieviele
      Feind = New GegnerTyp
   Next
End Function

Diese Funktion erschafft gleich 100 "namenlose" Gegner. Du kannst also den Begriff Feind immer wieder für immer neue Gegner benutzen., ohne dass einer von Ihnen "Feind" heißen würde.

Der Begriff Feind dient nur dazu das Element für einen Moment greifbar zu machen. z.B. wäre dies möglich:
BlitzBasic: [AUSKLAPPEN] 
GegnerErschaffen 12

Function GegnerErschaffen(StartX%)
   Local Feind.GegnerTyp
   Feind = New GegnerTyp
   Feind\X=StartX
   Feind\Y=Rand(200,400)
End Function

Hier bekommen die Gegner gleich noch Startwerte mit.

Einige typische Aktionen in Spielen:

BlitzBasic: [AUSKLAPPEN] 
Function AlleGegnerZeichnen()
   Local Feind.GegnerTyp
   For Feind = Each GegnerTyp
      DrawImage MonsterBild, Feind\X, Feind\Y
   Next
End Function


BlitzBasic: [AUSKLAPPEN] 
Function EinfachAllesZeichnen()
   Local Feind.GegnerTyp, Schuss.SchussTyp, Planet.PlanetenTyp
   For Feind = Each GegnerTyp
      If Feind\Kraft>50 Then
         DrawImage MonsterBild, Feind\X, Feind\Y
      Else
         DrawImage MonsterFastTotBild, Feind\X, Feind\Y
      EndIf
   Next
   For Schuss = Each SchussTyp
      DrawImage KugelBild, Schuss\X, Schuss\Y
      DrawImage FeuerschweifBild, Schuss\X-20, Schuss\Y
   Next
   For Planet = Each PlanetenTyp
      DrawImage Bild(Planet\FotoNr), Planet\X, Planet\Y
      Text Planet\Name,  Planet\X, Planet\Y
   Next
End Function

Midimaster

Betreff: Lektion IV: Auch TYPES sterben!

 BeitragDo, Dez 31, 2009 18:53
Antworten mit Zitat
Benutzer-Profile anzeigen
Lektion IV: Auch TYPES sterben!

Wenn ein Gegner als Element einer TYPE-Auflistung gestorben ist, kannst Du ihn aus dieser Liste entfernen. Verwende dazu den Variablennamen in Kombination mit dem Befehl DELETE:

BlitzBasic: [AUSKLAPPEN] 
Local Feind.GegnerTyp
Feind= New GegnerTyp
; hier lebt er noch

Delete Feind
; nu isser tot


oder in einer Element-Liste:
BlitzBasic: [AUSKLAPPEN] 
Global Bestie.GegnerTyp= New GegnerTyp
Global Monster.GegnerTyp= New GegnerTyp

Local Feind.GegnerTyp
For Feind = Each GegnerTyp
   If Feind\Kraft < 1
      Delete Feind 
    EndIf
Next



In dem folgenden Beispiel werden zuerst 100 Gegner mit unterschiedlichem "Gesundheitszustand" erstellt.
Dann wird die Funktion gerufen. Dort werden alle toten Gegner (Kraft<1) herausgefischt und aus der Elementliste entfernt.
Abschließend läuft zum Beweis eine Schleife durch, die alle Toten anzeigen soll. Sie findet aber keinen mehr.
BlitzBasic: [AUSKLAPPEN] 
Type GegnerTyp
   Field Kraft%
End Type

Local Feind.GegnerTyp
For  I%=1 To 100
   Feind = New gegnertyp
   Feind\Kraft = Rand(0,10)
Next 

EntferneTote()

For Feind = Each GegnerTyp
   If Feind\Kraft < 1
     Print "da lebt noch einer, der eigentlich schon tot ist!"
   EndIf
Next
End
BlitzBasic: [AUSKLAPPEN] 
Function EntferneTote()
   Local Feind.GegnerTyp
   For Feind = Each GegnerTyp
     If Feind\Kraft < 1
      Delete Feind 
      Print "einen Toten entfernt"
     EndIf
   Next
End Function

Hierzu ein Tipp: Oft wird ja durch eine Kollision eines Gegners mit einem Schuss die Gesundheit des Gegners so geschwächt, das er mit DELETE entfernt werden könnte. Allerdings rate ich dazu, in der Kollision zunächst nur die Gesundheit dieses Gegners zu reduzieren und später (außerhalb der Kollisionsschleife) die Elemente des Gegnerfeld einmal durchlaufen zu lassen, um dort die "Toten" zu entfernen.

Damit verhinderst Du, dass die Kollisionsschleife weiter hinten im Code ein Element aufrufen könnte, das schon entfernt wurde. Dies würde zum Programmabsturz führen.

Midimaster

Betreff: Lektion V: Types und Funktionen

 BeitragFr, Jan 01, 2010 14:26
Antworten mit Zitat
Benutzer-Profile anzeigen
Lektion V: Types und Funktionen

In diesem Kapitel erfährst Du, wie sich Types in Funktionen verhalten, wie man sie als Parameter an die Funktion übergbene kann und dass Functionen auch über RETURN einen TYpe zurückgeben können.

Types nehmen in Bezug auf GLOBAL/LOCAL eine Sonderstellung ein. Zwar kannst Du Ihre Platzhalter-Variable LOCAL oder GLOBAL erstellen, doch die Elementliste existiert immer GLOBAL.

Dies bedeutet, dass jedes "... = New ...." ein weiteres Element zur Liste hinzufügt, egal wo Du dies machst:

BlitzBasic: [AUSKLAPPEN] 
Global Feind.GegnerTyp = New GegnerTyp
SpringInsUnterprogramm()
End

Function Unterprogramm()
   Local Neuer.GegnerTyp = New GegnerTyp
End Function

Dies erzeugt zwei Elemente, die auch noch da sind, wenn die Funktion längst verlassen ist. Der neue Gegner, der in der Funktion erzeugt wurde ist also GLOBAL. Das einzige LOKALE daran ist, dass er sich über die Variable NEUER nur lokal, also während der Funktion ansprechen läßt. Außerhalb der Function erreichst du ihn jederzeit über eine Aufzählung FOR/EACH/NEXT.


Benötigst Du in BlitzBasic innerhalb einer Function eine Variable vom Type GegnerTyp nur kurz, dann kannst Du dies so lösen:

BlitzBasic: [AUSKLAPPEN] 
Function Unterprogramm()
   Local KurzZeit.GegnerTyp = New GegnerTyp
   KurzZeit\Kraft = ....
   ....
   Delete KurzZeit
End Function


und möchtest Du dabei die Werte eines bereits bestehenden Elements kopieren, geht das nur so:

BlitzBasic: [AUSKLAPPEN] 
Function KopiereDieWerte(VonWem.GegnerTyp)
   KurzZeit.GegnerTyp = New GegnerTyp
   KurzZeit\Kraft = VonWem\Kraft
   KurzZeit\X = VonWem\X
   KurzZeit\Y = VonWem\Y
   ....
   Delete KurzZeit
End Function


Hier siehst Du bereits, dass TYPEs sich auch problemlos als Parameter an Funktionen übergeben lassen.


TYPE als Parameter an Funktion übergeben

Du hast drei Möglichkeiten, ein Element Deiner Type-Liste an eine Funktion zu übergeben:

BlitzBasic: [AUSKLAPPEN] 
Feind.GegnerTyp = New GegnerTyp
Feind\X = 123
KopiereDieWerte Feind
End
Function KopiereDieWerte(VonWem.GegnerTyp)
   Print VonWem\X
   VonWem\X = 456
End Function

Diese Variante übergibt das komplette Element, bei Änderungen innerhalb der Funktion ändert sich das Element aber auch GLOBAL.


BlitzBasic: [AUSKLAPPEN] 
Feind.GegnerTyp = New GegnerTyp
Feind\X = 123
KopiereDieWerte Feind
End
Function KopiereDieWerte(VonWem.GegnerTyp)
   KurzZeit.GegnerTyp = New GegnerTyp
   KurzZeit\X = VonWem\X
   ....
   Print KurzZeit\X
   KurzZeit\X = 456
   Delete KurzZeit
End Function

Diese Variante übergibt das komplette Element, bei Änderungen innerhalb der Funktion ändert sich aber nur das lokale Element KURZZEIT

BlitzBasic: [AUSKLAPPEN] 
Feind.GegnerTyp = New GegnerTyp
Feind\X = 123
KopiereDieWerte Feind\X
End
Function KopiereDieWerte(X%)
   Print X
   X = 456
End Function

Diese Variante übergibt nur denWert des X-Fields des Elements, bei Änderungen innerhalb der Funktion ändert sich deshalb auch nicht das Element.


Funktionen geben Types zurück

Ein Funktion kann wie bei INTEGER oder STRING auch eine Variable vom Type GegnerTyp zurückgeben.
Dazu wird in der Header-Zeile der Funktion die Funktion wie bei einer Variablen als TYPE definiert:

BlitzBasic: [AUSKLAPPEN] 
Function EineZahl%()
   Return Rand(1,123)
End Function

Function EinenTyp.GegnerTyp()
   Neu.GegnerTyp= New GegnerTyp
   Return Neu
End Function


Dies eignet sich hervorragend um neue Gegner zu erschaffen und gleich mit Werten zu versehen.
BlitzBasic: [AUSKLAPPEN] 
Global Feind.GegnerTyp
Feind =ErzeugeZufallsGegener()
End
Function ErzeugeZufallsGegener.GegnerTyp()
   Neu.GegnerTyp = New GegnerTyp
   Neu\X=Rand(1,800)
   Neu\Y=Rand(1,600)
   ...
   Return Neu
End Function


Oft werde ich auch gefragt, ob man eines der "namenlosen" Elemente auch direkt ansprechen könne, ohne über den Umweg der FOR/EACH/NEXT-Möglichkeit zu gehen. Durch die Rückgabe eines TYPEs ist dies zu machen:
BlitzBasic: [AUSKLAPPEN] 
Type GegnerTyp
   Field X#, Y#, Nr%
End Type
Global Feind.GegnerTyp
For I=1 To 9
   Feind=New GegnerTyp
   Feind\Nr=i
   Feind\X=i*100
Next	
Feind =SucheFeind(6)
Print Feind\x
WaitKey
End
BlitzBasic: [AUSKLAPPEN] 
Function SucheFeind.GegnerTyp(Nr%)
   For suchGegner.GegnerTyp = Each GegnerTyp
      If SuchGegner\Nr=Nr Then
         Return SuchGegner
      EndIf
   Next
End Function

Der Trick ist in die TYPE-Beschreibung ein neues FIELD mit dem Namen NR% einzufügen. Dies dient als laufende Nummer bei der Erstellung neuer Gegner. Jedesmal wenn ein neuer Gegner erstellt wird, wird eine Zählvariable um 1 erhöht und in NR% gemerkt.

Wir nun nach einem bestimmten Element der Liste gesucht, erledigt das eine Funktion, die alle Elemente mittels FOR/EACH/NEXT durchforstet und das Element mit dem Field NR als Type zurüclliefert. Jetzt kann außerhalb der Funktion mit genau diesem Element weitergearbeitet werden.

Hinweis: Es muss schon mit einer Zählvariablen Nummer% gearbeitet werden. Das bloße Abzählen der Position, die ein Such-Element momentan in der Liste hat. bringt falsche Ergebnisse, da element-Listen "dynamisch" sind und z.B. durch DELETE die Reihenfolge der Elemente durcheinandergeraten kann. Die Zählvariable NR% bleibt aber immer bei ihrem Element.
  • Zuletzt bearbeitet von Midimaster am Di, Jan 22, 2013 1:02, insgesamt einmal bearbeitet

Midimaster

Betreff: Lektion VI: Types in Arrays, Array in Types

 BeitragDo, Jan 07, 2010 21:24
Antworten mit Zitat
Benutzer-Profile anzeigen
Lektion VI: Types in Arrays, Array in Types

Arrays oder Felder sind Daten-Sammlungen, die eine feste Anzahl Einträge enthalten. Diese Einträge können Zahlen, Strings oder auch TYPEN sein. In dieser Lektion wirst du erfahren, wann es sinnvoll ist einen TYPE nicht über die typische Element-Liste FOR/EACH/NEXT anzusprechen, sondern über ein einfaches Array.

Im zweiten Teil lernst Du, wie Du Arrays auch als Field in einen TYPE aufnehmen kannst und wo hier sinnvolle Anwendungen liegen.

Wo sind Array sinnvoll, wo nicht?

Array kommen in modernen Programmen nur in Frage, wenn die Anzahl der Elemente fix ist, wenn also während des Spiels keine neuen Elemente dazukommen oder welche sterben.

Dies bedeutet, dass Arrays für TYPES wie Gegner, Schüsse, Planeten etc nicht optimal sind. Solche Typen sterben oft, Schüsse vergehen, oder Planeten geraten außer Reichweite.

Aber bei der Simulation von Spielfeldern sind Arrays erste Wahl. Denken wir uns ein Monopoly-Spiel. Es hat immer 40 Spielfelder, von Anfang an und das bleibt auch so. Oder ein Brettspiel wie Schach hat immer 8x8 Felder. Auch beim Kartenspiel verändert sich die Anzahl Karten in der Regel nicht.


Ein Array aus Types

Hier erstellen wir 32 Spielkarten:
BlitzBasic: [AUSKLAPPEN] 
Type KartenTyp
   Field Farbe%
   Field Augen%
   Field Gruppe%
   ...
End Type

Dim Karte.KartenTyp(32)

For i=1 To 32
   Karte(i) = New KartenTyp
Next


Ud hier sehen wir, wie wir die einzelnen Parameter jeder Spielkarte ansprechen können, oder Karten miteinander vergleichen.

BlitzBasic: [AUSKLAPPEN] 
...
Karte(1)\Farbe=ROT

If Karte(MeineKarte)\Augen < Karte(LastKarte)\Augen Then
....



Hier noch zwei Beispiele, ein Schachbrett:

BlitzBasic: [AUSKLAPPEN] 
Type FeldTyp
   Field Farbe%
   Field AktFigur%
   ...
End Type

Dim Feld.FeldTyp(8,8)

For i=1 To 8
   For j=1 To 8
      Feld(i,j) = New FeldTyp
   Next
Next 
; typischer Spielzug:
If Feld(x+2, y+1)\Aktfigur = 0
   Feld(x+2, y+1)\Aktfigur = SPRINGER
   Feld(x+2, y+1)\Farbe = SCHWARZ
   Feld(x,y)\Aktfigur = 0
EndIf


Das Schachbrett dient als Grundlage für alle Brettspiele, bei denen Spielzüge in zwei Dimensionen x und y gemacht werden können. Dazu gehören auch "4 gewinnt", Landschaftsspiele wie SimCity, oder Jump'Run-Spiele.

Ein Monopoly
BlitzBasic: [AUSKLAPPEN] 
Type StrasseTyp
   Field Name$
   Field KaufPreis%
   Field InGruppe%
   ...
End Type

Dim Strasse.StrasseTyp(40)

For i=1 To 40
   Strasse(i)\Name = "Schloßallee"
   Strasse(i)\KaufPreis = 40000
   Strasse(i)\InGruppe = SUPER_TEUER
Next 
; typischer Spielzug:
If Strasse(MyPos)\Gekauft = 0
   Print Strasse(MyPos)\Name + " ist noch zu haben"
   Print "Preis: " + Strasse(MyPos)\Kaufpreis
   ....
Else
   ; straße schon verkauft miete muss gezahlt werden
   MyMoney = MyMoney - Strasse(MyPos)\Miete
   ....
EndIf


Dies ist eine Vorlage für alle Spiele, die nur vorwärts oder Rückwärts gespielt werden können. z.B. Start-Ziel-Spiele, Backgammon, aber auch Spiele, die sich im Kreis drehen.


Wer Monopoly kennt, weiss aber, dass es auf einer Straße nicht nur einen Preis für die Miete gibt, sondern 5, je nachdem viele Häuser dort bereits gebaut sind. Das bringt uns zu einer neuen Array-Variante:

Ein Type mit einen Array-Field

Das Problem mit den fünf verschiedenen Mietkosten liese sich zur Not mit 5 Variablen lösen:

BlitzBasic: [AUSKLAPPEN] 
Type StrasseTyp
   Field Name$
   Field KaufPreis%
   Field InGruppe%
   Field Miete0%, Miete1%, Miete2%, Miete3%, Miete4%, Miete5%,
   ....


Es geht aber auch eleganter und das spart später richtig Code-Arbeit:

BlitzBasic: [AUSKLAPPEN] 
Type StrasseTyp
   Field Name$
   Field KaufPreis%
   Field InGruppe%
   Field Miete%[5]
   ....


Diese Mieten kann ich ansprechen über Miete[0] bis Miete[5]


BlitzBasic: [AUSKLAPPEN] 
Print "Die Miete hier beträgt:"
Print Strasse(MyPos)\Miete[0] + " EUR als unbebautes Grundstück."
For i=1 To 4
   Print Strasse(MyPos)\Miete[i] + " EUR mit " + i  + " Haus."
Next
Print Strasse(MyPos)\Miete[5] + " EUR mit einem Hotel"


In dem letzten Beispiel haben wir also einen TYPE, der ein Array [i]Miete() enthält. Und darüber hinaus ist der Type selbst wieder Grundlage eines Array Strasse()

Neue Antwort erstellen


Übersicht BlitzBasic FAQ und Tutorials

Nach Oben

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group