TANGLEWOOD Tech Demo 0.1.04 Released

A fresh demo of Tanglewood has been released, showing off some big changes, brought to you by our newly formed, Kickstarter funded team!

Click to reserve your Tanglewood cartridge for SEGA Mega Drive

Tech Demo 0.1.04 marks a significant milestone in Tanglewood’s development. We’ve now completed considerable work upgrading the engine, editor and toolchain which will boost our productivity and enable us to realise some big features on our wishlist. We’ve used the updated tools to re-implement most of the existing work to a far higher standard than the original demo, and we hope it shows!

The demo is still only a small slice of what’s to come. It shows off one of the nine environments in Tanglewood, and only one of the six enemy types we have planned. We have a big bag of mechanics and tricks and puzzles ready to roll out for the other levels, and hopefully we’ll be able to show some of those off soon!

Download the demo ROM here: http://www.mediafire.com/file/as5beiw709o141f/TANGLEWD.BIN

The ROM has been tested with all major emulators, but naturally, we recommend you play on a genuine SEGA console 😉

Megafounder Continued Funding

We’ll be using our new demo release to drive a promotional campaign to see the end of the Megafounder funding stage off with a bang, and hopefully reach that last stretch goal for the SEGA Dreamcast HD conversion!

We’ll be running the continued crowdfunding for around 4 weeks following this release, before we close it down and start counting the materials needed for manufacture.

As usual, please lend us a hand spreading details of our continued campaign, by sharing this link around: https://www.megafounder.com/tanglewood


SEGA Mega Drive Assembly Programming Workshop at GameCity Festival

I’ll be running a workshop teaching the basics of 68000 assembly language and the SEGA Mega Drive at this year’s GameCity festival! It’s on Thursday 27th October, 11am – 2pm, at the National Videogame Arcade, Nottingham, and will last for around 3 hours.

Who is the workshop for?

  • Those who have never written a line of assembly before
  • Those with little or no understanding of how a CPU works
  • Some higher level programming experience is required – functions, variables, logic and flow, signed and unsigned numbers
  • Some higher level debugging experience is required – breakpoints, stepping, watch windows, swearing
  • A basic understanding of binary and hexadecimal numbering is recommended (I’ll provide a quick refresher, though)

What will be covered?

  • The basics of the 68000 CPU
  • The basics of 68000 assembly language
  • Writing your first line of assembly
  • Building your first ROM
  • Debugging assembly
  • Basic arithmetic, branching, looping, and logic
  • Initialising the SEGA Mega Drive
  • The Mega Drive Video Display Processor
  • Programming the VDP
  • Palettes, tiles, maps and sprites
  • Turning the screen pink!
  • Creating a font
  • Displaying “Hello, World!”
  • Porting Crysis 3

What will you need?

Tanglewood Tech Demo 0.0.11

I’m pleased to announce the very first tech demo release of Tanglewood!

The demo represents the first milestone in Tanglwood’s development. It is a proof of the engine, editor, toolchain and content pipeline, the basic mechanics of the game, controls and platforming behaviour, the art and animation styles, and some early puzzles.

These two levels have been a sandbox for mechanics and puzzle testing since development of the game began, and with a little work they’ve been turned into functional showcases for Tanglewood’s early progress.



This is a prototype of a game in its very early stages of development. Some assets are placeholder, and all tech is a work in progress. The look, feel, quality and feature set may not be representative of the final product.

The tech demo contains tests of the following features:

– Nymn: basic movement and platforming, sleep/wake up behaviour, running, walking, jumping, pushing (animation missing), rolling, gliding, death
– Fuzzls: all alert states, physics, and rolling behaviour
– Djakk monsters: initial encounter logic, A.I. behaviour tree, tracking, attacking, search patterns
– Colour abilities: yellow (glide) and green (time slow/cloak)
– Flues: varying output velocities and hold durations, multiple occupants, linked flues
– Boulders: physics, rolling behaviour, cracking and respawning
– Director Cam cutscenes
– Time of day system
– Static blockades



