LUNY.CO.UK

zxEdit is an idea for an application I've had for sometime. The idea is to have a configurable editor which allows 8 bit games to be edited, so that their text, graphics and even levels can be changed. Initially I will focus on editing ZX Spectrum games as that is where my knowledge lies but their should ne no reason that the application can be adapted for other popular platforms.

To create an application that allows users to edit the data of ZX Spectrum game snapshots, using on screen editors and create new game with the edited data.

The application will allow specific ZX Spectrum games to be edited.

Project configurations will define how a specific game data is stored and to which snapshot file the game is in.

On screen editors will allow easy editing using an intuitive UI. The user must be able to save their progress and compile the edited data into a working snapshot.

Developers must be able to create modules that, when included in the application folder, add customised editors made up of either existing or new controls, in order to extend the functionality of the application.

To begin with the application will work with ZX Spectrum game snapshots only but there is no reason it could load in other formats eventually. The data is extracted, using the configuration, into usable data in memory, such as text, data and graphics.

Configuration file will be defined in XML for human readability. They will each define:

• A single project, which relates to a single game for editing.
• How the data is stored and used.
• The on screen editors, including which controls and data are used to create the editor.

The application will be made up of reusable controls which in turn can be combined to create on screen editors for changing the data. Progress can be saved by serialising the data in an readable format which can be then reloaded at any point. Data can be compiled back into binary, in its original place into a final game snapshot or as a set of patch binary files (allowing for copyright issues.).

Here is a very high level overview of the application.

The binary is loaded in as a project, the user edits the data, is able to save their progress and then compile a final edited binary.

Now lets break that down to slightly more detailed overview breaking the application down into its own modules.

Note: I will be using SOLID principles heavily in this project so the connections between the module blocks will be defined using interfaces in order to keep the blocks as loosely coupled as possible.

So to recap that application is broken down to the following blocks:

• Serialisation
• Data
• The UI

Each of these in turn will break down into further smaller module with their own interfaces.

Serialisation

• Configuration
  • XML parsing.
• Binary
  • Loading and parsing.
  • Compiling and saving.
  • Single game binary.
  • Path files.
• Progress
  • Saving as XML
  • Loading as XML.

Data

• Configuration data.
• Module extensions.
• Game data converted from binary.
• Progress
  • Edited game data.
  • User / UI configurations.
• Project information.

UI

• Forms.
• Editors.
  • Custom controls.
    • Painters.
• Colours.