Weitere News...

Um eine Figur ins Spiel zu bringen, sind eine Menge Aktionen nötig. Deshalb ist es sinnvoll, alle Methoden in einer neuen Unit zusammenzufassen, die ich G4DFigur nennen möchte. Die Methoden, die eine solche Figur mindestens braucht, sind allesamt in der Klasse TFigur vereinbart.

(Statt von einer Figur könnte man auch von Akteur, Bot, Kreatur, Gegner oder wie auch immer sprechen. Daher steht es Euch natürlich frei die Unit bzw. Klasse beispielsweise in G4DBot bzw. TBot umzubenennen. Allerdings kann unsere Figur hier einem echten Bot noch lange nicht das Wasser reichen.)

Verschaffen wir uns einen Überblick über die Genesis-Units, die in die Hauptunit eingebunden werden müssen:

G4D_Genesis, G4D_BaseType, G4D_XForm3D, G4D_geTypes,
  G4D_Vec3D, G4D_Vfile, G4DDriver, G4DFigur;

Neu gegenüber dem letzten Projekt ist lediglich die Unit G4DFigur, die es aber in sich hat. Denn unsere Figur lernt damit nicht nur (scheinbar) selbständig zu laufen, sondern sie kann auch mit Kollisionen umgehen, Treppen und die Schwerkraft sind für sie kein Problem. Dazu bedarf es einer Reihe weiterer Methoden, von denen viele jedoch für Voreinstellungen zuständig sind.

Auch hier zuerst die Uses-Liste:

uses
  Windows, Classes, Dialogs,
  G4D_Genesis, G4D_BaseType, G4D_XForm3D, G4D_geTypes, G4D_Vec3D,
  G4D_Vfile, G4D_Motion, G4D_Actor;

Als nächstes folgt die Vereinbarung der Klasse TFigur. Dabei habe ich eine ganze Reihe Vektoren aus der Hauptunit übernommen. So trifft man von ViewVector bis MaxVector nur gute Bekannte. Lediglich mit ScaleVector gibt es einen weiteren Vektor für die Größenverhältnisse, in denen die Figur im Spiel erscheinen soll. (Es leuchtet sicher ein, dass ich mich später für Bewegung und Kollisionskontrolle der Figur ebenfalls kräftig bei den Methoden aus TForm1 bediene.)

type
  TFigur = class
  private
    Actor      : pgeActor;      // Figurtyp
    ActorFile  : pgeVFile;      // Figurdatei
    ActorDef   : pgeActor_Def;  // Definitionsdaten
    ViewVector : geVec3D;       // aktuelle Position
    LookVector : geVec3D;       // neue Position
    TurnVector : geVec3D;       // Drehwinkel
    ScaleVector: geVec3D;       // Skalierungswerte
    MinVector  : geVec3D;       // min. Kollisionsgrenze
    MaxVector  : geVec3D;       // max. Kollisionsgrenze
    Motion     : pgeMotion;     // Animationphasen
    MCount     : geFloat;       // Animationszähler
    MStart     : geFloat;       // Startzeitpunkt
    MTime      : geFloat;       // Animationsdauer
    MStop      : geFloat;       // Endzeitpunkt
    MSpeed     : geFloat;       // Laufgeschwindigkeit
    isMoving   : Boolean;       // in Bewegung?
  public
    World: pgeWorld;
    constructor Create (Welt: pgeWorld; DateiName: String);
    procedure SetPosition (x,y,z: geFloat);
    procedure SetRotation (x,y,z: geFloat);
    procedure SetScale (x,y,z: geFloat);
    procedure SetRange (x0,y0,z0, x1,y1,z1: geFloat);
    procedure SetMotion
      (Speed: geFloat; Bewegung: String; Modus: Boolean);
    function  Collision: Boolean; virtual;
    procedure CheckGravity; virtual;
    procedure Walk; virtual;
    procedure Render (Zeit: DWord); virtual;
    destructor Destroy; override;
  end;

Nun zu den einzelnen Methoden. Zuerst geht es um die Erschaffung der Figur. Dabei beginnt die Create-Methode damit, allen Vektoren einen (vorläufigen) Startwert zuzuteilen:

constructor TFigur.Create (Welt: pgeWorld; DateiName: String);
begin
  inherited Create;
  // Startaufstellung/ausrichtung "nullen"
  geVec3d_Set (@Motion, 0.0, 0.0, 0.0);
  geVec3d_Set (@ViewVector, 0.0, 0.0, 0.0);
  geVec3d_Set (@LookVector, 0.0, 0.0, 0.0);
  geVec3d_Set (@TurnVector, 0.0, 0.0, 0.0);
  // Normale Größe
  geVec3d_Set (@ScaleVector, 1.0, 1.0, 1.0);
  // Begrenzungen
  geVec3d_Set (@MinVector,-20.0,-0.0,-20.0);
  geVec3d_Set (@MaxVector, 20.0, 0.0, 20.0);
  // ACT-Datei laden
  ActorFile := geVFile_OpenNewSystem (nil,
    GE_VFILE_TYPE_DOS, PChar(DateiName), nil, GE_VFILE_OPEN_READONLY);
  if ActorFile = nil then
    ExitError ('ACT-Datei lässt sich nicht öffnen!');
  // Definitionsdaten der Figur "auspacken"
  ActorDef := geActor_DefCreateFromFile (ActorFile);
  if ActorDef = nil then
    ExitError ('Figurdaten lassen sich nicht auslesen!');
  // Die Figur "zusammenbauen"
  Actor := geActor_Create (ActorDef);
  if Actor = nil then
    ExitError ('Figur lässt sich nicht erzeugen!');
  // Die Figur in die Welt einfügen
  InitOK := Boolean(geWorld_AddActor
    (Welt, Actor, GE_ACTOR_RENDER_NORMAL, $fffffff));
  if not InitOK then
    ExitError ('Figur lässt sich nicht in Welt einfügen!');
  // Welt "übernehmen"
  World := Welt;
  // Startdaten für Animation setzen
  Motion := nil;
  MCount := GetTickCount; // 0.0;
  MSpeed := 0.0; isMoving := false;
end;

Dann wird die Datei geladen, die sämtliche Daten für unsere Figur enthält:

ActorFile := geVFile_OpenNewSystem (nil, GE_VFILE_TYPE_DOS,
  PChar(DateiName), nil, GE_VFILE_OPEN_READONLY);

Während die Weltdaten als BSP-Datei gespeichert sind, sind die Daten einer Figur in einer Datei untergebracht, die für Genesis3D die Kennung ACT hat. Das ist ein Kürzel für "Actor", zu Deutsch soviel wie "Schauspieler, Darsteller". In Genesis3D sind damit nicht nur Akteure gemeint, also Figuren, die sich bewegen und auch etwas tun (können). Als Actor gilt aber ebenso z.B. ein Baum oder eine Figur, die unbeweglich einen Eingang bewacht. Viele Gegenstände in einem Spiel können also vom Typ Actor sein.

Um eine Figur zu erstellen, wird ein 3D-Grafikprogramm benötigt. Eine sehr preisgünstige Möglichkeit ist das Shareware-Programm MilkShape 3D (mit dem sich Figuren nicht nur für Genesis-Games, sondern auch für zahlreiche andere Spiele wie z.B. Quake, Half-Life, Unreal oder Max Payne erstellen lassen). Nun müssen wir zuerst die Daten auspacken, die die Figur beschreiben. Anschließend kann damit die Figur selbst zusammengebaut werden:

ActorDef := geActor_DefCreateFromFile (ActorFile);
Actor := geActor_Create (ActorDef);

Die fertige Figur wird in die Welt eingefügt und diese kann dann mit der Eigenschaft World von TFigur verknüpft werden:

geWorld_AddActor (Welt, Actor, GE_ACTOR_RENDER_NORMAL, $fffffff));
World := Welt;

Zuletzt setzen wir die Ausgangswerte für eine mögliche Animation der Figur. Dabei sorgen wir jetzt dafür, dass sie erst einmal ihre Ruhe hat und stellen alles auf "regungslos":

Motion := nil; MCount   := GetTickCount;
MSpeed := 0.0; isMoving := false;