Spiele in Lazarus objektorientiert programmieren/Objekte und Klassen

Object Pascal ist – wie der Name schon sagt – eine so genannte objektorientierte Sprache. Man kann in ihr Objekte von verschiedenen Sorten anlegen, die bestimmte Eigenschaften haben und die bestimmte Dinge tun können. Die Lazarus-IDE unterstützt diese Art der Programmierung nachhaltig, indem sie dem Programmierer viele Routine-Aufgaben abnimmt und auch sehr viel Programmtext schon automatisch erzeugt: So kann sich der Programmierer auf die wesentlichen Dinge konzentrieren. Eigenschaften im Objekt-Inspektor

Objekte und Klassen im Alltag

Um eine grobe Vorstellung davon zu haben, was Informatiker unter „Objekten“ und unter „Klassen“ verstehen, schauen wir uns einfach „Dinge“ unseres Alltags an, z.B. Autos.

Ein ganz bestimmtes Auto wäre hierbei ein Objekt (z.B. das hässliche, verrostete gelbe Auto der Nachbarn). Dieses Auto hat verschiedenste Eigenschaften (Hersteller, Typbezeichnung, Baujahr, Farbe, Motorleistung, Anzahl der Sitze, …).

Und Autos können verschiedene Dinge tun, z.B. beschleunigen, abbremsen, usw. (wobei wir uns die etwas philosophische Diskussion ersparen, ob wirklich das Auto das tut oder der Fahrer). Diese Tätigkeiten eines Autos werden in der Sprache der Informatiker als Methoden bezeichnet. Methoden können insbesondere auch Eigenschaften eines Objekts ändern. Im Fall des Autos ändert die Methode beschleunigen beispielsweise die Eigenschaft Geschwindigkeit.

Für manche Objekte ebenfalls wichtig sind so genannte Ereignisse. Das sind äußere Einflüsse auf die ein Auto mit Tätigkeiten reagieren kann. Typische Ereignisse beim Auto wären z.B. Gaspedal wurde gedrückt oder Lenkrad wurde gedreht.

Objekte in Lazarus

Die Objekte, mit denen wir uns beim Programmieren zunächst beschäftigen, sind diejenigen, die der Benutzer des Programms sieht. Das ist das Programmfenster selbst, später kommen auch andere Dinge hinzu: bei den Spielen vor allem Bilder im Hintergrund und die Bilder von den Dingen, die sich im Spiel bewegen.

Eigenschaften von Objekten in Lazarus

Das erste (und bisher einzige) Objekt, das wir nach dem Erzeugen eines neuen Projekt sehen, ist ein leeres Fenster. Aber schon ein leeres Fenster ist ein Objekt mit Eigenschaften, die man als Programmierer verändern kann.

Der Objekt-Inspektor

Die einfachste Möglichkeit, dies zu tun bietet der so genannte Objekt-Inspektor. Hier kann man beispielsweise im Reiter „Eigenschaften“ die Beschriftung des Fensters am oberen Rand ändern (Caption). Auch weitere Eigenschaften eines Fensters können hier geändert werden; die für uns zunächst wichtigsten zeigt die folgende Tabelle

Eigenschaft	Bedeutung
Caption	Beschriftung des Fensters
Color	Hintergrundfarbe des Fensters
Height	Höhe des Fensters
Width	Breite des Fensters
Left	Entfernung des linken Fensterrandes vom linken Bildschirmrand
Top	Entfernung des oberen Fensterrandes vom oberen Bildschirmrand
Hint	Hinweis, der angezeigt wird, wenn der Benutzer mit dem Mauscursor längere Zeit auf dem Fenster steht
ShowHint	Wenn angehakt, wird der oben genannte Hinweis angezeigt, sonst nicht.
Name	Interner Name des Fensters (s. Erklärung unten)

Breie und Höhe, sowie die Position des Fensters kann man allerdings auch mit der Maus erledigen, die im Objektinspektor angezeigten Größen ändern sich dabei automatisch.

Eine besondere Eigenschaft, die sich auf das Aussehen des Fensters gar nicht auswirkt, ist die Eigenschaft Name (nicht zu verwechseln mit Caption). Diese Eigenschaft gibt dem Objekt einen Namen, der dann später im eigentlichen Programm verwendet wird. Beim Fenster ist der Name standardmäßig Form1.

