mixster

program ScaRPG_Map_Editor;
{
    ScaRPG Map Editor
    A tool that allows anyone to create an intricate map
    Author for used procedures and functions is 'mixster' unless otherwise stated
    Extremely heavy commenting required. If distributed without, kill whoever did it
    Designed primarily for adaptation. If you don't like it, change it - that's why heavy commenting required
}
type
  TSheet = record // Record of information on a sheet e.g. tilesheet; spritesheet.
    b: Integer; // Bitmap holder for the sheet
    h: Integer; // Height in tiles of sheet
    w: Integer; // Width in tiles of sheet
  end;

  TMap = record //Record of information for the entire map
    layers: array of T2DPointArray; // 3D integer array with the information for drawing the tiles. The TPoint holds the actual top left corner on the tilesheet
    attribs: T2DIntArray; // layer that holds attributes for a tile
    width, height, depth, sprite: Integer; // Width, height and depth for dimensions; sprite is layer where sprites are drawn on top of
    vis: TIntegerArray; // Holds bitmap for visible layers
    mC: TPoint; // Holds the top left position so we know which bits to draw
    saved: Boolean; // Holds whether or not the map is currently saved
    fp: string; // Holds filepath of where it is currently saved
  end;

var
  maps: array of TMap; // Holds the currently open maps
  cm: Integer; // Holds the index of currently visible map
  fMain: TForm; // Main form for editing or creating a map
  iMain: TImage; // Main visible component for displaying the map
  iSheet: TImage; // Visible component for displaying the tilesheet
  tcMain: TTabControl; // Main tab bit for holding the maps
  sbHorz, sbVert: TScrollBar; // Main scrollbars for scrolling map movement
  sbSheet: TScrollBox; // Scrollbox that the tilesheet goes into
  bitDeb: string; // Holds the string that has the info about all the bitmaps currently in use
  bitLoc: TStringArray; // Holds the location from where the relating bitmap was created
  dr: TPoint; // Holds the number of tiles to draw in regards to .x = width .y = height
  shTile: TSheet; // See TSheet. shTile for tilesheet
  dT: TPoint; // Holds the top left of the tile which is to be drawn upon clicking

procedure Crash(str: string); // Simple procedure to allow the script to crash easily from a single line due to laziness
begin
  Writeln('Crashing: ' + str); // Print the crashing reason
  TerminateScript; // Stop the script running
end;

function MBitmap(w, h: Integer; str, from: string): Integer; // Creation half of the memory leak debugging
begin
  Result := BitmapFromString(w, h, str); // Start by actually making the bitmap since we need the reference number
  while (Length(bitDeb) < Result + 1) do // While the string is too short
    bitDeb := bitDeb + '2'; // Increase the length of the string by adding a 2 which signifies bitmap created by alternate means
  bitDeb[Result + 1] := '1'; // Set the index to 1 to signify in use - string's start at 1 not 0, hence the + 1
  SetLength(bitLoc, Length(bitDeb) + 1); // This is 1 longer than the string due to it starting on 0 and me wanting them in line
  bitLoc[Result + 1] := from; // Set where the bitmap was created from
  //Writeln('Created bitmap number ' + IntToStr(Result + 1) + ' in procedure ''' + from + ''''); // Results in extremely large debug box
end;


procedure MFreeBitmap(b: Integer); // Destroying half of the memory leak debugging
begin
  FreeBitmap(b); // Start by freeing it as the reference remains afterwards
  b := b + 1 // Increment it to line it up with the arrays
  if (b > Length(bitDeb)) then // If the debug string is too short
    exit; // Then we don't need to change anything (created by LoadBitmap or something similar) so exit procedure
  //Writeln('Destroyed bitmap number ' + IntToStr(b) + ' which was created in procedure ''' + bitLoc[b] + ''''); // Results in extremely large debug box
  bitDeb[b] := '0'; // Set to 0 to signify not in use
  bitLoc[b] := ''; // Set to blank
end;

procedure LoadSheet(var sheet: TSheet; filename: string); // Loads a sheet from a file
var
  s: TPoint;
begin

  sheet.b := LoadBitmap(filename); // Load the bitmap
  GetBitmapSize(sheet.b, s.x, s.y); // Get actual dimensions
  sheet.w := s.x div 32; // Convert to tile dimenions
  sheet.h := s.y div 32; // As above
end;

