Community > Off Topic

 Memory-saving tricks in software of the 80's

(1/2) > >>

marcm200:
I recently learned about some tricks, software developers employed for the Amstrad game Elite in the early 80's when memory was a concern back then.
(from a german podcast: https://www.stayforever.de/2014/09/folge-37-elite/

Does anyone know of further such brilliant ideas from other software?

Elite is one of my favourite games from the 80s. You're a starship pilot, flying the universe, trading goods and shooting enemies to climb the rating ladder of traders.

Trick 1
The developers use a system of 2-letter syllables that - in any combination - sound like alien planetary names. With that method they could just store a short bit pattern for every planet instead of a longer character string (La-ve, Le-eh-ti).

Trick 2
For the galaxies, the planets and where which goods are tradable and to what price, they use a (system of) equations, where, when a different seed is entered, a different bit string results that is interpreted as the desired planet (I haven't figured that part out yet). Sounds almost like a compression method to me.

It would be interesting to use the classic quadratic Mandelbrot equation to form such a planetary system - with different seeds and different max it resulting in different alien systems :)



Linkback: https://fractalforums.org/index.php?topic=3526.0

gerrit:
Reminds me of the SMTP greeting: HELO

hobold:
Elite was procedurally generated. It was not the first game to do this. Pitfall was procedural, M.U.L.E.'s maps were procedural, too, for example. It was a common technique to work around the limited amounts of mass storage and main memory. It wasn't called "procedural" back then. And it isn't called "procedural" today, because today that word implies the (frequent) generation of fresh game content. Back then games re-generated a fixed set of game content, pre-selected by the game makers.

Initially, the procedural generators were flawed. They would sometimes create unplayable or otherwise buggy game content. That's why the game designers restricted their games to a small, hand picked subset of possible creations.

Later, in the 16 bit home computer era, procedural generators could be more sophisticated. They started to generate content with guarantees of playability and variety. I remember "Seven Cities of Gold" as my first encounter with a game that could create an entire new game world from scratch after you had played through the initial campaign (which was a manually created map of South America, if I remember correctly).

But most of the experimentation and exploration of possibilities was done outside the commercial video game industry. Rogue, Hack (and particularly Nethack) were all about procedurally generated dungeons as their core game mechanic. Some really weird experimentation continues until this day - I believe it was here on FractalForums that I was made aware of "Hyperrogue", which is set on the hyperbolic plane.


Data compression techniques are being employed, too. One of Sony's God of War games did some really heroic feats internally to let the Playstation shine in its brightest light. For example, it encoded a few extra bits of information by making intentional choices about the order in which they stored the three vertices of each surface facet. It is no coincidence that the end credits roll several hundred names. The Cell Processor was powerful, but a lot of ingenuity was necessary to overcome its limitations.

marcm200:
Very interesting, thanks for the explanation. I wasn't aware that this method was so widespread and had never heard of it before.

But back in the 80s, my programming skills were at the beginner's state. I remember being very proud having managed to stop a text adventure from loading from datasette and look at the BASIC code lines to see which commands to enter where actually understood by the parser (I think the game's name was Thor trilogy with a guy named Llywenhuf or so), but it didn't help solvin the task :)

marcm200:
A little computer experiment I'm conducting right now.

The "hello world" polynomial:

\[
f(x) = x^6+3x^5+394x^4+416x^3+234x^2+293x+258
 \]

\( f(466) = 10324913503655364 \) which can be interpreted to represent "hello world" by considering the binary bit string of the function value, split into groups of 5 bits taken as an entry to an alphabet. In a sense this is a procedural method, as there is another text hidden in the formula.

\( f(1262) = 4050368722319510032 \) which reads "cykl_tiffanyy" containing the name of an 80's female singer.
                       
The latter was put there by rearranging the alphabet as the two words are disjoint, so after constructing the polynomial with "hello world" I could freely move the alphabet at some points around to fit the desired letter shape without changing hello world's function value.

My goal here is to construct a polynomial for galac's minuscule Mandelbrot code https://fractalforums.org/programming/11/small-mandelbrot-set-in-c/2658/msg13599#msg13599 which only has 165 characters. I hope to get a function with not too many coefficients. For that I have to find an easy (or best not-to)-install BigInt library or try to write a maxima script to get the desired precision.

Navigation

[0] Message Index

[#] Next page

Go to full version
Powered by SMFPacks SEO Pro Mod | Sitemap
Powered by Advanced Topic Prefix Pro
Powered by SMFPacks Rates (Facepunch) Mod
Powered by SMFPacks Advanced Attachments Uploader Mod