I have been writing software since childhood, and have been making Free Software for a number of years now. I have been involved with several Free Software and Open Source Software projects, written my own libraries and tools, and sometimes developed or ported resources to unsupported operating systems.
One of my main areas of interest is the emulation of the Acorn Electron. See this library and this tribute site for information about this machine.
Initially, I used the ElectrEm emulator, but have been using Elkulator for the last few years. I have written various tools to convert data between various file formats used by ElectrEm and emulators of other Acorn 8 bit machines. I have also written a couple of games for the Electron.
Python is the development language I have chosen for many of my own projects since it has traditionally been quite easy to use it to express my ideas. I have created various libraries and utilities to aid project development and provide a comfortable working environment. I try to contribute to other projects which use the Python language, but this tends to happen less often than it did as my interests change.
Most of the Python projects that I'm comfortable sharing with others involve conversion between file formats, often those found on practically obsolete platforms. A lot of the code for these has been shared on external code hosting sites, so many of the links below will take you to external repositories.
This package contains various classes for reading and writing Acorn Drawfiles, and some example scripts that convert Drawfiles to other formats. Although it should be possible to use the module to create Drawfiles from scratch, the API is really designed for extracting the contents of existing Drawfiles, either for display or for conversion to a more long-lived format.
The code is available from an externally hosted Git repository.
In early 2016 I decided to learn about development for Android systems and, having previously looked into using Python as a development language, I hoped that I would be able to get up and running quickly. However, despite improvements to the availability of CPython on Android, it seemed that the toolchain to write Python applications was very heavy (being based on both the Android SDK and NDK) and the process not as smooth as I had hoped. I started to look at writing in Java but very quickly became frustrated with the language. This caused me to look at how Java source code was compiled to Dalvik bytecode and exploring the contents of APK files containing applications.
The result of my explorations can be found in the DUCK collection of tools and modules. This provides Python modules for manipulating data in Android-specific formats, such as APK and DEX files, as well as a compiler for the Serpentine language that supports a subset of Python that falls within the constraints imposed by the Dalvik bytecode it is compiled to.
A package of modules and tools for reading and interpreting Computer Concepts Impression documents with the aim of converting their contents into a more accessible form for modern systems and document processing applications. Unfortunately, many of the modern targets for this kind of file format are themselves in constant development.
This package relies on the Drawfile module to handle Drawfiles and Spritefiles that are embedded in documents. There is no support for Artworks files since I never used Artworks to create any files or embedded any existing files in documents that I wrote.
The code is available from an externally hosted Git repository. Looking back at the code, I did some tricks with dynamic class generation that I'm not happy with now, but at the time it seemed like a convenient way to represent the inheritance behaviour of document styles.
 |