procedure ConvertTile(var p: TPoint; i: Integer); // Changes integer based reference to an actual position
begin
  p.x := (i mod shTile.w) * 32; // mod by width to get the .x then * 32 to get actual location
  p.y := (i div shTile.w) * 32; // div by width to get the .y then same as above
end;

function ConvertBack(p: TPoint): Integer; // Change actual location back to integer reference
begin
  Result := ((p.y div 32) * shTile.w) + (p.x div 32); // div both by 32 to get tile reference then .y * width and add on .x
end;

procedure GenerateBlankMap(var map: TMap; w, h, d: Integer);
var
  z, y, x: Integer;
begin
  map.depth := d;
  map.height := h;
  map.width := w;
  map.sprite := Round(h / 1.5);
  map.mC := Point(0, 0);
  map.fp := ScriptPath;
  map.saved := false;

  SetLength(map.layers, d);
  SetLength(map.vis, d);

  for z := 0 to d - 1 do
  begin
    map.vis[z] := MBitmap(w * 32, h * 32, '', 'GenerateBlankMap');
    SetLength(map.layers[z], h);
    if (z = 0) then
      SetLength(map.attribs, h);
    for y := 0 to h - 1 do
    begin
      SetLength(map.layers[z][y], w);
      if (z = 0) then
        SetLength(map.attribs[y], w);
      for x := 0 to w - 1 do
      begin
        map.layers[z][y][x] := Point(0, 0);
        if (z = 0) then
          map.attribs[y][x] := 0;
      end;
    end;
  end;
end;

procedure PaintMap; // Paints the layers on to the form so we can see the map
var
  t, i: Integer;
begin
  t := MBitmap(480, 480, '', 'PaintMap'); // Create temp bitmap
  FastDrawClear(t, clBlack); // Ensure temp bitmap is blank

  for i := 0 to maps[cm].depth - 1 do // Loop through all layers
  begin
    SetTransparentColor(maps[cm].vis[i], clBlack); // Set transparent colour so the layers work nicely
    FastDrawTransparent(0, 0, maps[cm].vis[i], t); // Draw sprite layer on with transparency so bottom layer is visible
  end;

  SafeDrawBitmap(t, iMain.Canvas, 0, 0); // Draw the map onto the visual component
  MFreeBitmap(t); // Free our temp bitmap
end;

procedure RedrawMap; // Draw the map entirely from scratch - can be very confusing to understand, but straight forward enough
var
  z, y, x, t, d: Integer;
  p: TPoint;
  ts, ds: TCanvas;
begin
  t := MBitmap(dr.x * 32, dr.y * 32, '', 'RedrawMap'); // Create temp bitmap

  ts := GetBitmapCanvas(shTile.b); // Get the tilesheet's canvas
  ds := GetBitmapCanvas(t); // Get the temp bitmap's canvas

  for z := 0 to maps[cm].depth - 1 do // Loop through all the layers
  begin
    FastDrawClear(maps[cm].vis[z], clBlack); // Ensure layer is clear
    d := maps[cm].vis[z]; // Set d to current layer
    FastDrawClear(t, clBlack); // Clear the temp bitmap
    p.y := -32; // Holds where to draw on the visible map - reset it here
    for y := maps[cm].mC.y to maps[cm].mC.y + dr.y do // Loop through all on screen vertical tiles
    begin
      p.y := p.y + 32; // Increment the position by the height of a tile (32)
      if (y < 0) then // If y is off the top of the map
        continue // Go back to the beginning of the loop
      else if (y >= maps[cm].height) then // If y is off the bottom of the map
        break; // It won't go back on, so break the loop

      p.x := -32; // Holds where to draw on the visible map - reset it here
      for x := maps[cm].mC.x to maps[cm].mC.x + dr.x do // Loop through all on screen horizontal tiles
      begin
        p.x := p.x + 32; // Increment the position by the width of a tile
        if (x < 0) then // If x is off the left of the map
          continue // Go back to the beginning of the loop
        else if (x >= maps[cm].width) then // If x is off the right of the map
          break; // It won't go back on, so break the loop
        SafeCopyCanvas(ts, ds, maps[cm].layers[z][y][x].x, maps[cm].layers[z][y][x].y, maps[cm].layers[z][y][x].x + 32, maps[cm].layers[z][y][x].y + 32, p.x, p.y, p.x + 32, p.y + 32); // Using the 3D TPoint array, copy the tile onto the temp bitmap using TPoint p for where to draw
      end;
    end;
    SetTransparentColor(t, 16448505); // Tiles use a near white colour for transparency, so set it to allow layered maps
    FastDrawTransparent(0, 0, t, d); // Draw the layer transparently onto appropriate bitmap
  end;

  MFreeBitmap(t); // Free our temp bitmap

  PaintMap; // See PaintMap procedure