It’s an early tech demo/prototype, so expect to see these problems and more:

– Missing fall animation
– Missing push animation
– Framerate drop during Djakk monster encounter in Level 1
– It’s possible to get Fuzzls stuck against walls if they’re rolling fast enough to jump over flues
– It’s possible to get the Fuzzls in Level 2 stuck by rolling them back to the flue at the start
– The Djakk in Level 2 can reach the flue on the right-hand side if left alone in search state for a long time
– It’s possible to get Nymn to sleep in mid-air by jumping at the end of a level
– It’s possible to push the boulder in Level 2 whilst using time-slow ability (boulder won’t animate)
– Footstep sound effects take priority over others, which may result in some SFX cutting out whilst running (ambience, Fuzzl SFX)
– Many known sprite/background draw priority glitches, and tile flipping errors
– Dead Djakks use the older placeholder palette (yellow feet/teeth)
– Occasionally the wrong instruments are chosen for an SFX (emulator only)
– Double-tapping C with the cloak ability will choose the wrong palette



Download link over at the Tanglewood forum

Tanglewood: Introducing Djakk Monsters

Introducing Djakk Monsters

There’s a reason our friend Nymn is so keen to get back home before dark. That reason is a huge, snarling, fearsome beast that emerges from its cave at night, with the blood of its last victim still dripping from its teeth, and an insatiable appetite for Nymn’s face.

djakk_0Djakk monsters have been a threat to Tanglewood for as long as its inhabitants can remember. The lore speaks of an ancient tribe of hunters who saddled them up and rode them right to the edge of the forest, hunting the Djunn kind for as far as they could smell. Long gone are the bad rulers of the lands, but their big ugly pets remained.

A Djakk fight is a long and drawn out challenge, they are expert trackers and will chase Nymn to the ends of the Earth for a taste of his innards. As the player you must be quick, be forever wary of the Djakk’s presence (however much you think you’ve lost it underneath you), and never underestimate their ability to break through obstacles or foil your traps. They’ve seen it all before.

Getting rid of a Djakk will need to be done in different ways for each encounter. In the demo I’ve been working on, a precariously placed boulder is primed ready to drop on the unsuspecting beast’s head, but that’s just a set-up scenario to show off the mechanics quickly. The monster will roar on sight, then immediately give chase, but if he loses you he will wander over to the last place Nymn was spotted to sniff out your tracks. This can be used very much to your advantage, as a way to coax a Djakk into standing on a particular spot – as long as you’re cunning in your escape.


I have plans for some of the Djakk encounters to last entire levels, and maybe more. They provide an interesting narrative reason for keeping the forest floor out of bounds until the creature has been defeated. Flues, Fuzzls, and all other tricks and traps inhabiting the surface would be unusable, making whole sections of the game, pickups and secrets inaccessible unless Nymn figures out a way to dispose of his unwelcome companion. More importantly, Nymn is looking for somewhere to sleep to wait out the rest of the night terrors, and with this thing around it’s unlikely there will be anywhere safe to rest.


The Djakk posed quite an early technical challenge for the game engine; it’s the largest sprite sheet in the game so far, which is costly both in subsprite count and bandwidth to transfer animation frames. Many of the routines featured in my Mega Drive coding tutorials for sprite management were too slow and naïve in implementation, and it’s taken me quite a while to rewrite them to cope with these huge creatures. The work has certainly paid off, I’m quite proud of our Djakk so far.

Future plans for the Djakk include the ability to traverse the terrain, perhaps being able to leap across a crevasse or run up a ramp to reach higher. There’s also the possibility of weak tree branches, both as an added threat to Nynm and an advantageous point to coax a Djakk onto, to see it fall to its death. For the moment we’ll be keeping it simple, this huge sprite sheet is tricky for our artist to maintain, so we’ll squeeze what we can out of the animations available first.

See the ugly fellow in action in this short demo video:


