• Skip to primary navigation
  • Skip to main content
  • Skip to primary sidebar
  • Skip to footer

Retro Rendezvous

Connect, Collaborate and Code

  • Home
  • Recommended Resources
  • About Me
  • Contact Me
  • en EN
    • en EN
    • es ES

Paul Bussey

Mythic Map

February 11, 2026 by Paul Bussey

Run straight away in Owlet – click below…

Run Mythic Map

🧭 Mythic Map – Essential How to Play Guide

Objective:
Find the Iron Crown, hidden somewhere in the ruins or buildings of a procedurally generated 20×20 world.

You begin in the centre of the map with 50 supplies. A yellow @ symbol shows your player position when you view the map.\

🎮 Controls

N / E / S / W — Turn to face a direction

T — Travel forward one tile (in the direction you’re facing)

M — View the map

G — Generate a new world

Q — Quit

You always move forward — turning changes your facing direction.

👀 What You See

Each turn, the game describes:

  • Your current location
  • What lies immediately ahead
  • What lies further in the distance
  • What can be seen on the horizon

Occasionally important features to your left or right

Think of it as surveying the landscape from your position.

🥾 Supplies & Survival

  • Moving consumes supplies.
  • Rough terrain (forests, hills) costs more.
  • Roads may cost less.
  • Some terrain is impassable.
  • If supplies reach 0, the game ends.

🏨 Replenishing Supplies

  • Find a Coaching Inn (marked as C on the map).
  • When you step onto an Inn:
  • You automatically rest.
  • Supplies +10

Plan routes carefully — Inns are your lifeline.

🗺 Map View

  • Press M to see the full map:
  • Terrain types are colour coded.
  • Your position is marked with “@”.
  • Inns are shown as a Magenta “C”

🏆 Winning

  • Locate the hidden quest location (in a ruin or building) to recover the Iron Crown and win.
  • Explore. Conserve supplies. Use Inns wisely. Survey the land before moving.

That’s all you need to begin.

Development and High Level Code Walkthrough

There’s a very deliberate lineage behind Mythic Map.

Years ago I was fascinated by the way The Lords of Midnight by Mike Singleton handled scale and perspective. It showed you what you could see from your position — mountains looming in the distance, forests rising beyond hills — all rendered through clever layered graphics on very limited hardware. You’ll see from one of my earlier projects in this Stardot subforum post “Landscaping” is a very simple version of this.

Mythic Map takes that same core principle — but applies it to text.

Instead of scaled bitmap landscapes, we now generate “scaled” narrative description:

  • Immediate foreground (1 tile ahead)
  • Mid-distance (2 tiles)
  • Horizon (3 tiles)
  • Side scanning for “important” landmarks

It’s essentially using the idea of Landscaping from The Lords of Midnight, distilled into MODE 7 prose.

Design Philosophy

The key idea:

The world is not just where you stand. It is what you perceive.

That’s why PROCLook is the heart of the game.

I’ll stay deliberately high level here.

[b]1. Setup & Data Structures[/b]
DIM M%(19,19)
DIM N$(6,5)
DIM VOC$(9), VAGUE$(6), PHR$(3)

M%(19,19) – The world grid (20×20).

Each cell encodes:

  • Terrain type (tens digit)
  • Subtype / progression stage (units digit)

N$() holds terrain names.
VOC$() adjectives.
PHR$() distance phrases.
VAGUE$() horizon descriptors.

This is lightweight but powerful: small data tables, combinatorial output.

PROCMakePath

The world is procedurally forged in layers:

  • Base terrain (woods vs hills)
  • Rivers carved with a directional path
  • Roads laid similarly
  • Ruins & buildings scattered
  • Quest location hidden in valid terrain

This is intentionally fast and replayable.

Notably:

  • Rivers and roads use staged progression (STP%) to simulate widening.
  • Impassable terrain is encoded in subtype 5.
  • Supplies introduce pressure.

This creates:

  • Movement constraints
  • Resource tension
  • Directional decision making

The Core Innovation – PROCLook

This is where the “Lords of Midnight principle” lives.

FOR DIST%=1 TO 3