end;

procedure RedrawArea(ts, te, dp: TPoint); // A procedure similar to RedrawMap, but with alterations so it only redraws the set area and then draws it where told
var
  t, d, z, y, x, w, h: Integer;
  tc, tsc: TCanvas;
  p: TPoint;
begin
  w := (te.x - ts.x) * 32; // Get the width to draw by getting the difference in start and end then multiplying by tile width
  h := (te.y - ts.y) * 32; // As above, only height
  t := MBitmap(w + 32, h + 32, '', 'RedrawArea'); // Setup the bitmap used to draw the new stuff
  tsc := GetBitmapCanvas(shTile.b); // Get the tilesheet's canvas
  tc := GetBitmapCanvas(t); // Get the temp bitmap's canvas



  for z := 0 to maps[cm].depth - 1 do // Loop through all layers
  begin
    d := maps[cm].vis[z];
    FastDrawClear(t, clBlack); // Clear temp bitmap
    p.y := -32; // Reset p.y
    for y := ts.y to te.y do
    begin
      p.y := p.y + 32; // Increment position to draw to
      p.x := -32;
      if (y < 0) then // If y is not valid due to being too far up
        Continue // Skip to beginning of loop
      else if (y >= maps[cm].width) then // If y is not valid due to being too far down
        break; // Break the loop as there's no hope of it returning

      for x := ts.x to te.x do // Loop through all columns
      begin
        p.x := p.x + 32; // Increment position to draw to
        if (x < 0) then // If x is not valid due to being too far left
          Continue // Skip to beginning of loop
        else if (x >= maps[cm].width) then // If x is not valid due to being too far right
          break; // Break the loop as there's no hope of it returning

        SafeCopyCanvas(tsc, tc, maps[cm].layers[z][y][x].x, maps[cm].layers[z][y][x].y, maps[cm].layers[z][y][x].x + 32, maps[cm].layers[z][y][x].y + 32, p.x, p.y, p.x + 32, p.y + 32); // Using the 3D TPoint array, copy the tile onto the temp bitmap using TPoint p for where to draw
      end;
    end;

    SetTransparentColor(t, 16448505); // Tiles use a near white colour for transparency, so set it to allow layered maps
    FastDrawTransparent(dp.x, dp.y, t, d); // Draw the layer transparently onto appropriate bitmap
  end;

  MFreeBitmap(t); // Free our temp bitmap
end;

procedure HandleMovement(amount: Integer; dir: Integer); // Wrapper procedure for RedrawArea
var
  t, z: Integer;
  tc: TCanvas;
  s, e, o, d: TPoint;
begin
  if (amount < 0) then
    amount := - amount;
  t := MBitmap((dr.x + 1) * 32, (dr.y + 1) * 32, '', 'HandleMovement');
  tc := GetBitmapCanvas(t);
  s := maps[cm].mC;
  e := Point(s.x + dr.x, s.y + dr.y);
  o := Point(0, 0);
  d := Point(0, 0);
  case dir of
    1: begin
      e.y := s.y + amount;
      o.y := amount * 32;
    end;
    2: begin
      e.x := s.x + amount;
      o.x := amount * 32;
    end;
    3: begin
      s.y := e.y - amount;
      o.y := - (amount * 32);
      d.y := (dr.y - amount) * 32;
    end;
    4: begin
      s.x := e.x - amount;
      o.x := - (amount * 32);
      d.x := (dr.x - amount) * 32;
    end;
  end;

  for z := 0 to maps[cm].depth - 1 do
  begin
    SafeDrawBitmap(maps[cm].vis[z], tc, o.x, o.y);
    SafeDrawBitmap(t, GetBitmapCanvas(maps[cm].vis[z]), 0, 0);
  end;

  MFreeBitmap(t);

  RedrawArea(s, e, d);
  PaintMap;
end;

procedure AddMap(w, h, d: Integer);
var
  l: Integer;