Tanglewood: Colour Switching

Colour is everything in Tanglewood. It is a life force that can be given, shared, stolen, or used as currency.

Every animal and plant in Tanglewood has a distinct colour, and that colour may play an advantage or disadvantage to the player. The organic world may respond in a positive manner if Nymn is a matching colour. For example, a length of twisted vines blocking your way may open up for Nymn if you find a way to switch to the same colour, or even move or entice a matching coloured creature to sit next to it.

Monsters may behave differently depending if you are a matching or opposing colour, and will either give chase or hang back on the assumption that you are a member of their pack.

In Nymn’s case, his colour is his power. Born a red fellow, he can’t do many things by default, but when transformed into a blue, green or yellow creature his world is opened up to bigger and better possibilities.

In the previous article I mentioned that the humble little Fuzzls will reward Nymn for helping them back to their nests. A Fuzzl will allow Nymn to take its colour for himself, transforming Nymn to match, and allowing him to use the special ability provided by that colour.


This week we’ve been implementing Nymn’s first power colour – yellow. This particular colour gives Nymn the ability to glide over long distances to previously unreachable areas.

Here’s a clip:


Tanglewood: Introducing Fuzzls

Introducing Fuzzls

Tanglewood’s world is alive with the strangest of creatures, from little to large, good to evil. The Fuzzl is a neutral, furry, confused, and easily startled member of the club.

fuzzl_64_blueFuzzls began life in a tech demo for a physics game written back in my University days, and since then they’ve been crammed into almost every game design I’ve been a part of, but until now have never made it past the concept stage and to fruition. They’ve finally found their permanent home in Tanglewood, or not, seeing as they too are lost from home, and need Nymn’s help to get back to their nests.

Fuzzls sleep at night, come back during the day!

Fuzzls sleep at night, come back during the day!

Nymn can roll these little ones (if they’re awake…) back to their nests. The Fuzzls dish out handsome rewards for your efforts, but those details will come in a later post. They can also use Flues; if you drop a terrified and unsuspecting Fuzzl into one, they’ll fling sky high up into a tree branch!

Fuzzls aren’t the smartest of creatures, but they play a large role in Tanglewood, and have quite a history. They were once domestic pets of various races, including the Djun. Some of the more advanced – but now extinct – species used Fuzzls to power contraptions, as counterweights for lifts and hoists, and even to hug for stress relief, but now they’re left alone to live out their lives sleeping, or getting startled by their own shadows.

Nobody knows what they do, what they eat, how they mate, what goes on in their little minds, if they can communicate, or how they still exist as a species without being able to perform basic functions of their own. They just… are.

I’ve captured a short video showing a Fuzzl’s basic behaviour. It’s in its early prototype stages so there are a few quirks to sort out, but the basics are all working. Enjoy!


Tanglewood: Introducing Nymn

Introducing Nymn

Nymn is Tanglewood’s protagonist, a shy creature from a family-oriented species called the Djun race, who survive in packs, live underground, and only emerge during daylight. Night time is dangerous for Nymn and his fellow Djun, since many of Tanglewood’s less desirable characters emerge after dark to chase, intimidate, hunt and eat any strays who should have retreated underground.

Unfortunately, this is exactly the situation Nymn has found himself in. Lost, alone and missing his family, Nymn is desperate to find a way to get back to his underground pack before nightfall sets in and he becomes the victim of a sadistic hunting game, which will almost certainly end in his demise.

Controlling Nymn

NymnThe small teaser video from last week showed Nymn walking through the world for a small glimpse of the environment, but the gameplay itself will be faster paced; Nymn is a quick and nimble creature who can walk on two legs, and scurry along quickly on all four. The platforming experience of Tanglewood is one that I’ve spent a lot of time perfecting – it’s important to me that Nymn’s controls and physical behaviours are accessible and familiar to fans of both legacy Mega Drive titles and the modern platforming games by which Tanglewood was inspired. Since my initial platform code demos in January I’ve added a whole suite of movement features, and spent many hours tweaking and perfecting movement behaviour and response.

