GUI Development:zxEdit


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.

The Brief

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 Specification

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.

The Technical Details

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:

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.).

The Design

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.

The principles of SOLID are guidelines that can be applied while working on software to remove code smells by providing a framework through which the programmer may refactor the software's source code until it is both legible and extensible. It is part of an overall strategy of agile and Adaptive Software Development.

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:

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