With the large amount of quiz games that I’ve been prising open, a few of them used saved arrays on tape (and some were also on disk too) to store multiple sets of questions and the answers. This freed up the game from only being able to store one set of questions and answers in memory and giving more value to the quiz game.
I’ve been doing this with my own methods (poking about in the raw binary files, using an old tool called Bin2Text and using Notepad++) and also with Gerard Sweeney from The Tipshop and Ian (aka SToS). Especially the latter with his help via his Python scripts that convert saved arrays into files that can easily be imported into Excel.
Every time I’m learning from the previous attempts and I’m slowly building up into a decent set of procedures, and some accompanying tools, to get it done quicker. Well, in theory it is. So this page should (eventually) hold all of the ways I’ve developed with help.
How arrays are stored on tape/disk
Header Block Details
The header block contains metadata about the array. The crucial element is the file type byte (at offset 12 in the 17-byte structure), which identifies the content as a numeric or string array.
- Type 1: Numeric array.
- Type 2: Character (string) array.
Other information in the header includes:
- The filename (a 10-character string).
- The length of the subsequent data block.
- The array name (a single byte at position 14 decimal of the header).
Data Block Details
The data block contains the actual array data in the same format as it is stored in the Spectrum’s RAM.
- Numeric Arrays: Each number is stored as a 5-byte floating-point value.
- String Arrays: String arrays have fixed-length elements. The data block contains the characters for each string in sequence.
For example data block of a 2×3 numeric array (with small integer numbers):
| Byte (decimal) | Length | Example value | Description |
|---|---|---|---|
| 0 | 1 | 0x02 | Number of dimensions – DIM(2,3) |
| 1 | 2 | 0x02 0x00 | Dimension 1 – 2 |
| 3 | 2 | 0x03 0x00 | Dimension 2 (0x03 0x00 – 3) |
If your array has more columns than the two in the example above, the amount of bytes will need to be increased *before* the actual data is stored. Something to be aware of if you want to create your own extraction tool(s).
Luckily ZX-BlockEditor automatically parses the header and allows you to export just the binary files. That’s covered in the next section.
Tool that I use
There is only the one that I’m aware of for Windows and that’s the excellent ZX-Blockeditor. It allows you to load in a .TAP or a .DSK file and extract any of the files contained within the image. If it’s a program file, binary file, or an array (numeric or string), it will be listed in the window.
The example below is from a recent quiz game (released in 2025!) which used string arrays to store the questions and answers used. String arrays in ZX-Blockeditor are denoted by the DATA$ that appears before array’s filename.
(I’ve blurred out the locations of where I store these files, mainly because my working folders are, shall we say, a little messy!)
ZX-Blockeditor allows you to split the arrays into two parts. You then right-click on a the array’s contents, labelled as Standard data, and save off just the data block part as a array into a separate file. Nice and easy!
There are tools (Python-based) available from zxtaputils which do multiple functions, including tapsplit and tapextract. So if you’re comfortable with using Python, then try these.
If anyone is aware of any other tools (DOS, Windows, Mac, Linux) that will extract arrays from tape or disk images, please let me know.
(I’m sticking with the above tool because it’s easier to use and involves less typing on a command line!)
Exporting the array(s) as binary files
Before we can poke around the data contained within the array file, we need to extract it into a binary file that we can then open and view the contents of.
Right click on the part of the array file that states it is “Standard data”, then select the Export as … option, then select the Export as binary file (*.bin) option.
The usual Windows file dialog will appear and find somewhere safe to store this file. If there are multiple arrays in the game, you might as well extract them all. I tend to give them the same array name as they had in the original tape (or disk) image, but that part is up to you.
Prodding around
So you’ve got your BIN file(s) extracted. Now what? Open them up in a text editor first and see if you can spot the general layout of the array.
Based on the above, you can tell that there’s no encryption being used to hide the contents of the array from the end user. Probably because they weren’t expecting anyone to prise the files open and have a look inside.
From the above screenshot we can work out that there’s the question first, with extra spaces being used to pad the text out so that it can be displayed on a few lines due to the ZX Spectrum’s 32-character screen display. After the question mark there seems to be four possible answers, then there’s a 3-digit code (two numbers, followed by a letter). These are all stored in a single column and because the answers always start at a particular position, the game knows where to find them – and how small they need to be.
Not every game will store its arrays like this. Others might use more columns, e.g. 1 column for the question, 4 more columns for the separate answers.
To help extract this data and convert it into a usable format (e.g. Excel or a PDF), we need to work out how many columns are in this array and what is the width of each one.
These parameters are stored in the first 9 bytes of the BIN file and are not visible in a text message. The next section will show you where these parameters are stored.
Hex Editor view
Open the .BIN file in your hex-editor next. We’re interested in the first few bytes as they will tell us some useful information about rebuilding the array.
(Note: I use WinHex to view my files, your view will be different if you’re using any other hex editor tool.)
Because the display shows ASCII characters, you can assume that this is a string array and not a numeric one.
The header states (based on the information at the top of the file) that this file contains 2 arrays ($02 appears as the first byte), followed by $27 (39) rows and each row contains $CD (205) characters.
The ZX Spectrum BASIC definition would be something like: DIM q$(39,205).
Pseduo Loops
This simple BASiC loop would traverse through every character
' myarray$ is the question and answer array set to (39,305). The assumption is that you've
' loaded the data from the file into the array beforehand.
FOR rows = 1 TO 39
FOR column = 1 TO 305
character$ = MID$(myarray$(rows), column, 1)
' Process the character here
' PRINT character$; ' (example)
NEXT column
NEXT rowsDepending on the flavour of BASIC that you are using, you can optimise the above heavily and just loop through the rows then do any string manipulation on the whole line of data.
Python scripts by Ian (aka SToS)
I wish I’d asked Ian (aka SToS) from Atari Forum to help out much earlier than I did. He sent me some of his Python scripts to help me extract the data from Crossword Puzzler, and I’ve been requesting more and more features ever since.
Using the information found in the header (see previous section), Ian’s scripts run through the BIN file and reformat the output in a “sort of” CSV file. Instead of using commas as a delimiter, the script uses the olde worlde | (pipe) symbol.
Note that this isn’t a strict CSV format. The only commas that might be visible are those that are part of the question text. Using a different symbol instead of the comma helps to preserve the original content.
The resulting file, once processed through the Python script, now looks like this:
<screenshot to follow>
When you import the extract files into Excel, or whatever spreadsheet tool you preder, you use the Text To Data function to split the extracted data back into columns based on where the | symbol appears.