Digger for .NET

Brian Long (www.blong.com)

Introduction

This demo is an implementation of the classic Digger game (sometimes known as Boulderdash or Dig Dug).
It was translated to Delphi for .NET by Brian Long (www.blong.com) from the C# implementation by Lutz Roeder (www.aisto.com/roeder/dotnet).
The graphics and levels are taken from the original version by Alexander Lang and Jan Fricke.

Delphi For .NET Details

Changes in the Delphi implementation include:

• meaningful constants and variable names are used throughout
• some methods have been renamed for clarity
• Delphi sets are used where appropriate
• some code has been tidied up
• some redundant code has been removed
• a couple of logic bugs have been fixed
• the panel has been removed (the game is now drawn directly on the form instead)
• the use of .NET type info (using GetType) has been replaced with the Delphi is operator

Concepts Demonstrated

Digger spans several units and demonstrates a number of useful concepts, including:

• Unit names that define namespaces
• Accessing .NET class library assemblies
• The structure of a GUI .NET application
• The use of a timer
• Event handlers (for the form and a timer)
• Drawing simple sprite graphics
• Object boxing (e.g. turning integers into objects)
• The use of class references and the .NET equivalent
• Accessing data files on disk
• Accessing managed resources, despite the preview version of Delphi for .NET not directly supporting them)

Points To Note

The Digger source uses conditional compilation through various conditional defines to cater for some features that are currently not working in the preview version of Delphi for .NET and also to show alternative ways of doing things:

• Class references don't work correctly yet. You get the type in the class reference variable declaration instead of the correct type that has been assigned at runtime.
  If USE_CLASS_REFS is defined, class references are used.
  If USE_CLASS_REFS is not defined, .NET type info is used
• Managed resources cannot currently be linked in by Delphi for .NET, but you can work around this limitation using creative round tripping (disassembling, modifying and reassembling)
  If LINK_RESOURCES is defined, the code expects the managed resources to be linked in.
  If LINK_RESOURCES is not defined, the code works off data files in the same directory.
  Digger uses resource files for the form icon (Digger.ico), the sprite images (Sprite.png), the font data (Font.png) and the level data (Level.bin)
• Range checking is not currently reliable in Delphi for .NET
  If USE_RANGE_CHECKING is defined then range checking will be enabled
  If USE_RANGE_CHECKING is not defined then range checking will be disabled.
• Some of the original C# code used object boxing (e.g. turning integers to objects, so methods can be called on them).
  If USE_OBJECT_BOXING is defined, object boxing is used (in DiggerMainForm.pas).
  If USE_OBJECT_BOXING is not defined, the Format function is used
• A couple of units (Oblong.Vcl.Controls.pas and Oblong.Types.pas) are used solely to map .NET types to familiar looking Delphi types.
  This preview edition of Delphi for .NET does not contain a VCL library but the full version will do, at which point most, if not all these types will be defined in the VCL units

Building Digger

You can build Digger in two different ways, depending on whether you want a simple, straightforward compilation, or something slightly more involved and interesting:

1. The preview version of Delphi for .NET does not currently support linking in managed resources into the executable.
   So the first approach to compiling Digger generates an executable that reads data files from disk (they are expected to be in the current directory).
   Use the BUILD.BAT batch file at the command line to generate this version of Digger.exe.
   BUILD.BAT performs the following steps:
   1. delete any existing copy of Digger.exe
   2. compile a resource script that refers to the application icon (to display in Windows Explorer and on the Task Bar), generating a Win32 resource file
   3. delete command-line configuration file if present (it will be generated if you save the project in the Delphi 7 IDE)
   4. compile the project source files and link in the Win32 icon resource to an executable (Digger.exe)
   5. verify Digger.exe
   6. show a DIR listing of the Digger.exe
   7. launch Digger.exe

   *** Deleting old executable (if present) *** *** Compiling the icon into a resource file *** Borland Resource Compiler Version 5.40 Copyright (c) 1990, 1999 Inprise Corporation. All rights reserved. *** Deleting command-line compiler config file (if present) *** *** Compiling Digger to use external resource files *** Borland Delphi Version 16.0 Copyright (c) 1983,2002 Borland Software Corporation Confidential pre-release version built Aug 6 2002 14:22:28 Oblong.Vcl.Controls.pas(42) Oblong.Types.pas(27) DiggerFont.pas(77) DiggerLevel.pas(1157) DiggerMainForm.pas(291) Digger.dpr(60) 1660 lines, 0.49 seconds, 23803 bytes code, 0 bytes data. *** Verifying generated executable *** Microsoft (R) .NET Framework PE Verifier Version 1.0.3705.0 Copyright (C) Microsoft Corporation 1998-2001. All rights reserved. All Classes and Methods in Digger.exe Verified *** Showing generated executable details *** Volume in drive D is DATA Volume Serial Number is A43F-3989 Directory of D:\Dev\Delphi.NET\Digger 09/08/2002 11:18 28,672 Digger.exe 1 File(s) 28,672 bytes 0 Dir(s) 706,592,768 bytes free *** Launching Digger *** D:\Dev\Delphi.NET\Digger>