We scan outward three tiles in the facing direction.
Each distance band:

  • Has different descriptive richness
  • Uses rank filtering (FNrank)
  • Adds side scanning for significant landmarks

The rank system is subtle but key:

DEF FNrank

  • Mountains, keeps, impassables = higher importance.
  • Trees and low features = lower importance.

This prevents descriptive overload while preserving drama.

The result is sparse but evocative and atmospheric!

Travel & Survival

PROCTravel handles:

  • Movement vectors based on facing
  • Impassable checks
  • Supply drain
  • Rest at Inns (+10 supplies)
  • Proximity tension message

Victory condition

This creates the gameplay loop:

Look → Decide → Travel → Consume Supplies → Repeat

Map Rendering


PROCPreRender builds colourised MAP_ROW$ strings.
It uses:

  • Character tables
  • Colour tables
  • Special overrides (e.g. Inn = “C”)

This means:

  • The map draws instantly.
  • No recalculation during display.

What’s Working Well

The perception-based viewing model.

  • Distance layering.
  • Importance ranking (I think)
  • Procedural naming of rivers and roads.

Resource pressure loop.

Clean modular procedures.

Where It Needs Work

The English descriptions are functional — but not yet mythic.

Examples:
“Directly ahead, ancient a Forest awaits.”
“On the horizon, dark shapes can be seen.”

They work mechanically.
But they lack rhythm, cohesion, and narrative tone….so if there’s enough memory I think these could be improved.

What we need:

  • Better grammar flow (for sure)
  • Perhaps less repetition.
  • Stronger atmosphere?
  • Even occasional surprise phrases.
  • Maybe even variation in sentence structure.

Filed Under: BASIC Programming, BBC Micro B Tagged With: BBC Micro

2026 01 : Falkirk, Business Hub – The I.T. Crowd (Scotland)

January 22, 2026 by Paul Bussey

Retro Computing Day at Falkirk Business Hub – January 17th, 2026

IMG_0978
IMG_0979
IMG_0980
IMG_0981
IMG_0982
IMG_0983
IMG_0984
IMG_0985
IMG_9420
IMG_9424
PlayPause
IMG_0978
IMG_0979
IMG_0980
IMG_0981
IMG_0982
IMG_0983
IMG_0984
IMG_0985
IMG_9420
IMG_9424
previous arrow
next arrow

On Saturday, January 17th, 2026, members of the I.T. Crowd (Scotland) gathered once again for a full day of hands-on retro computing at Falkirk Business Hub.

Although I was organising remotely from Spain this time, the day itself ran exactly as hoped: relaxed, sociable, and packed with interesting hardware, ongoing projects, and good conversation. A big thank-you goes to everyone who came along and helped make the day such a success — and especially to Dave for keeping everyone supplied with tea and taking some photos.

A Day of Tinkering, Testing, and Talking Tech

As ever, not everything went entirely to plan — which is half the fun. One attendee (Steve) arrived having not intended to bring any machines at all, only to wake up with a sudden urge to rebuild an A7000 that morning and test a long-neglected SSD and IDE/SATA adapter. Despite valiant efforts (and a newly replaced VGA cable), it stubbornly refused to cooperate.

Elsewhere in the room, there was no shortage of fascinating kit to see and hear:

  • Gary brought along a prototype sound cartridge for the Acorn Electron, with plans for a Master version too — filling the space with what can only be described as bangin’ choons.
  • Derek showcased mark IV of his heavily upgraded Electron, while Ken was seen proudly surveying his newly acquired, fully-loaded Risc PC, which later apparently made it into his house unnoticed.
  • Steve spent time upgrading his A7000, while Dave’s Master Compact received some well-deserved attention.
  • Chris demonstrated a particularly intriguing project: a re-creation of the Game Boy Mobile Adapter, restoring online-style functionality that was once exclusive to Japan — all running locally for demo purposes.

Alongside the hardware, the world was thoroughly put to rights. Topics ranged from why war is a bad idea, why AI is… questionable at best, and why Acorn was simultaneously brilliant and bonkers — with the added mystery of why no one ever ordered those fries.

Good Company, As Always