begin
  l := High(maps) + 1;
  SetLength(maps, l + 1);
  GenerateBlankMap(maps[l], w, h, d);
  tcMain.Tabs.Append('untitled');
  tcMain.TabIndex := tcMain.Tabs.Count - 1;
end;

procedure MapImplode(var arr: TStringArray); // Breaks down the map into an array to be used for saving maps
var
  z, y, x, i: Integer;
begin
  SetLength(arr, 0); // Ensure array passed is empty
  if ((maps[cm].depth <= 0) or (maps[cm].height <= 0) or (maps[cm].width <= 0)) then // If map is blank/invalid size
    Crash('Imploding map of invalid dimensions (one is set to zero)'); // Crash
  i := 2 + ((maps[cm].depth * (maps[cm].height + 1)) - 1); // 2 is for the first line to hold dimension size then a blank line after. Layers held in "paragraphs", so for every layer, there should be height + 1 strings to allow for blank line underneath and then you take one away as bottom "paragraph" doesn't need blank line
  SetLength(arr, i); // Set the length so it's the right length for the data
  arr[0] := IntToStr(maps[cm].width) + ',' + IntToStr(maps[cm].height) + ',' + IntToStr(maps[cm].depth); // Set first array index to hold dimenions info (x by y by z)
  for x := 1 to i - 1 do // Loop through all arrays
    arr[x] := ''; // Set to blank to ensure no corruption
  i := 1; // Set i to 1 as 0 is used for dimensions, then 1 as a blank line - i is incremented once before being used for the first time
  for z := 0 to maps[cm].depth do // Loop through all layers and the attributes
  begin
    for y := 0 to maps[cm].height - 1 do // Loop through all rows
    begin
      i := i + 1; // Increment i so it points to next blank array
      for x := 0 to maps[cm].width - 1 do // Loop through all columns
        if (z < maps[cm].depth) then // if it is a visual layer
          arr[i] := arr[i] + IntToStr(ConvertBack(maps[cm].layers[z][y][x])) + ',' // Append the converted tile and a comma to the end of the array
        else // if it is the attirbutes layer
          arr[i] := arr[i] + IntToStr(maps[cm].attribs[y][x]) + ','; // Append the attribute and a comma to the end of the array
      Delete(arr[i], Length(arr[i]), 1); // Remove the trailing comma
    end;
    i := i + 1; // Increment i to give the blank line between "paragraphs"
  end;
end;

procedure SaveMap(filename: string); // Outputs the map to a file
var
  f, i: Integer;
  s: TStringArray;