There are a lot of variables at play here – walk acceleration, run acceleration, max walk velocity, max run velocity, floor drag, in-air drag, gravity, critical mass, walk-to-run transition speed, forced deceleration, jump impulse, step heights, multiple jump ground heights… you get the idea. There’s a few bits left to do, too, such as a separate acceleration value for controlling Nymn’s left/right movement whilst in air; a practice that has dwindled in favour of physical realism, but was synonymous with platforming games at the time and would be sorely missed.


Nymn’s animations are something that we are very proud of. The character design has been through several iterations, and endured many tiny tweaks in order for it to appear as smooth as the hardware allows, and we hope it shows. There’s still a lot of work left to do to iron out some of the creases, but we’re getting there.

I’ll leave you with a small sample of Nymn’s basic movements:



Follow Tanglewood on Twitter: @tanglewoodgame

Introducing Tanglewood – an Original Title for the SEGA Mega Drive

UPDATE 2: Play the Tanglewood Tech Demo! Go here:



UPDATE 1: Looking for gameplay? More info here:





Introducing Tanglewood

Tanglewood is a new and original platforming title for the SEGA Genesis/Mega Drive, which lends inspiration from games like Limbo, Abe’s Oddysee, Flashback and Another World. It’s a dark and moody tale that follows the life of a creature who has gotten lost after dark – a dangerous thing to do in Tanglewood’s world – and a struggle to get back home to safety.

The game features a familiar 2D platforming experience to Mega Drive veterans, a world full of interesting characters, creatures and enemies, puzzles and traps, a day/night time cycle, and a charming story.


Tanglewood is being developed in pure 68000 assembly language, using a Cross Products development kit (1993 model) and custom tools.

I’ll be revealing characters, mechanics and lore gradually, but here’s a brisk walk though the basic environment which shows off day/dusk/night cycles, falling leaves, fireflies, and the game’s protagonist, Nymn:

Follow @tanglewoodgame on Twitter for updates!

Sega Megadrive – 10: Sound Part I – The PSG Chip

Okay, despite my promises of regular updates I’ve fallen a little behind, and you can thank a short holiday, music festivals, my Real Job™, and many many videogames for that.

Welcome to the first article in the Sound series! Being a full-time audio engine programmer, game audio is a subject very close to me, so this should get quite tasty. One of the most nostalgic and fondly remembered parts of my childhood were the soundtracks accompanying my favourite games, many of which I still find technically impressive, especially considering the machine’s audio capabilities didn’t really weigh up to those of its competing consoles, requiring the sound designers to squeeze so much out of so little.

There are three chips which can create, or are involved in the creation of sound in the Megadrive:

The PSG chip

The Programmable Sound Generator, the same Texas Instruments SN76489 chip used in the Sega Master System. It’s a simple device, comprising 4 mono channels – 3 channels generate a square wave at varying frequencies, and the 4th is a white noise generator. Each channel can have its attenuation modified, and the frequency of the wave or density of the white noise.

It’s got a good trick up its sleeve – you can set the wave generators to stick at +ve, then switch the attenuation registers high and low very quickly to make it behave like a 1-bit DAC, meaning it’s capable of playing PCM data. It won’t win any sound quality awards, and with the available memory I doubt it could stream entire soundtracks, but it can pull of some short voice overs and sound effects which can’t be synthesised.

The FM chip

The Yamaha YM2612 – a stereo, 6 channel sound chip with lots to brag about. 6 FM voices with 4 operators each, Yamaha synthesizer patch compatibility, envelopes, a distortion oscillator, two built-in timers, and a DAC for playing 8-bit PCM data.

Each ‘operator’ of a channel has an input and output (from and to other operators, or the final output), a frequency and an envelope. These operators can be routed in various formations to create algorithms suited for different instrument types (harp, strings, flute, brass, xylophone, piano, organ, guitar and various percussion). It’s quite a complex beast and requires some serious effort to get anything other than basic beeps out of it, but I’ve found plenty of documentation and examples so hopefully I can get it singing.