Perhaps most importantly, the atmosphere was exactly what these meet-ups are about: friendly, inclusive, and pressure-free. Some people brought tables full of kit, others brought very little, and everyone brought good humour. Shoes were remembered. Trousers too.

The feedback afterwards said it all — another enjoyable, worthwhile day spent among people who genuinely enjoy retro computing and the conversations that come with it.

Given how well this new arrangement worked, we’ll be looking at running similar days again — possibly every other month. A poll will be shared soon to find a suitable Saturday.

Thanks again to everyone who attended, contributed, chatted, fixed things, broke things, and made the day what it was. More soon.

— Paul (Tosk)

Filed Under: Event

2026 01 : Cordoba, La Zona – Retrobytes Mini Meetup

January 22, 2026 by Paul Bussey

WhatsApp Image 2026-01-21 at 15.49.01 (1)
WhatsApp Image 2026-01-21 at 15.49.01
WhatsApp Image 2026-01-21 at 15.53.39 (1)
WhatsApp Image 2026-01-21 at 15.53.39 (2)
WhatsApp Image 2026-01-21 at 15.53.39
WhatsApp Image 2026-01-21 at 15.53.40
PlayPause
WhatsApp Image 2026-01-21 at 15.49.01 (1)
WhatsApp Image 2026-01-21 at 15.49.01
WhatsApp Image 2026-01-21 at 15.53.39 (1)
WhatsApp Image 2026-01-21 at 15.53.39 (2)
WhatsApp Image 2026-01-21 at 15.53.39
WhatsApp Image 2026-01-21 at 15.53.40
previous arrow
next arrow

On Wednesday, January 21st, 2026, a small group of Retrobytes members gathered for a mini meetup at LaZona Coworking in Córdoba. Designed as an informal, table-level get-together, the morning focused on sharing hardware, solving problems together, and simply enjoying good conversation in a relaxed setting.

Despite being a deliberately small gathering, the atmosphere was warm and collaborative, and it was great to finally bring a few people together face to face. We had lunch at the nearby University Cafe.

Who came along (and what they brought)

  • Antonio José brought along a Raspberry Pi 4, adding a modern twist to the retro mix.
  • Pablo Mañas, a passionate Apple collector, stopped by briefly to talk about his collection. Although he could only stay a short time due to work, the conversation around the future of his collection was particularly inspiring — including the possibility of it one day being used for hands-on exhibition or educational purposes, perhaps even in a small interactive museum setting.
  • José, president of the Retrobytes club, was on hand helping other members with hardware troubleshooting and repair advice, as always generously sharing his experience.
  • FranXisco brought his ZX Spectrum +2, which sparked plenty of discussion and nostalgia.
  • Vitinillo arrived with a 1990s Apple PowerBook as well as his ZX Spectrum, offering a fascinating contrast between eras.
  • Natxo brought a beautifully preserved ZX Spectrum 48K, originally from Seville. He also helped correct the Spanish translation for Exploring Wilderland, a simplified version of the classic text adventure The Hobbit that I originally coded. We discussed the need for a diagnostic board and a reliable way to load software in order to properly test the machine.
  • Paul – brought his Acorn BBC Micro B running the Spanish version of “Exploring Wilderland” ready for translation testing. He also improved his “Space Probe” game re-coding it without the need for the GXR chip.

A morning well spent

What made the meetup special wasn’t just the hardware on the table, but the shared knowledge, curiosity, and willingness to help one another. There were no presentations or formal structure — just people talking, experimenting, and reconnecting around machines that still have stories to tell.

Several members also expressed appreciation for having a calm, welcoming space in which to meet, and for the opportunity to slow things down and focus on conversation and hands-on exploration.

Thanks again to everyone who came along and helped make the morning such an enjoyable one.

You can find out more about the Retrobytes club in Córdoba here:
https://retrobytes.org/

Filed Under: Event

Exploring Wilderland – Map of the Game

January 16, 2026 by Paul Bussey

Google AI Studio has helped me create an exact map of my Exploring Wilderland game.

This includes the starting positions of the NPCs as well as the objects. I say “starting” since NPCs can pick up objects and randomly drop them again. Not all the NPCs move in the game.

https://retrorendezvous.org/wp-content/uploads/2026/01/TheHobbitMapEnglish-scaled.png

