constructor name must be init???

[Anonymus]

Aus Turbo Pascal Zeiten kenne ich Objekte, bei denen der Constuctor diesen Namen hatte, aber bei Klassen. Ich will grad die Allegro ausprobieren. Dort aber sind keine Objekte (Schlüsselwort object) sondern Klassen im Einsatz (Schlüsselwort Class).

Warum dann diese Meldung?

Lässt sich die irgendwo abschalten?

[theo]

In welchem Modus bist du und wie kommst du da hin?

-Ss http://www.freepascal.org/docs-html/use ... 460005.1.5

[Anonymus]

In welchem Modus bist du und wie kommst du da hin?

-Ss http://www.freepascal.org/docs-html/use ... 460005.1.5

In der fpc.cfg ist der Modus -Ss NICHT eingeschaltet, sondern mit einem # ausgeschaltet.

#-Ss

Ansonsten habe ich die Standardeinstellungen der allegro.cfg beibehalten.

Ich verwende die Pascalversion 4.4.5 der Allegro und möchte diese auch beibehalten, denn solches Gefrickel begegent mir nicht zum Ersten Mal und die Version 5 scheint mir wieder mal total anders zu sein. Habe von Computerfreunden noch alte Allegro Programme, die die Version 4.4.5 voraussetzen. Auf neue Version das alles anpassen ist mir zu frickelig. Wennschon dennschon dann eben diese Version 4.4.5 zum Laufen kriegen und die Frickelei jetzt in Kauf nehmen und dann diese Version bis in alle Ewigkeit verwenden. Ich muss nicht von allen Bibliotheken die brandneuste Version haben, ich brauche in ERSTER Linie eine Version die ordentlich funktioniert.


Gibt es noch irgendwo einen Compilerschalter, den ich im Quelltext setzen kann bzw. muss?

Es geht um diesen Quellcode, zu finden im Ordner Examples der Allegro.pas Version 4.4.5:

Seit wann wird Construktorname Init bei Klassen verlangt?

Der Compiler hält beim Konstruktor von TCube an, mit der ominösen Meldung. Kann man nicht Default die Konstruktornamen freistellen?

Code: Alles auswählen

 
UNIT cube;
(*______   ___    ___
 /\  _  \ /\_ \  /\_ \
 \ \ \L\ \\//\ \ \//\ \      __     __   _ __   ___        __    ___      ____
  \ \  __ \ \ \ \  \ \ \   /'__`\ /'_ `\/\`'__\/ __`\    /'__`\ /\__`\  /'___/
   \ \ \/\ \ \_\ \_ \_\ \_/\  __//\ \L\ \ \ \//\ \L\ \__/\ \L\ \\/ __ \/\____`\
    \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/\_\ \  __//\____/\/\____/
     \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/\/_/\ \ \/ \/___/  \/___/
                                    /\____/               \ \_\
                                    \_/__/                 \/_/
 
   Defines a simple 3D cube used by ex3d and exzbuf examples.
 
   It isn't a very efficient piece of code, but it does show the stuff in
   action.  It is left to the reader as an exercise to design a proper model
   structure and rendering pipeline:  after all, the best way to do that sort
   of stuff varies hugely from one game to another.
 
   By Guillermo "Ñuño" Martínez
   Some parts are inspired or ported from an example of the Allegro library
   by Shawn Hargreaves.
 
   See README file for license and copyright information.
 *)
 
{$IFDEF FPC}
{ Free Pascal. }
  {$MODE OBJFPC}
{$ENDIF}
 