The Z80 chip

The 8-bit Zilog Z80, which was the Sega Master System’s main CPU, made its way to the Genesis both for backwards compatibility and as a slave CPU to the 68000. Neither of the sound chips can be programmed and left to get on with it, they need their hands holding for the whole session, having data fed to them constantly. This would be quite a pain to manage on the 68k, and it would be impossible to keep up a feed of PCM data whilst trying to process an entire game at the same time, so the Z80 can be used as a secondary CPU for managing the audio. Unfortunately, it doesn’t have any knowledge of the sound chips or how to operate them by default – we need to write our own sound driver (a sequencer, and a program to feed PCM data) in Z80 assembler, generate a binary and load it on startup. This means learning another assembly language, but I’m certainly up for the challenge.

Programming the PSG

I won’t jump straight in the deep end and write a Z80 audio driver just yet, I need to get a handle on the basics. This article covers the simplest case – operating the PSG from the 68000.

The PSG has 4 channels3 square wave generators and 1 white noise generator. I’ll concentrate on just the wave generators to begin with. Each channel is controlled by 2 registers: one for the attenuation, and one for the wave generator’s counter reset. The attenuation registers are 4 bits in size, allowing 16 possible volume values, from 0x0 (no attenuation; full volume) to 0xF (full attenuation; no volume). The counter reset registers are 10 bits in size, and store the square wave’s time until the polarity of the output is flipped in clock ticks / 16 (essentially the “wave width / 2”).

So, assuming an NTSC setup with a clock frequency of 3579545 Hz, a register value of 0xFE would generate a square wave at a  frequency of 440.4 Hz (3579545  ÷ (2 x 16 x reg value)).

To program the PSG, we write to its control port at 0x00C00011, one byte at a time. The most significant bit is the latch, telling the chip that this is the first or only byte it’s expected to receive. Bits 6-5 mark the channel ID (0 – 3) that we’re about to modify. Bit 4 indicates that we’re writing either the attenuation value or wave/noise settings. That leaves 4 bits for the data, which may or may not be enough. If there wasn’t enough space, we send a second byte with the latch bit OFF, indicating it contains the remaining data and is not a new command, with the upper 6 bits of data in bits 5-0.

So, a quick recap:

First byte:
Bit 7    : Latch. ON indicates this is the first (or only) byte being written
Bits 6-5 : Channel ID (0-3)
Bit 4    : Data type. ON if data bits contain attenuation value, OFF if they contain the square wave counter reset
Bits 3-0 : The data. Either all 4 bits of the attenuation value, or the lower 4 bits of counter reset value

Second byte:
Bit 7    : Latch. OFF indicates this is the second byte, and will only contain the remainder of data
Bit 6    : Unused
Bits 5-0 : Upper 6 bits of data

So, let’s make channel 0 produce 440.4hz. The first byte needs the latch ON (to indicate it’s the first byte), the channel ID, the data type bit OFF (to indicate we’re writing a counter reset value), and the lower 4 bits of the value 254. The second byte needs the latch OFF (it’s the second byte), and the upper 6 bits of the value 254.

They’re written to the PSG control port at address 0x00C00011:

move.b #%10001110, 0x00C00011 ; Latch ON, channel 0, counter data type, lower 4 bits of data
move.b #%00001111, 0x00C00011 ; Latch OFF, upper 6 bits of data

The channel will have been initialised fully attenuated, so we need to turn the volume up to hear anything. The attenuation is specified in 4 bits, where 0 is fully attenuated and 16 is full volume, so we can fit the command and data in a single byte. Latch needs to be ON, channel ID is 0, data type bit ON to indicate attenuation data, followed by the 4-bit value:

move.b #%10010000, 0x00C00011 ; Latch OFF, channel 0, attenuation data type, 4 bits of data