Bei der Benennung von Objekten hat es sich als günstig erwiesen, als Gedächtnisstütze die ersten beiden Buchstaben so zu wählen, dass man sieht, von welcher Art (man sagt: von welchem Typ) das Objekt ist: Bei Fenstern (Form) wäre das z.B. „fm...“, so dass das Hauptfenster einer Anwendung z.B. „fmHaupt“ heißen könnte.

Datentypen

Die Eigenschaften von Objekten sind zum Teil sehr unterschiedlich. Es kann sich – wie z.B. bei den Eigenschaften Left oder Width – um z.B. um ganze Zahlen handeln (engl.; „Integer“) oder – wie bei Caption oder Hint – um Zeichenketten (engl.: String). Es gibt auch Eigenschaften wie ShowHint, die einfach nur wahr oder falsch sind (engl.: Boolean mit den Werten TRUE und FALSE).

Methoden und Ereignisse

Ereignisse

Die Objekte, (z.B. das Fenster) müssen irgendwie auf Dinge reagieren, die der Benutzer des Programms tut. Man sagt: Der Benutzer löst z.B. mittels Maus oder Tastatur bestimmte Ereignisse aus. Welche Ereignisse das sein können, kann man im Reiter „Ereignisse“ des Objektinspektors nachlesen. Keine Angst vor der Menge der möglichen Ereignisse: wir werden nur ganz wenige davon überhaupt brauchen.

Ereignis	Tritt ein, wenn ...
OnCreate	… das Fenster und sein Inhalt gerade entstanden ist.
OnClick	… man mit der Maus auf den Fensterhintergrund klickt
OnMouseDown	… wenn man eine der Maustaste irgendwo auf dem Fensterinhalt herunterdrückt
OnMouseUp	… wenn man eine der Maustaste irgendwo auf dem Fensterinhalt wieder loslässt
OnKeyDown	… wenn man eine Taste der Tastatur herunterdrückt
OnKeyUp	… wenn man eine Taste der Tastatur wieder loslässt

Methoden

Objekte haben nicht nur Eigenschaften, sie können auch Dinge tun. Sie können z.B. die eigenen Eigenschaften oder die fremder Objekte verändern. Immer dann, wenn das Programm auf ein Ereignis reagieren soll, muss eine entsprechende Methode dies tun. Klickt man auf dem Reiter „Ereignisse“ im Objektinspektor auf die Spalte neben dem Ereignisnamen, erzeugt Lazarus automatisch eine entsprechende Methode und verknüpft sie mit diesem Ereignis.

Eine erste selbst erzeugte Methode

Klickt man also z.B. rechts doppelt neben das Ereignis „OnClick“, so wird eine neue Methode im Programmtext erzeugt. Diese wird aufgerufen, wenn man mit der Maus auf das leere Fenster klickt. Dem Programmierer wird diese Stelle im Programmtext auch direkt angezeigt.

Man kann nun eine Zeile zwischen „begin“ und „end“ einfügen, die dafür sorgt, dass der Eigenschaft „Color“ der Wert „clGreen“ zugewiesen wird.

procedure TForm1.FormClick(Sender: TObject);
begin
  Form1.Color:=clGreen;
  Form1.Caption:='Ohh... alles Grün';
end;

Bei der Befehlszeile erkennt man: Man schreibt zunächst das Objekt (hier: Form1) hin, dann folgt ein Punkt und dann die Eigenschaft (hier: Color), um zu beschreiben, dass man die Eigenschaft Color des Objekts Form1 verändern will.

Man sieht auch: Kommen mehrere Befehlszeilen hintereinander, so werden diese mit einem Semikolon (Strichpunkt) getrennt.

Zuweisungen

Will man innerhalb von Methoden den Eigenschaften von Objekten bestimmte Werte zuweisen, muss man ein paar sehr einfache Regeln beachten:

Die Eigenschaft steht immer links, der Wert, der zugewiesen wird immer rechts vom Zuweisungsoperator „:=“. Je nach Datentyp muss man beachten

