Skript-Engine integrieren

[I love Delphi]

So,
habe mich jetzt in das PDF zu SE2 eingelesen, das "einbauen" ist mir allerdings nicht geglückt. Zwar bekomme ich keinerlei Fehlermeldungen, dafür aber auch nicht das was ich will. Wenn ich die Dokumentation richtig verstanden habe, brauche ich doch eine Unit die die Prozeduren registriert und den Quelltext der, welche die external-Aufrufe beinhaltet, in einer Konstanten enthält. Auf die sollte ich dann während der Ausführung zugreifen können, richtig?

Mein Code:

Delphi-Quellcode:

unit Skripting;

interface

uses AdSprites, Dialogs, murmel, SysUtils, uSE2Compiler, uSE2UnitCacheMngr, uSE2Errors, uSE2Reader, uSE2PEData, uSE2RunTime, uSE2RunAccess, uSE2UnitManager, uSE2Consts, Murmelspiel_Form1_CODE;

  procedure Prepare();
  procedure ParseSkript(ASkript: String; AMurmel: TMurmel);
  procedure ZeigeNachricht(ANachricht: String);
  procedure Murmel_SetXSpeed(AXSpeed: double; AMurmel: TMurmel);
  procedure Murmel_SetYSpeed(AYSpeed: double; AMurmel: TMurmel);

const
// diese Variable mit dem Namen der Unit füllen
C_UnitName = 'SkriptCommands';
// in diese Variable kommt der komplette Script-Quelltext
C_UnitSource =
  'unit SkriptCommands;'+#13#10+ #13#10+
  'interface'+#13#10+#13#10+
  'uses Murmel, Skripting;'+#13#10+#13#10+
  'procedure ZeigeNachricht(ANachricht: String); external;'+#13#10+
  'procedure Murmel_SetXSpeed(AXSpeed: double; AMurmel: TMurmel); external;'+#13#10+
  'procedure Murmel_SetYSpeed(AYSpeed: double; AMurmel: TMurmel); external;'+#13#10+#13#10+
  'implementation'+#13#10+#13#10+
  'end.';

var
  Compiler : TSE2Compiler;
  RunTime : TSE2RunTime;
  PEData : TSE2PE;

implementation

procedure Unit_GetSource(var Target: string);
begin
  Target := C_UnitSource;
end;

procedure Unit_RegisterMethods(const Target: TSE2RunAccess);
begin
  if Target.HasUnit(C_UnitName) then
  begin
    // hier die Funktions-Pointer setzen
    Target.Method['ZeigeNachricht[0]', C_UnitName] := @ZeigeNachricht;
  end;
end;

procedure RegisterUnit;
var p : TSE2MethodUnit;
begin
  p := TSE2MethodUnit.Create;
  p.DoRegisterMethods := Unit_RegisterMethods;
  p.DoGetUnitSource := Unit_GetSource;
  p.UnitName := C_UnitName;
  TSE2UnitManager.RegisterUnit(p);
end;

procedure ParseSkript(ASkript: String; AMurmel: TMurmel);
begin
  //ShowMessage('Hallo');
  //Das Parsen übernimmt nun die S(cript) E(ngine) 2 (http://www.delphipraxis.net/140590-scriptengine-ii-v-0-5-3-2-a-4.html)
  Compiler := TSE2Compiler.Create;
  try
    PEData := Compiler.Compile(ASkript);
    if PEData <> nil then
    begin
      RunTime := TSE2RunTime.Create;
      try
        RunTime.AppCode := PEData;
        RunTime.Initialize;
        Pause:=true; //Spiel während Skript-Ausführung anhalten
        RunTime.Run;
        Pause:=false;
        RunTime.Finalize;
        RunTime.AppCode := nil;
      finally
        RunTime.Free;
      end;
    end;
  except
    ShowMessage('Beim Ausführen des Skripts ist ein Fehler aufgetreten!');
  end;
  PEData.Free;
end;

procedure Murmel_SetXSpeed(AXSpeed: Double; AMurmel: TMurmel);
begin
  AMurmel.XSpeed := AXSpeed;
end;

procedure Murmel_SetYSpeed(AYSpeed: Double; AMurmel: TMurmel);
begin
  AMurmel.YSpeed := AYSpeed;
end;

procedure ZeigeNachricht(ANachricht: string);
begin
  ShowMessage(ANachricht);
end;

initialization
RegisterUnit;

end.

Das hier wäre der Aufruf, der funktioniert jedoch:

Delphi-Quellcode:

Skripting.ParseSkript(Sprite.Skript, self);