Here’s the equivalent map in Spanish:-

https://retrorendezvous.org/wp-content/uploads/2026/01/TheHobbitMapSpanish-scaled.png

Filed Under: BASIC Programming, BBC Micro B

The Hobbit : Exploring Wilderland Completed

January 7, 2026 by Paul Bussey

This is the final version of “Exploring Wilderland” – a BBC BASIC game based on the original “The Hobbit” text adventure game by Melbourne House

This is running in Owlet, so you’ll need to click into the righthand window in order to start typing commands for the game.

Click HERE to run in Outlet

After some battling with logic bugs and memory management, I’m happy to share the working version of Exploring Wilderland.

This is a text adventure running in Mode 7 on a standard BBC Model B. While it looks like a standard adventure on the surface, underneath it’s running a simulation where NPCs (Thorin, Gandalf, Goblins, etc.) are actively competing with you.

Here is the rundown on how to play and a look under the hood for those interested in the code.

How to Play

The Objective:

The game has 10 valuable treasures scattered across 52 locations (from Beorn’s House to the Lonely Mountain). To win, you must find and TAKE all 10 items. Once your inventory holds every treasure, the game detects this and you win.

The Catch:

You aren’t alone. There are a number of NPCs (12 altogether) with some of them wandering the map. They will move between locations, open and close doors, and—most importantly—pick up and drop items. If you can’t find the Valuable Treasure, chances are a goblin (or even Thorin) has picked it up and walked off with it! You might have to follow them and wait for them to drop it.

Commands

The parser is designed for speed. You can abbreviate almost all commands.

The parser is quite basic, so if you use backspace or delete, it won’t recognise a command. Try and get commands typed in right first time!

Navigation: N, S, E, W, U (Up), D (Down), NE, SE, etc.

Interaction:

OPEN (or O): Opens a door if one is present.
CLOSE (or C): Closes a door.
TAKE (or T): Note: This command takes ALL loose objects in the current room. You do not need to type the noun (e.g., just type T, not TAKE SWORD).
DROP (or DR): Drops ALL items you are currently carrying.

Info: LOOK (L), INVENT (INV), SCORE (SC), HELP (H).

Strategy: WAIT (or WA). This passes time without moving, allowing you to see NPCs enter/leave or interact with the room. JUMP (or J) allows you to jump to a random location in the game.

Further Help

The map pretty much follows the original Hobbit text adventure, but the more random parts of the map (stuck in Goblins caves) have been toned down.

You can see the original “Guide to Playing the Hobbit” by Melbourne House to get a sense of all the locations. The location numbers in my game (in the DATA statements) match the location numbers in the book, so if you get lost, then the guide will be invaluable.

Click here for Guide to Playing the Hobbit PDF

Code Insight Under the Hood

For those looking at the listing, here is how we managed the memory on the Model B:

  1. Data Type Optimization

We were hitting memory limits, but rather than making the code unreadable by renaming every variable to A$ or X%, we optimized the data structures.
Originally, door statuses (“Open”/”Closed”) were stored as strings. We converted this to an Integer array (doorStatus%), which saves bytes for every door and is faster to process. We also stripped REM statements to claw back space.

  1. The “Living” AI (PROC_NPC)

The heart of the simulation is in PROC_NPC. Every turn, each NPC rolls a die:
They have a chance to OPEN or CLOSE a door if they are near one.
They have a chance to TAKE items if present, or DROP items if they are carrying them.
They attempt to move to adjacent rooms using the same exit data the player uses.

  1. Two-Way Door Logic

A tricky bug we solved involved doors. In many adventures, opening a door only updates the room you are standing in. In this game, PROC_OpenDoor and PROC_CloseDoor instantly calculate the location on the other side of the connection and update the exits for both rooms simultaneously. This means if Gandalf opens a door from the inside, you can walk in from the outside immediately.

Tweaking the Game

If you paste the code into your emulator and want to mess around, here are the key lines to look at:

Line 280 – Sets the starting location (normally set to 6) – so you can get the game to start in locations 1-52

Change the AI Personality (Line 924)