Immediately after writing, the PSG will emit a constant tone of 440.4hz, at full volume.

A poor man’s sequencer

Even with just one feature of the PSG covered, it’s enough to make a basic tune. By defining an array of counter reset values, with sustain times, we can iterate over them and play the notes. Here’s some example data – it’s one crudely written line from Scott Joplin’s The Entertainer. Each “note” is 32 bits in size, the first word is the sustain time in vsync frames, and the second word is the counter reset value:

   dc.w 0x0010, 0x02f8, 0x0010, 0x02cd, 0x0010, 0x02a5, 0x0010, 0x01aa, 0x0008, 0x0000 ; D3 D#3 E3 C4 .
   dc.w 0x0010, 0x02a5, 0x0010, 0x01aa, 0x0008, 0x0000 ; E3 C4 .
   dc.w 0x0010, 0x02a5, 0x0010, 0x01aa, 0x0010, 0x0000 ; E3 C4 .
   dc.w 0x0010, 0x01aa, 0x0010, 0x0193, 0x0010, 0x017c, 0x0010, 0x0152, 0x0010, 0x01aa, 0x0010, 0x017c, 0x0010, 0x0152, 0x0008, 0x0000 ; C4 C#4 D4 E4 C4 D4 E4 .
   dc.w 0x0010, 0x01c4, 0x0010, 0x017c, 0x0008, 0x0000 ; B3 D4 .
   dc.w 0x0010, 0x01aa ; C4
 chan0_notes_len equ chan0_notes_end-chan0_notes
 chan0_notes_count equ chan0_notes_len/4

In order to play it, we loop over the notes, apply the counter reset value to channel 0, and wait for the defined amount of frames. It’s pretty simple:

 move.b #%10010000, psg_control ; Channel 0 full volume

 lea chan0_notes, a0            ; Notes to a0
 move.l #chan0_notes_count, d1  ; Number of notes to d1
 subi.l #0x1, d1                ; -1 for counter


 move.w (a0)+, d0       ; Delay to d0 and inc. pointer
 move.w (a0)+, d2       ; Counter reset to d2 and inc. pointer
 move.b d2, d3          ; Lower byte of counter reset to d3
 and.b #%00001111, d3   ; Clear top nybble (leave lower 4 bits)
 or.b #%10000000, d3    ; Latch bit (7) on, chan 0 (6-5), tone data bit (4) off
 move.b d3, psg_control ; Write to PSG port

 move.w d2, d3          ; Counter reset to d3 again
 ror.w #0x4, d3         ; Shift right 4 bits
 and.b #%00111111, d3   ; Only need bits 5-0 (upper 6 bits of the 10 bit value)
 move.b d3, psg_control ; Write to PSG port

 move.l d1, -(sp)       ; Backup d1
 jsr WaitFrames         ; Delay frames is in d0
 move.l (sp)+, d1       ; Restore d1

 dbra d1, @NextNote     ; Branch back up to play the next note

 move.b #%10011111, psg_control ; Finished - silence channel 0

It’s a good start, but it will need many improvements. At the very least, it should support all three square wave channels, and a higher frequency timer. Also, each note should come with a “note on” time, so we don’t need to create “empty” notes for silence, and instead have arbitrary start times. To make it more advanced, we could implement software ADSR envelopes to bring some life to each note with a softer attack and a fade out.

I’ll be building on my sequencer with each new sound feature I learn, and I have plans to write an authoring tool to compose music on a PC, instead of looking up the frequency of each note, converting it to a counter reset value and manually typing it into a text editor! The sequencer will eventually need translating to Z80 assembly language, too.

Well, this was quite a short article, I’ll try and pick up the pace again soon. I’ve missed out the white noise generator, but to really show it off I need to add some finely tuned support to my sequencer for it, so perhaps it deserves – along with many sequencer improvements – a post of its own.



Assemble with:

asm68k.exe /p soundtest.asm,soundtest.bin