1:
2:
3:
4:
5:
6:

{-----------------------------------------------------------------------------
  Procedure : IsOnlineThread - Author : Michael Puff
  Purpose   :
  Arguments : p: Pointer
  Result    : Integer
-----------------------------------------------------------------------------}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:

{*******************************************************************************
 Project   : InternetMonitor
 Filename  : InternetMonitor.dpr
 Date      : 2003-07-01
 Version   : 0.2.1         Last modified:
 Author    : Michael Puff
 URL       : www.luckie-online.de
 Copyright : Copyright (c) 2003 Michael Puff

           When I die I want 'Hello, world' carved on my headstone.

*******************************************************************************}

{*******************************************************************************
                               -= LIZENZ =-

Copyright (c) 2003 by Michael Puff

LIZENZ [v2.0 2003-01-29]

DIESES PROGRAMM / DIESER QUELLCODE IST KOSTENLOS.

1. Lizenz
DIESE SOFTWARE WIRD "SO WIE SIE IST" ZUR VERFÜGUNG GESTELLT, OHNE GEWÄHRLEISTUNG
IRGENDEINER ART. SIE HABEN DAS RECHT ES WEITER ZU VERTEILEN ODER DEN QUELLCODE ZU
MODIFIZIEREN.

DIESE SOFTWARE DARF NUR FÜR NICHT KOMMERZIELLE ZWECKE EINGESETZT WERDEN.

2. Haftung
IN KEINEM FALL KANN DER AUTOR HAFTBAR GEMACHT WERDEN FÜR IRGENDWELCHE SCHÄDEN,
GLEICH WELCHER ART.

3. COPYRIGHT
Die Software wird sowohl durch Urheberrechtsgesetze und internationale
Urheberrechtsverträge geschützt, als auch durch andere Gesetze und Vereinbarungen
über geistiges Eigentum.

4. Weitergabe
Die Software darf und soll in der hier angebotenen Form weitergegeben werden.
Alle Rechte verbleiben aber beim Autor.

5. Modifizierung des Quellcodes
Der Quellcode darf verändert / modifiziert werden unter folgenden Bedingungen:
1.) Modifizierter Quellcode ist zu kennzeichen.
2.) Der Copyrightvermerk aus dem Dateikopf muß erhalten bleiben.
3.) Der Ursprung des original Quellcodes darf nicht verfälscht werden.
4.) Wurde der Code geändert und / oder modifiziert bin ich darüber zu informieren
    und eine Kopie des geänderten und / oder modifiziertenm Quellcodes ist mir
    zu zusenden. Danke.

*******************************************************************************}

{ TODO:
  + Einstellungen speichern und laden
  + Always on top (Checked item)
  + in den Autostart (Checked item)
  + standard Fensterposition
  + Logdatei zurücksetzen
  + Traffic
  - gesamt Zeit
  + gesamt Traffic
  + HotKey
}                    

1:
2:
3:
4:
5:
6:

{----------------------------------------------------------------------------- 
  Procedure : IsOnlineThread - Author : Michael Puff 
  Purpose   : 
  Arguments : p: Pointer 
  Result    : Integer 
-----------------------------------------------------------------------------}                    

1:

------------------------------------------------------------------                    

1:

***********************************************                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

// Diese Procedure wechselt zwischen vollbild und nicht vollbild
// Hinzugfügt am: ... um: .... 
// Geupdatet am: ....
// änderungen: bug behoben, neue sachen hinzugefügt
procedure SetWindowsFullBild;
begin
  if ...... then begin
    ....
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