2. The second approach to compiling Digger involves the use of creative round tripping to link the data files into the executable as managed resources.
   This is an interesting process that involves:

   1. Disassembling the executable compiled by Delphi for .NET with the .NET disassembler (ildasm.exe), which produces a CIL (Common Intermediate Language) file with a .IL extension
   2. Modifying the generated IL code, or adding new IL files into the pot
   3. Reassembling the (possibly) modified IL file(s) with the .NET assembler (ilasm.exe) to recreate a new version of the executable

   In this particular case, once Digger.exe has been disassembled to the corresponding Digger.il file, it is reassembled with one additional IL file, DiggerResources.il.
   This is a trivial file that refers to each data file in an appropriate manner to have the assembler link them all as managed resources and looks like this:

   .mresource public Level.bin {} .mresource public Font.png {} .mresource public Digger.ico {} .mresource public Sprite.png {}

   Use the BUILD2.BAT batch file at the command line to generate this version of Digger.exe.
   BUILD2.BAT performs the following operations:

   1. delete any existing copy of Digger.exe
   2. compile a resource script that refers to the application icon (to display in Windows Explorer and on the Task Bar), generating a Win32 resource file
   3. delete command-line configuration file if present (it will be generated if you save the project in the Delphi 7 IDE)
   4. compile the project source files and link in the Win32 icon resource to an executable (Digger.exe) with LINK_RESOURCES defined
   5. disassemble Digger.exe to Digger.il
   6. assemble Digger.il and DiggerResources.il to create a new Digger.exe
   7. verify Digger.exe
   8. show a DIR listing of the Digger.exe
   9. launch Digger.exe

   *** Deleting old executable (if present) *** *** Compiling the icon into a resource file *** Borland Resource Compiler Version 5.40 Copyright (c) 1990, 1999 Inprise Corporation. All rights reserved. *** Deleting command-line compiler config file (if present) *** *** Compiling Digger to use linked managed resources *** Borland Delphi Version 16.0 Copyright (c) 1983,2002 Borland Software Corporation Confidential pre-release version built Aug 6 2002 14:22:28 Oblong.Vcl.Controls.pas(42) Oblong.Types.pas(27) DiggerFont.pas(77) DiggerLevel.pas(1157) DiggerMainForm.pas(291) Digger.dpr(60) 1660 lines, 0.54 seconds, 23891 bytes code, 0 bytes data. *** Disassembling Digger *** // WARNING: Created Win32 resource file Digger.res *** Reassembling Digger with linked resources *** Assembling 'Digger.IL' , no listing file, to EXE --> 'Digger.EXE' Source file is ANSI Assembling 'DiggerResources.IL' , no listing file, to EXE --> 'Digger.EXE' Source file is ANSI Operation completed successfully *** Verifying generated executable *** Microsoft (R) .NET Framework PE Verifier Version 1.0.3705.0 Copyright (C) Microsoft Corporation 1998-2001. All rights reserved. All Classes and Methods in Digger.exe Verified *** Showing generated executable details *** Volume in drive D is DATA Volume Serial Number is A43F-3989 Directory of D:\Dev\Delphi.NET\Digger 09/08/2002 11:19 38,912 Digger.exe 1 File(s) 38,912 bytes 0 Dir(s) 706,580,480 bytes free *** Launching Digger *** D:\Dev\Delphi.NET\Digger>