Currently, the code is: 924 action=RND(4)
This gives NPCs a 25% chance to try Opening, Closing, Taking, or Dropping.
Change it to RND(10) to make them less hyperactive (they will mostly just walk around).
Change it to RND(2) if you want a chaotic game where doors are constantly slamming shut!

Change the Win Condition (Line 670)

Currently, you need all 10 items (LEN(Inventory$)/2=NoOfObj%). You can lower this number if you want a quicker game.

I hope you enjoy exploring Wilderland!

Filed Under: BASIC Programming, BBC Micro B

The Hobbit : Exploring the Wilderland

February 19, 2024 by Paul Bussey

My next BASIC coding project is to squeeze a very simplified version of the classic text adventure game “The Hobbit” by Veronika Megler, Philip Mitchell and David Johnston into a BBC Basic program. This would be for a 32K BBC Model B. I’ll be using the Owlet editor in the main and cross checking the code on my own BBC Micro.

See this Stardot forum post for progress on this project

Like many of you, I enjoyed this landmark game and it stuck in memory. I coded some of my own text adventures at the time and was fascinated with the process….certainly nudging me towards a database programming career later on in life. Let me know some of your own memories, experiences with this game – I’d like to hear them.

This project is mostly for nostalgia, but also taking on the challenge of squeezing a very simplified form of this landmark game into a BBC Basic version. Like many retro coding projects you think …. “Why not?”

My objectives are:-

1. To represent every location in the game in BBC basic, using tokens for the common words to save space.
2. To navigate between all the locations using the original mappings (though I may exclude the random-like maddening mazes such as the Dark Stuffy Passage)
3. To emulate the split screen user interface that the Hobbit had, with input text in the bottom quarter of the screen and output text in the top.
4. To keep everything in one program, not reading other files.

If there’s any memory left (I’ll use MODE 7) then we’ll see what else could be added. It would be fantastic to include NPCs wandering around the game map randomly, such as Thorin and/or Gandalf, so you could meet them as you wander.

My objectives are not:-

1. To have a clever parser. It’s just to input directions, to allow an easy exploration of the Wilderland.

Resources

The book “The Guide to Playing the Hobbit” by David Elkan (which I used to own) which gives a great breakdown of the game (from the internet archive)
https://archive.org/download/guide-to-p … Hobbit.pdf

Veronikia Megler’s website (one of the original authors of the game) includes some really useful information:-
http://veronikamegler.com/WL/wl.htm

– A map
– Room Database dump of the locations
– Even a rudimentary Spectrum emulator, displaying the state of the elements in the game

Using ChatGPT (ver 4)

For this project I’ve been using ChatGPT to start to compile the word tokens and the locations converted into text with token indexes inserted. It’s done quite well with this. I asked ChatGPT to look at this list of locations and pull out all common words that are greater than two characters:-

Beorn’s house
The Bewitched gloomy place
A big cavern with torches along the walls
A bleak barren land that was once green
The cellar where the king keeps his barrels of wine.
A comfortable tunnel-like hall.
A dark dungeon in the elven king’s halls.
The dark stuffy passage
The dark winding passage
The east bank of a black river
The elven king’s great halls
An elvish clearing with levelled ground and logs
The empty place
The forest
A forest of tangled smothering trees
The forest road
The forest road
Forest river
The front gate of the Lonely Mountain
The gate to Mirkwood
A gloomy empty land with dreary hills ahead
The goblins’ dungeon
The great river
The green forest
The halls where the dragon sleeps
A hard dangerous path in the Misty Mountains
A hidden path with trolls’ footprints
Inside the goblins’ gate
A large dry cave which is quite comfortable
A little steep bay, still and quiet, with an overhanging cliff.
The Lonely Mountain
Long Lake
The mountains
A narrow path
A narrow dangerous path
A narrow place with a dreadful drop into a dim valley
Outside goblins’ gate
A place of black spiders
Rivendell
The ruins of the town of Dale
The running river
A smooth straight passage
A strong river
The treeless opening
The troll’s cave
The troll’s clearing
The waterfall
The west bank of a black river
The west side of Ravenhill
A wooden town in the middle of Long Lake

Common words (tokens) that ChatGPT found (here shown stored in DATA statements):-