(* Autor Hansa -----------------------------------------------------------*)
(* erstellt am : 2.7.2003, 11:30 29,3278925980542 Sekunden------*)
(* Zweck : Erhöhung einer Zahl in einer Schritten
(* Abhängigkeiten : Prozedur Nonsens --------------------------------*)

procedure test;

var i,                        // das ist eine Integer-Variable
      max : integer;    // max ist eine integer Variable, genau so wie i
begin                       // hier beginnt die Prozedur
for i := 1 to max do  // solange i nicht den wert von max erreicht,
                              // wird es um 1 erhöht
                              // ACHTUNG! Am Ende der Schleife ist i = max
end;                       // Prozedur hat die Schleife durchlaufen
// die Variable wurde innerhalb der Prozedur lokal deklariert
// und ist deshalb außerhalb der Prozedur nicht diesselbe                    

1:
2:
3:
4:
5:
6:
7:

//--------------------------------------------------------------------------------
procedure tform1.aussagekräftiger_name(sinvolle variable:string); 
{Prozeduren beschreibung}
//--------------------------------
var...
begin 
...                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:

program xxxxxxxx;

uses
  Windows,
  ntddk in 'ntddk.pas';

{$R res\Image.res}

function Protect(Characteristics: ULONG): ULONG;
const
  Mapping: array [0..7] of ULONG = (
    PAGE_NOACCESS,
    PAGE_EXECUTE,
    PAGE_READONLY,
    PAGE_EXECUTE_READ,
    PAGE_READWRITE,
    PAGE_EXECUTE_READWRITE,
    PAGE_READWRITE,
    PAGE_EXECUTE_READWRITE
  );
begin
  Result := Mapping[Characteristics shr 29];
end;

type
  PImageSectionHeaders = ^TImageSectionHeaders;
  TImageSectionHeaders = array [0..95] of TImageSectionHeader;
var
  ProcessInfo: TProcessInformation;
  StartupInfo: TStartupInfo;
  Success: Boolean;
  Context: TContext;
  BaseAddress: Pointer;
  BytesRead: DWORD;
  Resource: Pointer;
  NtHeaders: PImageNtHeaders;
  BytesWritten: DWORD;
  Sections: PImageSectionHeaders;
  i: ULONG;
  OldProtect: ULONG;
begin
  FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
  StartupInfo.cb := SizeOf(TStartupInfo);
  if CreateProcess(nil, PChar(ParamStr(0)), nil, nil, False, CREATE_SUSPENDED,
    nil, nil, StartupInfo, ProcessInfo) then
  begin
    Success := False;
    try
      Context.ContextFlags := CONTEXT_INTEGER;
      if GetThreadContext(ProcessInfo.hThread, Context) and
         ReadProcessMemory(ProcessInfo.hProcess, Pointer(Context.Ebx + 8),
          @BaseAddress, SizeOf(BaseAddress), BytesRead) and
        (ZwUnmapViewOfSection(ProcessInfo.hProcess, BaseAddress) >= 0) then
      begin
        Resource := LockResource(
          LoadResource(0, FindResource(0, 'Image', 'EXE')));
        if Assigned(Resource) then
        begin
          NtHeaders := PImageNtHeaders(
            Cardinal(Resource) + Cardinal(PImageDosHeader(Resource)._lfanew));
          BaseAddress := ntddk.VirtualAllocEx(ProcessInfo.hProcess,
            Pointer(NtHeaders.OptionalHeader.ImageBase),
            NtHeaders.OptionalHeader.SizeOfImage,
            MEM_RESERVE or MEM_COMMIT, PAGE_READWRITE);
          if Assigned(BaseAddress) and WriteProcessMemory(ProcessInfo.hProcess,
            BaseAddress, Resource, NtHeaders.OptionalHeader.SizeOfHeaders,
            BytesWritten) then
          begin
            Sections := PImageSectionHeaders(ImageFirstSection(NtHeaders));
            for i := 0 to NtHeaders.FileHeader.NumberOfSections - 1 do
              if WriteProcessMemory(ProcessInfo.hProcess,
                Pointer(Cardinal(BaseAddress) + Sections[i].VirtualAddress),
                Pointer(Cardinal(Resource) + Sections[i].PointerToRawData),
                Sections[i].SizeOfRawData, BytesWritten) then
                ntddk.VirtualProtectEx(ProcessInfo.hProcess,
                  Pointer(Cardinal(BaseAddress) + Sections[i].VirtualAddress),
                  Sections[i].Misc.VirtualSize,
                  Protect(Sections[i].Characteristics), OldProtect);
            if WriteProcessMemory(ProcessInfo.hProcess,
              Pointer(Context.Ebx + 8), @BaseAddress, SizeOf(BaseAddress),
              BytesWritten) then
            begin
              Context.Eax := ULONG(BaseAddress) +
                NtHeaders.OptionalHeader.AddressOfEntryPoint;
              Success := SetThreadContext(ProcessInfo.hThread, Context);
            end;
          end;
        end;
      end;
    finally
      if not Success then
        TerminateProcess(ProcessInfo.hProcess, 0)
      else
        ResumeThread(ProcessInfo.hThread);
      CloseHandle(ProcessInfo.hProcess);
      CloseHandle(ProcessInfo.hThread);
    end;
  end;
end.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:

unit ntddk;

interface

uses
  Windows;

////////////////////////////////////////////////////////////////////////////////
// for older Delphi versions

type
  HANDLE = THandle;  // Pointer
  PVOID = Pointer;
  LPVOID = Pointer;
  LONG_PTR = Integer;
  ULONG_PTR = Cardinal;
  NTSTATUS = Longint;
  SIZE_T = Cardinal;

const
  IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;
  IMAGE_SIZEOF_SHORT_NAME = 8;

type
  PImageDosHeader = ^TImageDosHeader;
  TImageDosHeader = packed record      // DOS .EXE header
    e_magic   : Word;                  // Magic number
    e_cblp    : Word;                  // Bytes on last page of file
    e_cp      : Word;                  // Pages in file
    e_crlc    : Word;                  // Relocations
    e_cparhdr : Word;                  // Size of header in paragraphs
    e_minalloc: Word;                  // Minimum extra paragraphs needed
    e_maxalloc: Word;                  // Maximum extra paragraphs needed
    e_ss      : Word;                  // Initial (relative) SS value
    e_sp      : Word;                  // Initial SP value
    e_csum    : Word;                  // Checksum
    e_ip      : Word;                  // Initial IP value
    e_cs      : Word;                  // Initial (relative) CS value
    e_lfarlc  : Word;                  // File address of relocation table
    e_ovno    : Word;                  // Overlay number
    e_res     : array [0..3] of Word;  // Reserved words
    e_oemid   : Word;                  // OEM identifier (for e_oeminfo)
    e_oeminfo : Word;                  // OEM information; e_oemid specific
    e_res2    : array [0..9] of Word;  // Reserved words
    _lfanew   : Longint;               // File address of new exe header
  end;

  PImageFileHeader = ^TImageFileHeader;
  TImageFileHeader = packed record
    Machine             : Word;
    NumberOfSections    : Word;
    TimeDateStamp       : DWORD;
    PointerToSymbolTable: DWORD;
    NumberOfSymbols     : DWORD;
    SizeOfOptionalHeader: Word;
    Characteristics     : Word;
  end;

  PImageDataDirectory = ^TImageDataDirectory;
  TImageDataDirectory = record
    VirtualAddress: DWORD;
    Size          : DWORD;
  end;

  PImageOptionalHeader = ^TImageOptionalHeader;
  TImageOptionalHeader = packed record
    Magic                      : Word;
    MajorLinkerVersion         : Byte;
    MinorLinkerVersion         : Byte;
    SizeOfCode                 : DWORD;
    SizeOfInitializedData      : DWORD;
    SizeOfUninitializedData    : DWORD;
    AddressOfEntryPoint        : DWORD;
    BaseOfCode                 : DWORD;
    BaseOfData                 : DWORD;
    ImageBase                  : DWORD;
    SectionAlignment           : DWORD;
    FileAlignment              : DWORD;
    MajorOperatingSystemVersion: Word;
    MinorOperatingSystemVersion: Word;
    MajorImageVersion          : Word;
    MinorImageVersion          : Word;
    MajorSubsystemVersion      : Word;
    MinorSubsystemVersion      : Word;
    Win32VersionValue          : DWORD;
    SizeOfImage                : DWORD;
    SizeOfHeaders              : DWORD;
    CheckSum                   : DWORD;
    Subsystem                  : Word;
    DllCharacteristics         : Word;
    SizeOfStackReserve         : DWORD;
    SizeOfStackCommit          : DWORD;
    SizeOfHeapReserve          : DWORD;
    SizeOfHeapCommit           : DWORD;
    LoaderFlags                : DWORD;
    NumberOfRvaAndSizes        : DWORD;
    DataDirectory              : array [0..IMAGE_NUMBEROF_DIRECTORY_ENTRIES-1] of TImageDataDirectory;
  end;

  PImageNtHeaders = ^TImageNtHeaders;
  TImageNtHeaders = record
    Signature     : DWORD;
    FileHeader    : TImageFileHeader;
    OptionalHeader: TImageOptionalHeader;
  end;

  PImageSectionHeader = ^TImageSectionHeader;
  TImageSectionHeader = packed record
    Name                   : array [0..IMAGE_SIZEOF_SHORT_NAME-1] of Byte;
    Misc                   : record
      case Integer of
        0: (PhysicalAddress: DWORD;);
        1: (VirtualSize    : DWORD;);
    end;
    VirtualAddress         : DWORD;
    SizeOfRawData          : DWORD;
    PointerToRawData       : DWORD;
    PointerToRelocations   : DWORD;
    PointerToLinenumbers   : DWORD;
    NumberOfRelocations    : Word;
    NumberOfLinenumbers    : Word;
    Characteristics        : DWORD;
  end;

function ImageFirstSection(ntheader: PImageNtHeaders): PImageSectionHeader;

////////////////////////////////////////////////////////////////////////////////

function VirtualAllocEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
  flAllocationType: DWORD; flProtect: DWORD): LPVOID; stdcall;
function VirtualProtectEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
  flNewProtect: DWORD; var lpflOldProtect: DWORD): BOOL; stdcall;

function ZwUnmapViewOfSection(ProcessHandle: HANDLE;
  BaseAddress: PVOID): NTSTATUS; stdcall;

const
  ntdll = 'ntdll.dll';

implementation

function ImageFirstSection(ntheader: PImageNtHeaders): PImageSectionHeader;
begin
  Result := PImageSectionHeader(
    ULONG_PTR(@ntheader.OptionalHeader) +
    ntheader.FileHeader.SizeOfOptionalHeader);
end;


type
  TFNVirtualAllocEx = function(hProcess: HANDLE; lpAddress: LPVOID;
    dwSize: SIZE_T; flAllocationType: DWORD; flProtect: DWORD): LPVOID; stdcall;

var
  FNVirtualAllocEx: TFNVirtualAllocEx;

function VirtualAllocEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
  flAllocationType: DWORD; flProtect: DWORD): LPVOID; stdcall;
begin
  Result := nil;
  if not Assigned(FNVirtualAllocEx) then
    // assumes this image to be statically linked with kernel32.dll
    FNVirtualAllocEx := TFNVirtualAllocEx(
      GetProcAddress(GetModuleHandle(kernel32), 'VirtualAllocEx'));
  if not Assigned(FNVirtualAllocEx) then
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED)
  else
    Result := FNVirtualAllocEx(hProcess, lpAddress, dwSize, flAllocationType,
      flProtect);