begin
  f := RewriteFile(filename, False); // Open file and wipe it or create the file then assign to f
  MapImplode(s); // See MapImplode
  for i := 0 to High(s) do // Loop through s
    WriteFileString(f, s[i] + #13 + #10); // Write to file with new line after
  CloseFile(f); // Close the file
end;

procedure ExportMap; // GUI method of saving a map by opening a TSaveDialog
var
  dialog: TSaveDialog;
begin
  dialog := TSaveDialog.Create(nil); // Create parentless save dialog
  dialog.Filter := 'ScaRPG map|*.srpg'; // Set filter to only allow the the extension specified
  if (ScriptPath <> '') then // If script is saved
    dialog.InitialDir := ScriptPath; // Set starting directory to same as where script is saved
  if (not dialog.Execute) then // If no file is specified after opening the dialog and it is closed
    exit; // exit procedure
  SaveMap(dialog.filename); // See SaveMap - the chosen file is passed as where to save it to
end;

procedure MExplode(var arr: TStringArray; str, del: string); // Standard Explode procedure written for older Scar versions
var
  i, h, l: Integer;
begin
  SetLength(arr, 0); // Ensure passed array is blank
  h := -1; // Set high of array to -1
  l := Length(del) - 1; // Amount to delete by based on del's length to ensure it is removed if longer than 1 char
  while (true) do // Endless loop
  begin
    h := h + 1; // Increment h
    SetLength(arr, h + 1); // Make array longer by one
    i := Pos(del, str); // Find first occurence of del in str
    if (i = 0) then // If it is not found
      break; // Break from loop
    arr[h] := Copy(str, 1, i - 1); // Copy the text until del (not including del) to the array
    Delete(str, 1, i + l); // Remove copied text as well as del
  end;
  arr[h] := Copy(str, 1, Length(str)); // Copy remaining text into the array - del should not be on it, so no need to copy shorter than the length
end;

function StrInt(s: string): Integer; // "Safe" version of IntToStr to catch dodgy map files specifically
begin
  try
    Result := StrToInt(s); // Try standard conversion
  except // If it is non-numeric
    if (s = '') then // If it is blank
      Result := 0 // Set to 0
    else // If non-numeric and not blank
      Crash('StrInt passed invalid string - "' + s + '"'); // Crash
  end;
end;

procedure MapExplode(str: string); // Creates the backend for the visual map from a string
var
  lineArr: TStringArray;
  mapArr: array of TStringArray;
  i, z, y, x: Integer;
begin
  if (Pos(#13 + #10, str) = 0) then // If no enter's are found in the string
    Crash('Exploding map from an invalid input string'); // Crash

  MExplode(lineArr, str, #13 + #10); // See MExplode - breaks into seperate lines
  SetLength(mapArr, High(lineArr) + 1); // Set 2D array to the same length as the number of lines
  for i := 0 to High(lineArr) do // Loop through all the lines
    MExplode(mapArr[i], lineArr[i], ','); //See MExplode - breaks into seperate values between the comma's

  maps[cm].width := StrInt(mapArr[0][0]); // Set the dimension of the map based on the extracted values
  maps[cm].height := StrInt(mapArr[0][1]); // As above
  maps[cm].depth := StrInt(mapArr[0][2]); // As above

  i := 2; // Set i to 2 - the first array relating to the map

  // This section is like the inverse of the main loop in MapImplode
  SetLength(maps[cm].layers, maps[cm].depth); // Set the 3D TPoint array to length of the depth
  for z := 0 to maps[cm].depth - 1 do // Loop through all layers and the attribute layer
  begin
    SetLength(maps[cm].layers[z], maps[cm].height); // Set a 2D TPoint array to length of the height
    for y := 0 to maps[cm].height - 1 do // Loop through all rows
    begin
      SetLength(maps[cm].layers[z][y], maps[cm].width); // Set the TPoint array to the length of the width
      for x := 0 to maps[cm].width - 1 do // Loop through all columns
        ConvertTile(maps[cm].layers[z][y][x], StrInt(mapArr[i][x])); // See ConvertTile - this is done so that map painting requires less calculations
      i := i + 1; // Go onto the next line of the loaded "paragraph"
    end;
    i := i + 1; // Would be a blank line here, so go on to the next
  end;

  SetLength(maps[cm].attribs, maps[cm].height); // Set the height of the 2DIntArray
  for y := 0 to maps[cm].height - 1 do // Loop through all rows
  begin
    SetLength(maps[cm].attribs[y], maps[cm].width); // Set the width of the TIntegerArray
    for x := 0 to maps[cm].width - 1 do // Loop through all columns
      maps[cm].attribs[y][x] := StrInt(mapArr[i][x]); // Convert the string into an integer attribute value
    i := i + 1;
  end;
end;

procedure LoadMap(filename: string); // Handles the loading of a map file and doing what needs to be done
var
  f: Integer;
  s: string;
begin
  if (not FileExists(filename)) then // If file does not exist
    Crash('File specified to load does not exist - "' + filename + '"'); // Crash
  f := OpenFile(filename, False); // Open the file specified
  ReadFileString(f, s, FileSize(f)); // Read the contents of the file
  CloseFile(f); // Close the file
  MapExplode(s); // See MapExplode - pass the file contents to break apart
end;

procedure ImportMap; // GUI method of opening a map by opening a TOpemDialog
var
  dialog: TOpenDialog;
begin
  dialog := TOpenDialog.Create(nil); // Create a parentless open dialog
  dialog.Filter := 'ScaRPG map|*.srpg'; // Set the filter to only show map files
  if (ScriptPath <> '') then // If the script is saved
    dialog.InitialDir := ScriptPath; // Set the starting directory to the place where the script is saved in
  if (not dialog.Execute) then // If the dialog is launched and no file is selected when closed
    exit; // exit procedure
  LoadMap(dialog.filename); // See LoadMap - passing the selected file as the one to load
end;

procedure OnMapMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var
  d: TPoint;
begin
  X := Trunc(X / 32.0);
  Y := Trunc(Y / 32.0);
  d := Point(X * 32, Y * 32);
  X := maps[cm].mC.x + X;
  Y := maps[cm].mC.y + Y;
  maps[cm].layers[2][Y][X].x := dT.x;
  maps[cm].layers[2][Y][X].y := dT.y;
  RedrawArea(Point(X, Y), Point(X, Y), d);
  PaintMap;
end;

procedure OnMapScroll(Sender: TObject; ScrollCode: TScrollCode; var ScrollPos: Integer);
var
  dir, amo: Integer;
begin
  if (Sender = sbHorz) then
  begin
    amo := maps[cm].mC.x - sbHorz.Position;
    maps[cm].mC.x := sbHorz.Position;
    if (amo < 0) then
      dir := 4
    else
      dir := 2;
  end
  else if (Sender = sbVert) then
  begin
    amo := maps[cm].mC.y - sbVert.Position;
    maps[cm].mC.y := sbVert.Position;
    if (amo < 0) then
      dir := 3
    else
      dir := 1;
  end;
  HandleMovement(amo, dir);
end;

procedure OnTilesheetMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  X := Trunc(X / 32.0) * 32;
  Y := Trunc(Y / 32.0) * 32;
  dT := Point(X, Y);
  Writeln(IntToStr(x) + ',' + IntToStr(y));
end;

procedure SetupForm;
begin
  fMain := CreateForm;
  with fMain do
  begin
    Caption := 'ScaRPG - Map Editor';
    ClientWidth := 596 + (shTile.w * 32); // 50 + 480 + 16 + 50 + tilesheet bit
    ClientHeight := 596; // 50 + 480 + 16 + 50
    Position := poDesktopCenter;
  end;

  sbSheet := TScrollBox.Create(fMain);
  with sbSheet do
  begin
    Parent := fMain;
    Align := alRight;
    Width := (shTile.w * 32) + 20;
    Height := 480;
    Left := fMain.ClientWidth - Width;
    Top := 0;
  end;

  iSheet := TImage.Create(sbSheet);
  with iSheet do
  begin
    Parent := sbSheet;
    Left := 0;
    Top := 0;
    Width := (shTile.w * 32);
    Height := (shTile.h * 32);
    SafeDrawBitmap(shTile.b, Canvas, 0, 0);
    OnMouseUp := @OnTilesheetMouseUp;
  end;

  tcMain := TTabControl.Create(fMain);
  with tcMain do
  begin
    Parent := fMain;
    Align := alClient;
    AddMap(20, 20, 3);
  end;

  iMain := TImage.Create(tcMain);
  with iMain do
  begin
    Parent := tcMain;
    Left := 50;
    Top := 50;
    Width := 480;
    Height := 480;
    Canvas.Brush.Color := clRed;
    Canvas.RoundRect(0, 0, 480, 480, 0, 0);
    OnMouseUp := @OnMapMouseUp;
  end;

  sbHorz := TScrollBar.Create(tcMain);
  with sbHorz do
  begin
    Parent := tcMain;
    Left := 50;
    Top := 530;
    Width := 480;
    Height := 16;
    Kind := sbHorizontal;
    Max := maps[cm].Width - 1;
    OnScroll := @OnMapScroll;
  end;

  sbVert := TScrollBar.Create(tcMain);
  with sbVert do
  begin
    Parent := tcMain;
    Left := 530;
    Top := 50;
    Width := 480;
    Height := 16;
    Kind := sbVertical;
    Max := maps[cm].Height - 1;
    OnScroll := @OnMapScroll;
  end;

  RedrawMap;
  fMain.ShowModal;
end;

var
  v: TVariantArray;
  m, z, i: Integer;
// Main loop - no comments
begin
  Writeln('begin');
  dr := Point(15, 15);
  LoadSheet(shTile, ScriptPath + 'Tiles.bmp');

  ThreadSafeCall('SetupForm', v);
//  SetupForm; // Use without SafeCall for debugging unknown errors, though very prone to self destruct when done so - use at own risk
  FreeForm(fMain);

  for m := 0 to High(maps) do
    for z := 0 to maps[m].depth - 1 do
      MFreeBitmap(maps[m].vis[z]);
  FreeBitmap(shTile.b);

  // Section for debugging memory leaks - see MBitmap and MFreeBitmap
  // Don't rely on it for fixing all leaks - only works when you use MBitmap and not LoadBitmap etc.
  while True do
  begin
    i := Pos('1', bitDeb);
    if (i = 0) then
      Break;
    Writeln('Bitmap created from ''' + bitLoc[i] + ''' not freed!');
    MFreeBitmap(i - 1);
  end;

  Writeln('end');
end.