800 DATA “the”,”with”,”river”,”forest”,”place”,”gate”,”path”,”dark”,”passage”
810 DATA “black”,”goblins'”,”narrow”,”gloomy”,”land”,”green”,”where”,”comfortable”,”dungeon”
820 DATA “elven”,”king’s”,”bank”,”great”,”halls”,”clearing”,”and”,”empty”,”lonely”
830 DATA “mountain”,”dangerous”,”mountains”,”cave”,”long”,”lake”,”town”,”troll’s”,”west”

…and the resulting location descriptions with indexes inserted representing the word token (this was also generated by ChatGPT):-

900 DATA Beorn’s house,01 Bewitched 13 04,A big cavern 02 torches along 01 walls,A bleak barren 14 that was once 15,01 cellar 16 01 king keeps his barrels of wine.
910 DATA A 17 tunnel-like hall.,A 18 dungeon in 01 elven king’s halls.,01 18 stuffy 09,01 18 winding 09,01 east 20 of a 10 03
920 DATA 01 elven king’s 22 halls,An elvish 24 02 levelled ground 24 logs,01 25 04,01 05,A 05 of tangled smothering trees
930 DATA 01 05 road,01 05 road,05 03,01 front 20 of 01 Lonely Mountain,01 20 to Mirkwood
940 DATA A 13 25 14 02 dreary hills ahead,01 goblins’ dungeon,01 22 03,01 15 05,01 halls 16 01 dragon sleeps
950 DATA A hard 18 20 in 01 Misty Mountains,A hidden 20 02 trolls’ footprints,Inside 01 goblins’ 20,A large dry 31 02 is quite 17,A little steep bay, still and quiet, 02 an overhanging cliff.
960 DATA 01 Lonely Mountain,Long Lake,01 mountains,A 12 20,A 12 18 20
970 DATA A 12 04 02 a dreadful drop into a dim valley,Outside goblins’ 20,A 04 of 10 spiders,Rivendell,01 ruins of 01 34 of Dale
980 DATA 01 running 03,A smooth straight 09,A strong 03,01 treeless opening,01 troll’s 31
990 DATA 01 troll’s 24,01 waterfall,01 west 20 of a 10 03,01 west side of Ravenhill,A wooden 34 in 01 middle of Long Lake

Location Exit Data

Each location has data in this format:-

“01202807506605103”

The first two digits are the location, followed by at least one group of 3 digits.

Each 3-digit block represents an exit, with the first digit for the direction (1 for North, 2 for Northeast, etc., 0 for Down, and 9 for Up) and the next two digits for the destination location number

I had ChatGPT read “The Guide to Playing the Hobbit” and had a go at creating the exit data, but it’s pretty bad – and this needs redoing by hand!

I need to:-

a) Resolve a bug with unpacking the room descriptions properly. It doesn’t convert the token value that lies at the end of a location description string into the corresponding word.
b) Go through all the exit data to check and replace as required (done)
c) Allow the input of directions to include shorthand as well as longhand for the directions (North and N for example).
d) Cross check the common word token replacements. I think ChatGPT has made some mistakes.

Filed Under: BASIC Programming, BBC Micro B

  • Go to page 1
  • Go to page 2
  • Go to Next Page »

Primary Sidebar

Recent Posts

  • Mythic Map
  • 2026 01 : Falkirk, Business Hub – The I.T. Crowd (Scotland)
  • 2026 01 : Cordoba, La Zona – Retrobytes Mini Meetup
  • Exploring Wilderland – Map of the Game
  • The Hobbit : Exploring Wilderland Completed
  • The Hobbit : Exploring the Wilderland
  • The Lords of Midnight : Landscaping
  • Notes on Owlet – A Modern BBC Basic Editor
  • Solid State Storage for a BBC Micro
  • Programming Project : Space Probe
  • Using a BBC Micro B with an HDMI Monitor
  • Acquiring a 40 year old refurbished BBC Micro B Computer

Footer

The Venue

We meet at the Falkirk Business Hub.

Learn more about it here

The blog

Learn about my “rediscovery” of the BBC Micro B here in my blog

Recommended Resources

As I discover them I’ll be logging useful resources for Acorn machines HERE.