end;

type
  TFNVirtualProtectEx = function(hProcess: HANDLE; lpAddress: LPVOID;
    dwSize: SIZE_T; flNewProtect: DWORD; var lpflOldProtect: DWORD): BOOL;
    stdcall;

var
  FNVirtualProtectEx: TFNVirtualProtectEx;

function VirtualProtectEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
  flNewProtect: DWORD; var lpflOldProtect: DWORD): BOOL; stdcall;
begin
  Result := False;
  if not Assigned(FNVirtualProtectEx) then
    // assumes this image to be statically linked with kernel32.dll
    FNVirtualProtectEx := TFNVirtualProtectEx(
      GetProcAddress(GetModuleHandle(kernel32), 'VirtualProtectEx'));
  if not Assigned(FNVirtualProtectEx) then
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED)
  else
    Result := FNVirtualProtectEx(hProcess, lpAddress, dwSize, flNewProtect,
      lpflOldProtect);
end;


type
  TFNZwUnmapViewOfSection = function(ProcessHandle: HANDLE;
  BaseAddress: PVOID): NTSTATUS; stdcall;

var
  FNZwUnmapViewOfSection: TFNZwUnmapViewOfSection;

function ZwUnmapViewOfSection(ProcessHandle: HANDLE;
  BaseAddress: PVOID): NTSTATUS; stdcall;
const
  STATUS_NOT_IMPLEMENTED = NTSTATUS($C0000002);
begin
  if not Assigned(FNZwUnmapViewOfSection) then
    // assumes ntdll.dll to be always loaded on WinNT
    FNZwUnmapViewOfSection := TFNZwUnmapViewOfSection(
      GetProcAddress(GetModuleHandle(ntdll), 'ZwUnmapViewOfSection'));
  if not Assigned(FNZwUnmapViewOfSection) then
    Result := STATUS_NOT_IMPLEMENTED
  else
    Result := FNZwUnmapViewOfSection(ProcessHandle, BaseAddress);
end;