from ldraw.colours import * from ldraw.figure import * figure = Person() print figure.head(Yellow, 35) print figure.hat(Black, "3901") # Hair Male print figure.torso(Red, "973") # Torso print figure.hips(Blue) print figure.left_leg(Blue, 5) print figure.right_leg(Blue, 20) print figure.left_arm(Red, 0) print figure.left_hand(Yellow, 0) print figure.right_arm(Red, -90) print figure.right_hand(Yellow, 0) print |
A package providing facilities for the creation of LDraw scene descriptions.
The code is available from an externally hosted Git repository.
Classes for reading and writing Acorn Spritefiles with tools for conversion and interoperability with other image formats. This module is needed by the Drawfile module because Drawfiles could contain Spritefiles, so a separate version is also included in that repository. Since these modules are rarely updated, it is not really a problem to keep the two versions in sync.
The code is available from an externally hosted Git repository.
A Python package for reading Icon Technology TechWriter documents with simple conversion tools that enable their contents to be exported to other formats.
I started using TechWriter for scientific and mathematical documents in the period between using Impression for desktop publishing and discovering LaTeX. At some point, support for TeX export was added to the application and this made it possible to slowly migrate content to LaTeX during the run up to writing my Ph.D. thesis. A couple of years later, I thought it might be a good idea to write this package to help other convert files without needing to get the application running on aging hardware.
The code is available from an externally hosted Git repository.
I spend a lot more time working with file formats than with networking protocols. However, there have been a couple of cases where I needed to be able to connect systems together, and it was necessary or interesting to write software to interoperate with existing servers or services.
This package contains a simple application for sharing directories with RISC OS machines running Acorn Access peer-to-peer disk drive sharing software. It was originally written as a proof of concept and was a way to learn about networking protocols and reverse engineering.
The code is available from an externally hosted Git repository.
A package implementing aspects of the Object Exchange (OBEX) protocol, which is a file sharing protocol typically used between Bluetooth devices. The standard isn't open, although it should be possible to find leaked copies of it online, and implementations of it vary in quality, particularly on mobile phones. This implementation doesn't promise to support everything, or indeed anything, you might want or need, but I get a steady trickle of enquiries about this package.
The code is available from an externally hosted Git repository.
When using retro platforms it is useful to be able to work with the file formats used by emulators or media formats used by the retro hardware itself. I have written Python modules to read and write some of the disk and tape formats used by emulators of Acorn 8 bit microcomputers. These have been used to access files from old media and create new media for use on old hardware.
A Python module and tool for reading ADFS floppy disc images, for use alongside emulators of Acorn 8 bit microcomputers.
The code is available from an externally hosted Git repository.
The basic Acorn Electron was supplied with only a cassette interface for data storage but, thanks to the expansion interface at the back of the machine, a number of peripherals were available to provide disc-based storage. To facilitate the transfer of users' data from cassette to disc, Slogger, a peripheral manufacturer, produced a number of ROMs for a variety of disc interfaces. Each program, instead of transferring files individually, places them all together in a tape image not unlike those used for games on ROM cartridge.
I have written various utilities to convert between the tape images produced by the various ROMs and other file formats used by emulators. Currently, images produced by T2Peg400 and T2P3 have been read and files successfully extracted.
The code is available from an externally hosted Git repository.
This set of modules and tools allows you to manipulate the data stored in Unified Emulator Format (UEF) files at the level of individual files or even at the "chunk" level.
The code is available from an externally hosted Git repository.
An experimental tool for extracting the files from a UEF file and creating ROM images containing those files stored a ROM filing system structure. Due to the way much cassette software was written this tool is of limited use, though many games can be converted to work as single or double ROM cartridges. Originally only able to create a single ROM image for each UEF, the latest version can create single, double or sequences of ROM images, compressing data as required. The use of compression also enables fast loading of ROM data since the decompression routine writes the decompressed data directly into RAM. Sequences of ROMs require special hardware to handle ROM paging using a register in the FC memory page.
The code is available from an externally hosted Git repository.
In 2011, after thinking about it for some time, I decided to take the plunge and write a game for the Acorn Electron in 6502 machine code. It was certainly easier to write assembly language after many years of programming experience than it had been in my childhood.
After a break in assembly language coding I followed the first game with another more ambitious game, meant to change expectations of what kinds of games could be done successfully on the Electron.
Castle Raider is a sideways scrolling platform game for the Acorn Electron and BBC Micro, featuring monsters to avoid, keys to collect, and lots of running and jumping action.
Initially written to show that the Electron could support smooth sideways scrolling, the game developed over three years into a fast-paced platform game unlike any other previously released for the machine. The BBC Micro version was developed to satisfy players who were worried that it would not be available for the Electron's older sibling!
Jungle Journey is a multi-screen exploration game for the Acorn Electron and BBC Micro, featuring hundreds of locations to explore, four different weapons and five types of enemy to avoid or shoot.
Written over a period of a few months in 2011, it was my first serious attempt to write a fairly substantial piece of software in 6502 assembly language.
One of the exciting things about using modern systems to access retro games and other software is the prospect of modifying or expanding them. While some old games were written with the idea of future expansions – new sets of levels, for example – others were released with a single map or set of levels and were never intended to be developed further. Since some of these games were built around impressive game engines with robust core mechanics, it seems a shame that they were only used for a single release and never built upon.
I started experimenting with modified versions of games in the late 1980s when my brother and I discovered that the level data for the Micro Power classic, Moon Raider, could be accessed after a soft reset and the game restarted with any modifications we had made. This led to the creation of a more comprehensive tool many years later.
I have now made quite a few tools for viewing and editing maps and levels from various Acorn Electron and BBC Micro games. These are covered briefly below. Please excuse the unimaginative naming scheme I use for them.
The BoneCruncherMaps project is a set of tools and modules to read, edit and write maps for the Acorn Electron version of Superior Software's BoneCruncher.
The main tool is a GUI editor for editing levels in an existing BoneCruncher executable and level files, stored in a Universal Emulator Format (UEF) file. This depends on the cross-platform PyQt4 GUI framework.
This project was discussed in this stardot thread and is referenced by this Retro Software Wiki page.
The code is available from an externally hosted Git repository.
The CloggerMaps project is a set of tools and modules to read and display maps for the Acorn Electron version of Impact Software's Clogger.
The main tool is a GUI editor for editing levels in existing Clogger level files, stored in a Universal Emulator Format (UEF) file. This depends on the cross-platform PyQt4 GUI framework.
Since the game design relies on a set of core mechanisms and the levels are provided as a set of loadable components, almost everything can be modified and the game will deal with it consistently. The editor allows most things to be customised fairly easily, if not in the most user-friendly way possible.
Interestingly, the way that sprites are defined and puzzle pieces are represented is quite similar to the way Repton and Repton 2 handle them. I imagine that the similarity in approach comes from having to solve the same problems in both games: how to plot sprites quickly and how to store many different sprites in a limited amount of memory.
This project was discussed in this stardot thread and is referenced by this Retro Software Wiki page.
The code is available from an externally hosted Git repository.
The FiretrackMaps project is a set of tools and modules to read maps for the Acorn Electron version of Superior Software's Firetrack.
The main tool is a GUI editor for browsing levels in an existing Firetrack executable and level files, stored in a Universal Emulator Format (UEF) file. This depends on the cross-platform PyQt4 GUI framework.
This project was discussed in this stardot thread and is referenced by this Retro Software Wiki page.
The code is available from an externally hosted Git repository.
My retro game modifications started when this game was not so retro.
The Micro Power game Moon Raider is a sideways-scrolling arcade game similar to the arcade classic Scramble and was released for both the BBC Micro and Acorn Electron computers. In the Electron version there are six consecutive levels, but the player can skip up to the first four. There is a refuelling stage between each level.
Despite having the standard challenges for "Scramble" type games, the description of the levels is surprisingly flexible. Using an appropriate utility, longer levels than the original can be designed, and enemies can be introduced to levels other than those in which they usually appear. For instance, fireballs may be introduced outside level three.
This program allows you to convert between the levels built in to a copy of Moon Raider and a textual description which can be edited more easily.
This project was discussed in this stardot thread and is referenced by this Retro Software Wiki page.
The code is available from an externally hosted Git repository.
The MushroomScreens tool is used to extract level data from files saved by Acornsoft's Magic Mushrooms and save it as a gallery of images in a Web page. There didn't seem to be much point in producing an editor for these files since the game itself already contains one.
This project was discussed in this stardot thread and is referenced by this Retro Software Wiki page.
The code is available from an externally hosted Git repository.
The RavenskullMaps project is a set of tools and modules to read maps for the Acorn Electron version of Superior Software's Ravenskull.
The main tool is a GUI editor for browsing levels in an existing Ravenskull executable and level files, stored in a Universal Emulator Format (UEF) file. This depends on the cross-platform PyQt4 GUI framework.
This project is much less complete than many of the others I have done. The level format is a lot more complicated than for other tile-based games since it also describes the various objects and special tiles that the player's character will encounter. I didn't get as far as decoding the object sprites, and it seems that I didn't manage to reliably save modified levels, though I remember being able to modify the first level in order to more easily access the crucifix, and also to give the player the bow and arrows at the start.
In the end, the potential for modifying Ravenskull is quite limited unless you can modify the way the objects behave and where the traps are. This was done comprehensively in the follow-up to Ravenskull, Pipeline.
This project was discussed in this stardot thread and is referenced by this Retro Software Wiki page.
The code is available from an externally hosted Git repository.
The ReptonMaps project is a set of tools and modules to read, edit and write maps for the Acorn Electron cassette versions of Superior Software's Repton and Repton 2, and the BBC Micro DFS disk version of Repton.
The main tool is a GUI editor for editing levels in an existing Repton or Repton 2 executable, stored in a Universal Emulator Format (UEF) or Single Sided Disk (SSD) file. This depends on the cross-platform PyQt4 GUI framework.
What started out as an experiment to see if the built-in maps in Repton could be modified ended up as a full-blown editor for Repton and Repton 2. Although it would be possible to add support for Repton 3, it isn't as interesting to do so because there is already an editor supplied with the game and the idea of customisation is part of the experience.
Handling the levels for Repton 2 was more complicated than that for Repton because they are interdependent and linked by transporters. There are also various rules about how levels appear – for example, levels are defined in horizontal strips of 8 rows, some of which are filled with only one tile type (such as skulls), and these can be reused in many levels. There are also special events that occur when the player has collected all items of a particular type – skulls will be removed on screen A, allowing access to the finishing piece.
This project was discussed in this stardot thread and is referenced by the ReverseEngineered Repton and ReverseEngineered Repton 2 Retro Software Wiki pages.
The code is available from an externally hosted Git repository.
The SharkMaps project is a set of tools and modules to read, edit and write maps for the Acorn Electron and BBC Micro versions of Audiogenic's Shark.
Unlike other editors for retro games, this one was implemented in BBC BASIC and 6502 assembly language because it seemed that people who might want to create levels would want to do so in the environment they would play the game in – either on real hardware or in an emulator.
This project was discussed in this stardot thread and is referenced by this Retro Software Wiki page.
The code is available from an externally hosted Git repository.
The DunjunzMaps project is a set of tools and modules to read maps for the Acorn Electron version of Bug Byte's Dunjunz.
Tools are provided for extracting sprites, displaying textual representations of the level maps, and creating HTML or annotated image representations of maps.
This project was discussed in this stardot thread and the information uncovered by the project was used by Ciaran Anscomb to create a rewrite of Dunjunz for the Dragon 32/64 and Tandy Colour Computer.
The code is available from an externally hosted Git repository.
The IcarusMaps project is a set of tools and modules to read maps for the Acorn Electron version of Mandarin Software's Icarus.
Tools are provided for extracting sprites, displaying textual representations of the level maps, and annotated image representations of maps.
The code is available from an externally hosted Git repository.
I started looking at Printed Circuit Board (PCB) design after my brother designed an Acorn Electron cartridge breakout board. My designs are also based around the Electron's cartridge format, using his design as the basis for my own.
The Acorn Electron 128K Banked Flash ROM Cartridge allows a 128K Am29F010 Flash chip to be accessed as four pairs of 16K banks, using 74HC00 (NAND) and 74LS174 (flip-flop) Integrated Circuits (ICs) to select different pages in the ROM.
From a software perspective, each pair of 16K banks is selected by writing a value from 0 to 3 to the ROM paging register at &FC73 in the Electron's memory. A software reset will then cause the operating system to rescan the ROMs presented by the cartridge and make them available to use. I wrote a fancy menu to present a selection of up to four games and allow the user to choose from them using this paging method.
The cartridge is a simpler version of the Mega Games Cartridge but it has the advantage that it is easier for people like me to put together since the components are all Dual In-Line Package (DIP) ICs.
I also designed a smaller version, though I have yet to get it manufactured.
Copyright © 2022 David Boddie
Last updated: 2022-09-30 20:54:14 UTC
This document is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International license.