INTERFACE
 
  USES
    allegro, alfixed, al3D;
 
 
 
  TYPE
  (* A simple vector. *)
    TVector = OBJECT
    PRIVATE
      fx, fy, fz: AL_FIXED;
    PUBLIC
      CONSTRUCTOR Init (ax, ay, az: AL_FIXED);
    (* Adds the given vector. *)
      PROCEDURE Add (Vector: TVector);
 
      PROPERTY x: AL_FIXED READ fx WRITE fx;
      PROPERTY y: AL_FIXED READ fy WRITE fY;
      PROPERTY z: AL_FIXED READ fz WRITE fz;
    END;
 
 
 
  (* A face. *)
    TFace = RECORD
      Point: ARRAY [1..4] OF AL_V3D;
    END;
 
 
 
  (* A simple cube. *)
    TCube = CLASS (TObject)
    PRIVATE
      fPosition, fAngle, fRotate: TVector;
      fSize: AL_FIXED;
      fVertexColor: ARRAY [1..4] OF INTEGER;
      fUseZbuff: BOOLEAN;
      fDrawmode: LONGINT;
      fTexture: AL_BITMAPptr;
      fTexWidth, fTexHeight: AL_FIXED;
    PROTECTED
      fFaces: ARRAY [1..6] OF TFace;
      fVisibleFaces: INTEGER; (* Number of faces to draw. *)
 
    (* Draws the faces. *)
      PROCEDURE DrawFaces (aBitmap: AL_BITMAPptr);
    PUBLIC
    (* Creates the cube. *)
      CONSTRUCTOR Create (px, py, pz, aSize: AL_FIXED; aTexture: AL_BITMAPptr);
   VIRTUAL;
    (* Sets a color for the cube. *)
      PROCEDURE SetColor (aR, aG, aB: INTEGER);
    (* Updates cube. *)
      PROCEDURE Update; VIRTUAL;
    (* Draws the cube. *)
      PROCEDURE Draw (aBitmap: AL_BITMAPptr; aMatrix: AL_MATRIX);
 
    (* Cube position. *)
      PROPERTY Pos: TVector READ fPosition;
    (* Cube angle. *)
      PROPERTY Ang: TVector READ fAngle;
    (* Cube size. *)
      PROPERTY Size: AL_FIXED READ fSize;
    (* Polygon draw mode. *)
      PROPERTY DrawMode: LONGINT READ fDrawmode WRITE fDrawmode;
    (* Cube texture.  Note it isn't destroyed by the cube. *)
      PROPERTY Texture: AL_BITMAPptr READ fTexture WRITE fTexture;
    (* To use Z-buffer if available.  Don't use it by default. *)
      PROPERTY UseZbuff: BOOLEAN READ fUseZbuff WRITE fUseZbuff;
    END;
 
 
 
  CONST
  (* A custom polytype.  Used to draw a wired cube. *)
    POLYTYPE_WIRED = -1;
 
 
 
IMPLEMENTATION
 
(* Returns max value. *)
  FUNCTION MyMax (x, y: LONGINT): LONGINT; INLINE;
  BEGIN
    IF x > y THEN RESULT := x ELSE RESULT := y;
  END;
 
 
 
(* Returns min value. *)
  FUNCTION MyMin (x, y: LONGINT): LONGINT; INLINE;
  BEGIN
    IF x < y THEN RESULT := x ELSE RESULT := y;
  END;
 
 
 
(* Returns mid value.  Use only when x < z. *)
  FUNCTION MyClamp (x, y, z: LONGINT): LONGINT; INLINE;
  BEGIN
    RESULT := MyMax (x, MyMin (y, z));
  END;
 
 
 
(*
 * TVector
 *****************************************************************************)
 
  CONSTRUCTOR TVector.Init (ax, ay, az: AL_FIXED);
  BEGIN
    fx := ax;
    fy := ay;
    fz := az;
  END;
 
 
 
(* Adds the given vector. *)
  PROCEDURE TVector.Add (Vector: TVector);
  BEGIN
    fx := (fx + Vector.fx) AND $00FFFFFF;
    fy := (fy + Vector.fy) AND $00FFFFFF;
    fz := (fz + Vector.fz) AND $00FFFFFF;
  END;
 
 
 
(*
 * TCube
 *****************************************************************************)
 
  VAR
  (* Coordinates for each vertex of the cube. *)
    PointCoordinates: ARRAY [0..7] OF TVector;
  (* Dictionary to know the vertex for each face. *)
    VertexIndex: ARRAY [0..23] OF INTEGER = (
    { Each line is a face. }
      2, 1, 0, 3,
      4, 5, 6, 7,
      0, 1, 5, 4,
      2, 3, 7, 6,
      4, 7, 3, 0,
      1, 2, 6, 5
    );
 
 
 
(* Draws faces. *)
  PROCEDURE TCube.DrawFaces (aBitmap: AL_BITMAPptr);
  VAR
    fZbuff, Cnt, Clr: INTEGER;
  BEGIN
    IF UseZbuff THEN
      fZbuff := AL_POLYTYPE_ZBUF
    ELSE
      fZbuff := 0;
    FOR Cnt := 1 TO fVisibleFaces DO
    WITH SELF.fFaces[Cnt] DO
    BEGIN
      IF fDrawmode <> POLYTYPE_WIRED THEN
      BEGIN
   al_quad3d (aBitmap, fDrawmode OR fZbuff, fTexture, @Point[1], @Point[2], @Point[3], @Point[4])
      END
      ELSE BEGIN
   Clr := MyClamp (128, 255 - al_fixtoi (Point[1].z + Point[3].z) DIV 16, 255);
   al_line (aBitmap, Point[1].x SHR 16, Point[1].y SHR 16,
         Point[2].x SHR 16, Point[2].y SHR 16,
         al_palette_color^[Clr]);
   al_line (aBitmap, Point[2].x SHR 16, Point[2].y SHR 16,
         Point[3].x SHR 16, Point[3].y SHR 16,
         al_palette_color^[Clr]);
   al_line (aBitmap, Point[3].x SHR 16, Point[3].y SHR 16,
         Point[4].x SHR 16, Point[4].y SHR 16,
         al_palette_color^[Clr]);
   al_line (aBitmap, Point[4].x SHR 16, Point[4].y SHR 16,
         Point[1].x SHR 16, Point[1].y SHR 16,
         al_palette_color^[Clr]);
      END;
    END;
  END;
 
 
 
(* Constructor. *)
  CONSTRUCTOR TCube.Create (px, py, pz, aSize: AL_FIXED; aTexture: AL_BITMAPptr);
  BEGIN
    fPosition.Init (px, py, pz);
    fAngle.Init (0, 0, 0);
    fRotate.Init (al_ftofix ((Random (32) - 16) / 8),
                 al_ftofix ((Random (32) - 16) / 8),
        al_ftofix ((Random (32) - 16) / 8));
    fSize := aSize;
    fTexture := aTexture;
    fUseZbuff := FALSE;
    IF fTexture <> NIL THEN
    BEGIN
      fDrawmode  := AL_POLYTYPE_PTEX;
      fTexWidth  := al_itofix (fTexture^.w);
      fTexHeight := al_itofix (fTexture^.h);
    END
    ELSE
      fDrawmode := AL_POLYTYPE_FLAT;
    fVertexColor[1] := $000000;
    fVertexColor[2] := $7F0000;
    fVertexColor[3] := $FF0000;
    fVertexColor[4] := $7F0000;
  END;
 
 
 
(* Sets a color for the cube. *)
  PROCEDURE TCube.SetColor (aR, aG, aB: INTEGER);
  VAR
    tR, tG, tB: INTEGER;
  BEGIN
    tR := aR SHR 1;
    tG := aG SHR 1;
    tB := aB SHR 1;
  { Vertex 1 is still black. }
    fVertexColor[2] := (tR SHL 16) OR (tG SHL 8) OR tB;
    fVertexColor[3] := (aR SHL 16) OR (aG SHL 8) OR aB;
    fVertexColor[4] := fVertexColor[2];
  END;
 
 
 
(* Updates the cube. *)
  PROCEDURE TCube.Update;
  BEGIN
    fAngle.Add (fRotate);
  END;
 
 
 
(* Draws the cube.
 
   This is very inefficient and doesn't draw the masked and transparent modes
   in the right order. *)
  PROCEDURE TCube.Draw (aBitmap: AL_BITMAPptr; aMatrix: AL_MATRIX);
  VAR
    Cnt, v1, v2, v3, v4, Face: LONGINT;
    z1, z2: AL_FIXED;
    Matrix: AL_MATRIX;
    Vertex: ARRAY [0..7] OF AL_V3D;
 
  (* Helper procedure to define a face. *)
    PROCEDURE SetFace (Ndx: INTEGER); INLINE;
    VAR
      Clr: INTEGER;
    BEGIN
      WITH fFaces[Ndx] DO
      BEGIN
      { Vertices. }
   Point[1] := Vertex[v1];
   Point[2] := Vertex[v2];
   Point[3] := Vertex[v3];
   Point[4] := Vertex[v4];
      { Texturization. }
   IF (fDrawmode >= AL_POLYTYPE_ATEX) AND (fTexture <> NIL) THEN
   BEGIN
     Point[1].u :=         0; Point[1].v := fTexHeight;
     Point[2].u :=         0; Point[2].v :=          0;
     Point[3].u := fTexWidth; Point[3].v :=          0;
     Point[4].u := fTexWidth; Point[4].v := fTexHeight;
   END;
   CASE fDrawmode OF
   AL_POLYTYPE_FLAT:
     BEGIN
       Clr := MyClamp (128, 255 - al_fixtoi (Point[1].z + Point[3].z) DIV 16, 255);
       Point[1].c := al_palette_color^[Clr];
     END;
   AL_POLYTYPE_GCOL:
     BEGIN
       Point[1].c := al_palette_color^[$D0];
       Point[2].c := al_palette_color^[$80];
       Point[3].c := al_palette_color^[$B0];
       Point[4].c := al_palette_color^[$FF];
     END;
   AL_POLYTYPE_GRGB:
     BEGIN
       Point[1].c := fVertexColor[1];
       Point[2].c := fVertexColor[2];
       Point[3].c := fVertexColor[3];
       Point[4].c := fVertexColor[4];
     END;
     ELSE BEGIN
       Point[1].c := MyClamp (0, 255 - al_fixtoi (Point[1].z) DIV 4, 255);
       Point[2].c := MyClamp (0, 255 - al_fixtoi (Point[2].z) DIV 4, 255);
       Point[3].c := MyClamp (0, 255 - al_fixtoi (Point[3].z) DIV 4, 255);
       Point[4].c := MyClamp (0, 255 - al_fixtoi (Point[4].z) DIV 4, 255);
     END;
   END;
      END;
    END;
 
  BEGIN
  { Create the transformation matrix. }
    al_get_transformation_matrix (Matrix, fSize, fAngle.x, fAngle.y, fAngle.z,
              fPosition.x, fPosition.y, fPosition.z);
    al_matrix_mul (Matrix, aMatrix, Matrix);
  { vertices of the cube }
    FOR Cnt := 0 TO 7 DO
    BEGIN
    { "Move" and project each vertex. }
      al_apply_matrix (Matrix,
   PointCoordinates[Cnt].x, PointCoordinates[Cnt].y, PointCoordinates[Cnt].z,
   Vertex[Cnt].x, Vertex[Cnt].y, Vertex[Cnt].z);
      al_persp_project (Vertex[Cnt].x, Vertex[Cnt].y, Vertex[Cnt].z,
         Vertex[Cnt].x, Vertex[Cnt].y);
    END;
  { faces of the cube. }
    fVisibleFaces := 0;
    FOR Cnt := 0 TO 5 DO
    BEGIN
      v1 := Cnt * 4;
      v2 := VertexIndex[v1 + 1];
      v3 := VertexIndex[v1 + 2];
      v4 := VertexIndex[v1 + 3];
      v1 := VertexIndex[v1];
      IF ((AL_POLYTYPE_FLAT <= fDrawmode) AND (fDrawmode <= AL_POLYTYPE_PTEX))
      OR (fDrawmode = AL_POLYTYPE_ATEX_LIT)
      OR (fDrawmode = AL_POLYTYPE_PTEX_LIT)
      THEN BEGIN
      { Only faces with positive normals are visible. }
   IF al_polygon_z_normal_sign (Vertex[v1], Vertex[v2], Vertex[v3]) < 0
        THEN
     CONTINUE;
      END;
    { Insert the face in the face list. }
      INC (fVisibleFaces);
    { If list is empty. }
      IF fVisibleFaces = 1 THEN
   SetFace (1)
      ELSE IF fVisibleFaces = 2 THEN
      BEGIN
   z1 := Vertex[v1].z + Vertex[v2].z + Vertex[v3].z + Vertex[v4].z;
   WITH fFaces[1] DO
     z2 := Point[1].z + Point[2].z + Point[3].z + Point[4].z;
   IF z1 > z2 THEN
   BEGIN
     fFaces[2] := fFaces[1];
     SetFace (1);
   END
   ELSE
     SetFace (2);
      END
      ELSE BEGIN
   z1 := Vertex[v1].z + Vertex[v2].z + Vertex[v3].z + Vertex[v4].z;
   Face := fVisibleFaces - 1;
   REPEAT
     WITH fFaces[Face] DO
       z2 := Point[1].z + Point[2].z + Point[3].z + Point[4].z;
     IF z1 > z2 THEN
       fFaces[Face + 1] := fFaces[Face]
     ELSE
       BREAK;
     DEC (FACE);
   UNTIL (Face = 0);
   SetFace (Face + 1);
      END;
    END;
  { Draw it. }
    SELF.DrawFaces (aBitmap)
  END;
 
 
 
CONST
  One = 1 SHL 16; { See al_itofix documentation. }
INITIALIZATION
{ Initialize cube coordinates. }
  PointCoordinates[0].Init (-One, -One, -One);
  PointCoordinates[1].Init (-One,  One, -One);
  PointCoordinates[2].Init ( One,  One, -One);
  PointCoordinates[3].Init ( One, -One, -One);
  PointCoordinates[4].Init (-One, -One,  One);
  PointCoordinates[5].Init (-One,  One,  One);
  PointCoordinates[6].Init ( One,  One,  One);
  PointCoordinates[7].Init ( One, -One,  One)
FINALIZATION
  ;
END.
 
 

[theo]

Hast du da ein Häkchen drin?

[Anonymus]

@theo:

Nein, in der Lazarus IDE nicht. Meine Allegro Bilbliothek liegt in f:\pp\projects\allegro\lib, die Beispiele in f:\pp\projects\allegro\examples und für Lazarus in f:\pp\projects\allegro\examples\lazarus

Unter Projektoptionen->Pfade habe ich unter "andere Quelldateien den Pfad f:\pp\projects\allegro\lib eingetragen, damit die Unit allegro gefunden werde.

Dennoch erhalte ich die Fehlermeldung Unit Allegro nicht gefunden.

Deshalb habe ich dann mit der Textmode IDE fp.exe mein Glück versucht. Dort aber erhalte ich die Fehlermeldung "constructor name must be init".

In den Compileroptionen dieser alten IDE finde ich aber überhaupt keine Option für "constructor name must be init" und die fpc.cfg hat die Option -Ss mit # in dieser Weise auskommentiert:

#-Ss

Ich weiß echt nicht mehr weiter. So macht Programmieren keinen Spaß.

Was für Optionen kann ich noch einstellen. Die oben verlinkte Doku gibt leider nichts her, die zeigt nur alle möglichen Optionen, aber welche ich hier nun einstellen muss, zeigt sie mir nicht.

Ich habe mich tatsächlich gemäß meinem Usernamen dem Anonymus Netzwerk angeschlossen, denn so eine Geheimhaltung hier ist dem OpenSource Gedanken unwürdig.

Warum nicht einfach paasende Default Einstellungen, damit auch jemand das Zeug nutzen kann der noch nie programmiert hat??????

Warum muss der Konstruktor unbedingt INIT heißen, in den KLssen heißt er doch schon lange nicht mehr so, sondern CREATE.

Was soll diese Bevormundung der Programmierer?

Lasst doch die Progammierer mit weniger restriktiver ´"Sicherheit" die hier keine ist, die Programmierer ihre eigenen Erfahrungen machen, wie ein Kind, das sich auch wohler fühlt, wenn es sich auch auf die Gefahr von Unfällen überall frei bewegen kann, statt wegen falsch verstandener Sorge diesm Kind alles zu verbieten wo irgendwas passieren könnte. Am Viehweidezaun kann ein Kind ganz gefahrlos lernen, dass man elektrische Anlagen nicht berühren darf. Wenn das Kind den Weidzaun anfasst, lernt es aus eigener Erfahrung. wenn dieses KInd aber gar nicht erst an den Weidezaun gelassen wird, weil der ja soooo gefährlich ist, fühlt sich das Kind bevormundet. Gegen solche Bevormundung tete ich ganz entschieden ein.

Im Zweifelsfall FREIHEIT VOR SICHERHEIT.

Die gilt auch in der Programmierung. Ich merke dann schon, wenn das Programmkonzept falsch ist.

Was also muss ich hier tun. Damit der Konstruktorname nicht vorgeschrieben wird.

Ich verwende ansonsten (in der IDE eingestellt) Mode OBJFPC! Hatte gedacht, dass da wegen der KLassen und dem dortigen Konstruktornamen CREATE das Problem gelöst sei. Ist es aber nicht.

Die Übersetzung mit Lazarus verwendet FPC 2.6.4 und die mit der Textmode IDE verwendet Version FPC 3.0.0

[Anonymus]

Kann hier leider keine Dateien hochladen, aber den Link zur Allegro kann ich hier einfügen:

http://allegro-pas.sourceforge.net/downloads.php

Dort gibt es auch die allegro.pas-4.4.5-src-pas.zip

Die will ich mit Lazarus übersetzen. Da werden aber die Units nicht gefunden, obwohl der Quellpfad unter Projektoptionen --> Pfade --> andere Quellcodes korrekt eingetragen ist. Ich verwende Lazarus 1.2.6 mit FPC 2.6.4

Mit Version 3.0 erhalte ich die Fehlermeldung die den Threadtitel ziert!

Es muss doch eine Chance geben, diese Allegro Units zu übersetzen.

[theo]

Immer ruhig bleiben.

Ich habe es mal runtergeladen, obwohl es mich eigentlich gar nicht interessiert.
Habe das Lazarus Beispiel in examples/lazarus geöffnet und bei "Andere Units..." "../../lib" eingetragen und schon kompiliert es.

Bist du sicher, dass du die liballeg installiert hast? http://liballeg.org/

[Anonymus]

Immer ruhig bleiben.

Äußerst schwierig bei solcher sinnlo9sen zeiraubenden Frickelei für eine sinple Übersetzung.

Ich habe es mal runtergeladen, obwohl es mich eigentlich gar nicht interessiert.

Danke!

Habe das Lazarus Beispiel in examples/lazarus geöffnet und bei "Andere Units..." "../../lib" eingetragen und schon kompiliert es.

Welcher Trick ist da dabei???

Bist du sicher, dass du die liballeg installiert hast? http://liballeg.org/

Bin ich nicht, ich habe die Pascal Version runter geladen in Version 4.4.5, wie schon geschrieben. Die liballeg auf der oben von Dir genannten Webseite ist die C/C++ Version.

Warum geht nicht einfach die Pascal Version?

In den Pascal Quelltexten in [Laufwerk]:\pp\projects\allegro\lib\ ist doch eine alleg44.dll

So dachte ich, ich müsse in Lazarus nur den Biliothekspfad mit angeben, in der Eingabezeile für den Pfad für Bibliotheken. Offenbart ist das also nicht genug.

In welchem Pfad wird die Dll denn verlangt.

Wie war gleich noch mal das Kommando für die Installation von Dlls?

Muss ich da wirklich Regsvr verwenden.

Hab das soeben probiert und da erhalte ich die Meldung:

regsvr32 [Laufwerk]:\pp\projects\allegro\lib\alleg44.dll wurde geladen, aber DllRegisterSvr wurde nicht gefunden, Dll kann nicht registriert werden.

Ich habe gedacht, die Dll ist ja da, hatte die alle 44.dll für die lib gehalten, die den Code enthält. Der Name allegXXX hat mich dazu verführt, anzunehmen, diese dll enthalten den Binärcode.

Welche dll brauche ich denn dann, damit das Übersetzen klappt? Da muss ja offenbar eine wichtige .dll fehlen????

[theo]

> Welcher Trick ist da dabei???
Keine Ahnung.

> Welche dll brauche ich denn dann, damit das Übersetzen klappt? Da muss ja offenbar eine wichtige .dll fehlen????
Es geht nicht um das übersetzten, das müsste so klappen, aber wahrscheinlich kann er nicht linken, wenn die DLL nicht auffindbar ist.
Schmeiß die DLL einfach mal nach Windows/System oder so. K.A. bin auf Linux.

[Thandor]

Eigentlich müsste es Reichen, wenn die DLL im Hauptverzeichnis deines Programms liegt. Also da, wo dann die *.exe entsteght und deine *.lpi-Datei liegt.
Linken kann er auch ohne DLL die wird etrst beim Ausführen benötigt, hattte ich schon oft, Programm compiliert, ausgeführt -> "Kann ...dll nicht finden" -> dll ins Programmverzeichnins geschoben -> läuft.
Jedoch habe ich noch nie mit alegro gearbeitet.

Ansonsten kannst du mal versuchen deine DLL's im "C:\Windows\System32" zu koppieren.