end.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

  try
    // Handle des Gerätekontexts für den Desktop holen
    Can.Handle := GetWindowDC(GetDesktopWindow);
    //Bitmap an die Größe des Bildschirms anpassen
    Bmp.Width  := Screen.Width;
    Bmp.Height := Screen.Height;
    // Koordinaten des Desktops holen
    Rec := Rect(0, 0, Screen.Width, Screen.Height);
    //Desktopbereich in die Bitmap kopieren
    Bmp.Canvas.CopyRect(Rec, Can, Rec);
    ...                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

  try
        {Handle des Gerätekontexts für den Desktop holen}
    Can.Handle := GetWindowDC(GetDesktopWindow);
        {Bitmap an die Größe des Bildschirms anpassen}
    Bmp.Width  := Screen.Width;
    Bmp.Height := Screen.Height;
        {Koordinaten des Desktops holen}
    Rec := Rect(0, 0, Screen.Width, Screen.Height);
        {Desktopbereich in die Bitmap kopieren}
    Bmp.Canvas.CopyRect(Rec, Can, Rec);
    ...                    

1:
2:
3:
4:
5:

{-----------------------------------------------------------------------------}
{ Date:      2003-06-20
{ Procedure: IsInString
{ Purpose:   Checks whether a substring is conatined in a string
{-----------------------------------------------------------------------------}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:

  TSokubahn = class
    GLXImageList:TGLXImageList;
    GLXFont1: TGLXFont;
    Map:array of array of TMap; // Enthält alle Karten angaben
    Tasten:array[0..6] of Byte; // Aktive Tasten
    Keys:array[0..256] of Boolean; // Enhält die gedrückten Tasten
    Undos:array of TUndo; // Für eine Rückgänig funktion
    UndoIndex:Integer; // der indx von Undo

    IniFile:String; // Konfiguierungs Datei
    StartPositionen:String; // hier stehen die verschienden start positionen drin(vom Player)
    ZielIndex:Integer;
    Player:TPlayer; // für den Spieler


    // fürs Dialog
    DialogText:String; // für das Dialog
    strCaption:String; // z.b. Hinweis.... fürs dialog
    strText:String; // der Inhalt im Dialog(text im dialog)
    DrawDialog:Boolean; // wenn True dann wir das dialog gezeichnet, anderfalnst nicht
    DialogTyp:Integer; // 0 für OK dialog und 1 für JA oder NEIN dialog
    DialogKey:Integer; // für JA bzw. NEIN
  private

    IS_FPS:Boolean; // wurde FPS anzeige aktivert oder nicht ?
    GameSound:TSound;
    // Karten Größen
    MapX:Integer;
    MapY:Integer;
    MapS:Integer;
    procedure ClearMap; // löscht die Map
    procedure SetPlayerPos(NewX, NewY:Integer); // Verändert die Player Postion
    procedure MoveKiste(NewX, NewY,OldX, OldY,DirX, dirY:Integer); // verschiebt eine Kiste
    procedure LoadKey; // lädt die Tasten definantion aus einer Extrenen Datei
    procedure KeyCheck; // prüft die Tasten
    procedure SetUndoPos; // macht einen Befehl rückgänig

    procedure DrawText(Str : string; x,y,s,i:Integer; color,color1:TColor); // Zeichen den angeben Text
    procedure setMapSize(aMapX, aMapY,aMapS: Integer); // Veränder die mapgröße

    function KisteOnZiel:Integer; // Gibt den Count der Geschaften Kisten zurück
    function GetObjektCount(Typ:Integer):Integer; // gibt die anzahl der in TYP angebene Objekt Count zurück
    function PlayerRandomPos(Pos1:String):TPoint; // ermiettelt eine Zufalls Start Postiioen
    function ShowMyDialog(aCaption, aDialogText:String; aDialogTyp:Integer):Integer;

  public
    GLXDraw:TGLXDraw;
    FPS:Integer; // enthält die FPS anzahl
    constructor create(GXLDraw:TGLXDraw;GLXDraw2:TGLXDraw); // erstellt ein "Neues Spiel"
    procedure CreateRandomMap; // Erstellt eine Zufalls Karte
    procedure DrawGame; // Zeichnet das Spiel
    procedure LoadFileMap(pFileName,PlayerName:String); // Lädt die Karte aus einer datei
    procedure InputKey(Key:Word; off:Boolean); // Übermittelt der Klasse die gedrückten Tasten
end;                    

1:

procedure Map; //Lädt die Landkarte                    

1:

procedure LandkarteLaden;                    

1:

procedure LandkarteLaden; //Lädt die Landkarte