Vielleicht habe ich auch einfach das Konzept dahinter noch nicht ganz verstanden... :(


Ich hoffe, jemand versteht mich.

Vielen Dank!

Viele Grüße,
I love Delphi!

EDIT: Als Skript habe ich folgendes verwendet:

Delphi-Quellcode:

program MyScriptProject;
uses
SkriptCommands;
begin
ZeigeNachricht('Hallo');
end.

[Florian Hämmerle]

Hi!

So auf die schnelle ohne Delphi kann ich dir auch nicht helfen. Aber ich habs so gemacht, dass ich erst ne ganz kleine Unit geschrieben habe und die dann getestet habe, ob alles funktioniert und erst bei erfolg hab ich die Unit erweitert. Vielleicht machst du das einfach nochmal von vorne und probierst nach jeder neuen Methode aus, ob noch alles funktioniert, dann kannst du den Fehler eingrenzen.
ODER: du schmeißt mal den Debugger an und steppst durch dein Spiel um zu schauen ob das Script überhaupt ausgeführt wird oder was los ist.

mfg Florian

[I love Delphi]

Hey,
also ausgeführt müsste es werden, das habe ich mit einem beispielhaften Aufruf von ShowMessage() in der Prozedure ParseSkript() getestet.
Leider wüsste ich gar nicht, inwiefern ich die Klasse noch reduzieren sollte: Ich habe lediglich die drei Funktionen/Prozeduren Murmel_SetYSpeed, Murmel_SetXSpeed und ZeigeNachricht() hinzugefügt. Wenn ich diese jedoch nicht mehr habe, dann kann ich ja die Funktionstüchtigkeit nicht mehr prüfen! Mist...

Viele Grüße,
I love Delphi!

[littleDave]

Ok, ich versuche mal eine Schnell-Anleitung zu geben, wie man das ganze am schnellsten macht (nicht abschrecken von den paar Punkten - habe versucht es möglich genau zu machen.

• Öffne die Beispiel-IDE, die mit im Download-Paket im Ordner "IDE" enthalten ist
• Erstelle ein neues Projekt (ist egal wie es heißt)
• Klicke mit der rechten Maustaste im Tab "Project" auf den oberen Eintrag in der TreeView und wähle den Eintrag "Add new Unit"
• Gib den Unit-Names "SkriptCommands" ein und drücke ok
• Wiederhole das ganze mit "Murmel" und "Skripting"
• Nun kannst du die Units per Doppelklick auf den entsprechenden Eintrag öffnen
• Fülle den Inhalt der Units entsprechend aus (also das, was bei dir in der Konstante C_UnitSource steht
• Wiederhole das mit "Murmel" und "Skripting"
• Gehe nun in den ersten Tab bei der Quelltext-Liste (da wo die Units offen sind) (program ... etc.)
• Füge deine hinzugefügten Units in die Uses-Liste hinzu (es sollte keine uses-Liste vorhanden sein, also einfach ganz normal erstellen)
• Nun solltest du kompilieren können.
• Jetzt wählst du wieder den Tab der Unit "SkriptCommands" aus.
• Dann klickst du im Hauptmenü unter "Project" auf "Generate Unit" -> "Application Unit"
• Es wird ein neuer Tab erstellt, in dem der komplett fertige Delphi-Quelltext drinnen steht. Diesen kopierst du einfach in die Zwischenablage und fügst ihn in eine neue Unit in deinem Projekt hinzu. Wahrscheinlich musst du noch ein paar uses-Sachen für die entsprechenden Typen anpassen, aber und vielleicht ein paar Methoden - aber es sollte eigentlich funktionieren ;-)
• Wiederhole die letzten 3 Punkte mit den Units "Murmel" und "SkriptCommands"

Die neuen Units, die du gerade erstellt hast, solltest du nicht mehr groß erweitert. Die sind nur dafür da, um die Script-Engine mit deinen Methoden usw. zu füllen.

Jetzt baue ich dein Beispiel-Script nach, wie es eigentlich funktionieren sollte (hab gerade kein Delphi zur Hand, daher ist alles nur ausm Kopf heraus geschrieben)

Erstelle in deinem Delphi-Projekt eine neue Unit und schreibe folgenden Quelltext hinein:

Delphi-Quellcode:

unit [was auch immer]

interface

procedure RunScript(const ScriptSource: string);

implementation

uses
  uSE2Compiler, uSE2RunTime, uSE2PEData;

procedure RunScript(const ScriptSource: string);
var Compiler: TSE2Compiler;
    PEData  : TSE2PE;
    RunTime : TSE2RunTime;
begin
  Compiler := TSE2Compiler.Create;
  try
    // Compilieren
    PEData := Compiler.Compile(ASkript);
    if PEData <> nil then
    begin
      // Compilieren erfolgreich - PEData muss nicht manuell
      // freigegeben werden, da die RunTime das für uns erledigt.
      // Daher gibt es hier für PEData keinen try-finally-Block
      RunTime := TSE2RunTime.Create;
      try
        RunTime.AppCode := PEData;

        // RunTime initialisieren
        RunTime.Initialize;
        // ausführen
        RunTime.Run;
        // aufräumen
        RunTime.Finalize;
      finally
        // wie gesagt, PEData wird hier mit freigegeben
        RunTime.Free;
      end;
    end;
  finally
    Compiler.Free;
  end;
end;

end.

Folgende Punkte sind im PDF für dich noch wichtig:

• 2.2 Auf Compiler-Fehler reagieren
• 2.5 Auf Laufzeitfehler reagieren - denn dein (except-block mit ShowMessage('Beim Ausführen des Skripts ist ein Fehler aufgetreten!'); wird nur bei wirklich fatalen Fehlern erreicht - alle Exceptions innerhalb eines Scriptes (z.B. Dividieren durch 0) müssen anders behandelt werden

Was ich auch noch erwähnen wollte: die SEII ist nicht dazu optimiert, ständig den Quelltext zu kompilieren und diesen dann direkt auszuführen. Die SEII ist für das Ausführen von Scripten extrem optimiert (schneller als Pascal-Script, Sysygy, Delphi++, etc...). Daher wäre es sinnvoll, dein Script einmal durch den Compiler zu jagen und dir das TSE2PE-Objekt zu merken. Aber das nur so am Rande, jetzt schau ma erstmal, dass dein Basis-Ding funktioniert ;-)