Datentyp	Hinweis	Beispiel
Integer	Einfach die Zahl hinter das := schreiben.	Form1.Left:=42; Form1.Left:=Form1.Left+10; // verschiebt den linken Rand des Fensters um 10 Pixel nach rechts.
String	String-Werte werden in einfache Anführungszeichen (meist gleiche Taste wie der Hash-Tag, nur mit Großschreibung).	Form1.Caption:='Mein Programm';
Boolean	Man kann hier nur die die Werte TRUE oder FALSE zuweisen.	Form1.Visible:=FALSE; Form1.Visible:=TRUE;

Typumwandlung

Was nicht so ohne weiteres funktioniert, ist das Zuweisen über die Grenzen von Datentypen hinweg. Wenn man also in der Beschriftung des Fensters einfach die Eigenschaft Left anzeigen lassen möchte, so funktioniert das nicht mit dem Befehl

Form1.Caption:=Form1.Left;

Denn die Eigenschaft Caption ist eine Zeichenkette (String), während Left eine ganze Zahl (Integer) ist. Es gibt jedoch Befehle, die z.B. Zahlen in Zeichenketten umwandeln. Ein funktionierender Befehl wäre also

Form1.Caption:=IntToStr(Form1.Left);

Ein einfaches Beispielprogramm

In dem folgenden Beispielprogramm wird direkt beim Programmstart der Fenstertitel auf „Mein tolles Programm“ gesetzt. (Man hätte das auch direkt im Objektinspektor erledigen können, aber nicht alles kann man im Objektinspektor erledigen, wie wir später noch sehen werden).

Weiterhin sorgt das Programm dafür, dass sich beim Anklicken des Fensters mit der Maus die Farbe des Fensters ändert. Auch die Titelzeile ändert sich.

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs;

type

  { TForm1 }

  TForm1 = class(TForm)
    procedure FormClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }


procedure TForm1.FormCreate(Sender: TObject);
begin
  Form1.Caption:='Mein tolles Programm';
end;


procedure TForm1.FormClick(Sender: TObject);
begin
  Form1.Color:=clBlue;
  Form1.Caption:='Mein tolles Programm nach dem ersten Klick';
end;



end.

Hinzufügen weiterer Objekte

Auf die Dauer ist ein einfaches Fenster, auf dem außer dem Hinweis nichts zu sehen ist, doch recht langweilig. Wir fügen aus dem Reiter „Additional“ geometrisches Objekt, genauer: ein Objekt vom Typ TShape hinzu. Hierfür klicken wir zunächst auf das Symbol Datei:Bild7.pngin der Symbolleiste und dann irgendwo in das Formular.

Man kann das nun entstandene Objekt mit dem Namen Shape1 nun nachträglich mit der Maus verschieben. Man kann die Form (Shape) und die Farbe (Color) im Objektinspektor verändern.

Natürlich geht das auch innerhalb der entsprechenden Methoden des Programms. Will man z.B., dass die Koordinaten des Objekts sich beim Drücken einer Maustaste irgendwo im Fenster (außer auf die geometrische Form selbst) ändern, so könnte das so aussehen.

procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
  Shape1.Left:=10;
  Shape1.Top:=20;
end;

Wichtig: Da wir es hier jetzt mit mehreren Objekten zu tun haben, müssen wir im Objektinspektor zunächst tatsächlich Form1 auswählen und dann im Reiter „Ereignisse“ rechts neben dem Ereignis OnMouseDown einen Doppelklick ausführen.

In der zweiten Zeile kann man erkennen, dass innerhalb der Methode noch die Variablen X und Y zur Verfügung stehen. Diese liefern die Informationen, wo genau der Mauszeiger stand, als die Maustaste gedrückt wurde. Das lässt sich nutzen, um unsere geometrische Form mit der linken oberen Ecke genau an die Position des Mauszeigers zu setzen, wenn die Maustaste gedrückt ist. Will man, dass das geometrische Objekt z.B. unsichtbar wird, wenn man auf das geometrische Objekt selbst klickt, so muss man im Objekt Shape1 im Objektinspektor auswählen und dann dort neben dem Ereignis OnMouseDown den Doppelklick ausführen.

Die so entstandene Methode können wir nun ergänzen.

procedure TForm1.Shape1MouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
  Shape1.Visible:=FALSE;
end;

Wichtig: Egal, welches Objekt (hier: Fenster oder geometrisches Objekt) das Ereignis auslöst; die zugehörige Methode gehört in Lazarus immer zum Fenster.