After dozens of commits, dozens of unit tests, and a whole ton of furniture rearranging, I now have a fully extensible palette management system, and improved state management system, written in assembler for my game. #commodore #amiga #retrocomputing #indiegamedev

Not much in the way of visuals to show this week. My focus has been to flesh out more of the unit test suite, allowing me to fix a few bugs in the process as well as perform some nice optimizations on some oft-called code.

I also discovered a good, extensible approach to building switch statements in assember without using a big list of CMP/BEQ statements, which requires writing lots of code and is also costly execution-wise. Any code I’ve run into that uses the CMP/BEQ approach I’ve been converting to this new approach, which is another reason for no real visuals this week.

The approach comes from a post on English Amiga Board: https://eab.abime.net/showpost.php?p=1548231&postcount=7

The example in the post is specific to the original asker’s use case, so I’ll provide a more generic example for DevPac, along with a unit test written in CuTest for SAS/C:

; switch.asm   ENUM ; MyChoices  EITEM ItemOne  EITEM ItemTwo  EITEM ItemThree   ; make accessible to C  XDEF _MySwitch  ; @inreg D0 enum MyChoices ; @outreg D0 final value _MySwitch:  ADD.W D0,D0 ; jumpTable entries are word sized  MOVE.W .jumpTable(pc,D0.W),D0 ; get the offset from .jumpTargets  JMP .jumpTargets(pc,D0.W) ; go!  .jumpTable:  ; these are in enum order  DC.W .itemOne-.jumpTargets  DC.W .itemTwo-.jumpTargets  DC.W .itemThree-.jumpTargets  .jumpTargets: .itemOne:  MOVE.L #4,D0  RTS  .itemTwo:  MOVE.L #20,D0  RTS  .itemThree:  MOVE.L #50,D0  RTS 

// switch_test.c #include "cutest.h"  enum MyChoices {  ItemOne,  ItemTwo,  ItemThree };  // this looks for an exported _MySwitch symbol uint32_t __asm MySwitch(register __d0 uint32_t myChoice);  void T_switch(CuTest *tc) {  uinit32_t result;   result = MySwitch(ItemOne);  CuAssertIntEquals(tc, 4, result);   result = MySwitch(ItemTwo);  CuAssertIntEquals(tc, 20, result);   result = MySwitch(ItemThree);  CuAssertIntEquals(tc, 50, result); }  void switchSuite(CuSuite *suite) {  SUITE_ADD_TEST(suite, T_switch); } 

This was supposed to be a quick sketch to wrap up a training session but it ended up becoming a full piece of fan art. #mastoart #furryart #skunk #fanart #sabrinaonline

I wrote up a pretty extensive devlog for my infinite runner now that I've started to work out more advanced unit testing techniques for Amiga development in C and assembler: https://theindustriousrabbit.com/blog/2025-01-03-bun-runner-devlog/ #amiga #softwaredevelopment

Faaaaaaaaade in. #amiga #retrocomputing #indiegamedev

Look at that smooth fade in:

The palette manager I talked about on 2024-12-22 is finally plugged in at the right place to allow the game to fade in the palette from black (or, really, any color) when the level starts up.

Interfaces, implementations, and dependencies

As I’m writing unit tests for all this, it’s required me to really think a lot about how to structure everything. Originally, I had mashed together a lot of the implementation details into what I call the Game Screen, the main display of the game. This includes:

• double buffering
• palette color definitions
• the Copperlist definition
• an implementation of “wait for bottom of frame”
• RastPort building for the lower part of the screen for using AmigaOS graphic routines like text drawing

This is a very shallow interface! And these also bring in a lot of dependencies. This makes unit testing difficult, and would make future reuse challenging as well. I ended up splitting out some of the Copperlist handling and the palette definitions to separate modules. The palettes are currently hardcoded via INCBIN, but they’ll soon enough be loaded dynamically for each level, so they need to be in a separate place anyway.

This allowed me to write some very specific tests for the following:

• ensuring a palette fade structure could be built for all three palettes: the foreground, background, and sprite palettes. This structure is essentially a multidimensional array built to be easily iterated in assembler.
• ensuring that I can pick an index in that multidimensional array and set the game screen Copperlist colors from that array data correctly
• walking through the “level starting up” logic, which includes:
  • prepping a bunch of state and setting default copperlist colors
  • pausing for specific numbers of frames in between palette changes or when about to start the game

Mocking Amiga system libraries in unit tests

Testing that the pauses were working correctly was an additional challenge. I actually built out the ability to mock Library Vector Offset (LVO) routines in libraries so that I can call WaitTOF() directly in the code and not have to deal with:

• some hacky solution in the assembler code to allow mocking
• the inability to spy on real library function calls w/o patching the library itself
• undesired side effects in unit tests like having real frame delays

I covered Library Vector Offsets a little bit in my video about revisiting the AMOS Pro BSDSocket code I wrote 20+ years ago, but never went into precise detail as to what they are. Essentially, they are a list of JMP instructions that live at negative offsets from the library’s base that you get from OpenLibrary(). The stuff actually at the library base varies – for the Graphics library, for example, it includes links to interrupts, fonts, and other data you’d want for OS-compliant graphics routines.

Using an LVO in assembler looks like this. There may be some sugar around the JSR call and how you get the LVO, but it all turns into this eventually:

_LVOWaitTOF EQU -270   MOVE.L _GfxBase,A6  JSR _LVOWaitTOF(A6)  ; the next instruction 

A6 is the address register that AmigaOS always uses for LVO-based calls. There’s no technical reason, just convention. JSR is “Jump to Subroutine”, which pushes the memory location of the next instruction onto the stack and changes the code executation location to the provided address. In this case, that address is “whatever is in A6 minus 270”. JSR expects that you’ll eventually RTS, or “Return from Subroutine”, which involves changing the code execution location to the value that’s popped off the stack.

What’s at “whatever is in A6 minus 270”? It’s this:

 JMP <place where the code actually lives> 

JMP is “Jump to Location” and it doesn’t expect that you RTS. However, the code that you do jump to does RTS, which means you’ll end up back where you left off in you own code anyway.

LVOs are always 6 bytes away from each other. Why six bytes? Because that’s how many bytes it takes to hold a JMP instruction:

4EF9 FFFF FFFF ; 4EF9 == JMP, FFFF FFFF == 32-bit (4 byte) memory address 

Check out the chart here for more opcode details: https://info.sonicretro.org/SCHG:68000_ASM-to-Hex_Code_Reference

This approach means you can change the contents of a library function to your heart’s content and not have to worry about updating function calls when you release a new version. The address of the JSR may change, but the LVO won’t (and can’t!).

Library bases in C and Assembler

_GfxBase is another Amiga library convention. C compilers like SAS/C can automatically open and close libraries for you, if they have the right information. When they do this, they normally place the address of the base of the library in a global variable. The name of that global variable comes from the library’s fd file, in the ##base field. That global variable is then used to JSR to the correct LVO and put the function’s parameter values in the correct registers. Look up pragma libcall in the SAS/C Development System Library Reference for details on how that works.

On the C side, if you do nothing but use Graphics library routines, you get that global _GfxBase variable (seen as GfxBase-no-underscore in C because of how variable and functions are made public in C code). With the right included file setup, your assembler routines that use _GfxBase can use either ones your assembler programs open, say in a system.asm file that opens and closes libraries and has that public variable, or the one that just happens to come along with your C unit tests.

So to get mocked Amiga library functions, I:

• create a block of memory big enough to cover the size of the largest LVO call I’m going to make
• place a JMP <address> instruction at each point from the end for each LVO, with the address being the pointer to a mock function in my C test suite
• set the library base to the end of that memory block
• call the library like I normally would in assembler or C

This means that my assembler code under test operates as expected, but now the calls to WaitTOF() are logged and I can treat them as you would any other mock in any other testing framework.

I'm getting better at finding those wrong-sized MOVE and other commands in my M68K code that cause those weird flaky errors. Now to get better at not letting them in in the first place...

A few days late but that's fine. I play through the supplemental content of Night in the Woods.

5th Annual Night in the Woods Longest Night Stream on now! https://makertube.net/w/p9xvVXCKG2Cvokf7boUuaM #nightinthewoods #indiegame #streaming

Perl camel. #mastoart #perl #furryart

Ok I think I will do my Night in the Woods stream tomorrow afternoon around 5PM EST on my PeerTube channel. See you then!

Next piece of the Amiga gamedev puzzle for me was figuring out a good way to fade between arbitrary color palettes. While a fade to/from black is pretty straightforward, I will have some effects that will require moving to/from other full palettes. This was calculated within the assembler code and not pre-calculated, it's fully unit tested so it took way less time to ultimately build, and the module's reusable so I can calculate palettes anywhere, including in the C program running this small demo. #amiga #indiegamedev #retrocomputing

I decided to work on the palette manager, and now I can fade between arbitrary palettes of colors:

The fading algorithm is a slightly tweaked implementation of Bresenham’s line algorithm. I know I built paletete fading code back in the AMOS days, very likely using a ratio approach like this:

The issue is arbitrary multiplications and divisions on the 68000 processor are expensive. Compare the roughly worst-case cycle time cost of MULU and DIVU to MOVE, LSL, and ADD:

• MULU: 70 cycles
• DIVU: 140 cycles
• MOVE.L to/from memory: 8 cycles
• LSL.L: 8 cycles
• ADD.L: 12 cycles

(Values from MC68000 Instructions Timing)

If you’re efficient, you can do a lot of stuff in the time it takes one division operation to take place!

The Bresenham implementation is all fixed point with no multiplications or divisions, and it’s pretty fast. This is also an algorithm I’m sure I’ll come back to a lot in retro development, so I wanted to get good with it:

The unit testing I alluded to in my last post helped out a lot with implementing this. Being able to write code like this to test out the results of the assembler-based algorithm made it way easier to find bugs and discover issues in my algorithm:

void T_buildColorTransition(CuTest *tc) {  uint16_t targetMemory[7] = { 0, 0, 0, 0, 0, 0, 0 };  struct ColorTransition ct = {  0x845,  0xAC0,  0,  6  };  int i;   buildColorTransition(  targetMemory,  &ct  );   CuAssertIntEquals(tc, 0x845, targetMemory[0]);  CuAssertIntEquals(tc, 0x864, targetMemory[1]);  CuAssertIntEquals(tc, 0x983, targetMemory[2]);  CuAssertIntEquals(tc, 0x992, targetMemory[3]);  CuAssertIntEquals(tc, 0xab1, targetMemory[4]);  CuAssertIntEquals(tc, 0xac0, targetMemory[5]);  CuAssertIntEquals(tc, 0, targetMemory[6]); } 

Additionally writing unit tests forced me to build an interface to the palette manager that was reusable. Lots of structures to manage incoming data, and well-defined inputs and outputs means that reusing this code in future programs, like the demo code above, was trivial.

I’ll be getting back to the head collision physics, and probably implementing more unit tests around that, since hand-testing the collision code requires a lot of setup and me jumping really precisely. Tests should speed up that feedback loop a lot.

Yup, no Night in the Woods stream tonight. I'll do one towards the end of the year. Close enough, right?

Things are pretty busy for me at the moment but I'm still gonna try to do my Night in the Woods Longest Night stream tomorrow. If it doesn't happen then, then it may happen closer to the new year. Stay tuned...

I now have a Sun Ultra 5 all fixed up and ready to serve up some Perl and C CGI scripts to my local machines. The future is now.

All three collision types are now working! (well, mostly working):

I need to do something about that last one, when you are going to go over an edge. I may just have to extend the physics engine a bit more to make that look good. Thankfully, I have a new tool in my retro development toolkit to make that a lot easier to implement.

I have unit tests with CuTest working with assembler code, so I can write tests for some of the more complicated data transformations (like collision physics) rather than using slow and error-prone hand testing:

As I describe on my wiki page about the subject, you have to set the stack up to around 30000 bytes on the Amiga for the test to run. You also have to include the math library. Get those in place, and you can easily run tests against any symbols exported from your assembler code.

Next is fixing that head konk collision ground slide, then implementing a palette manager which can set Copperlist palettes as well as perform transitions between two palette sets, to allow for color fades in and out and other effects.

Doing some drawing to make sure my stream setup is good for a future NITW stream.

Art stream is over, here's the art which includes a crab for @mhzmodels as well as an Adina Astra for my upcoming Night in the Woods Longest Night stream on December 21st. #mastoart #rabbit #crab #nightinthewoods

Streaming some art for a bit: https://makertube.net/w/p9xvVXCKG2Cvokf7boUuaM

Gonna try some art streaming tonight to make sure my streaming setup is ready for my yearly Night in the Woods stream. I'll post a link later. If you have something you want me to try and draw (SFW plz), lemme know.

If you told 16 year old me I'd be writing unit tests for Amiga code, I'd respond, "...what the HECK is a unit test?!?" #amiga #retrocomputing #programming

Trip! #amiga #indiegamedev #retrogaming

I have two of the three collision types working! Well at least the basics of them working:

I also got the tiles background working, though for performance reasons I made the backgrounds 512px wide so it’s easier to do bitwise math for calculations.

Doing both of these things required restructuring a TON of code, and included working out good ways to do unit-ish testing in C of the assembler code I’ve been writing. It’s also helped me focus on ensuring dependencies between areas of the game code are as few and deep as possible.

Next is finishing up the final collision type, the rabbit hitting its head. This will involve the physics necessary to get the rabbit to fall correctly and hit the ground. Then I’ll be doing a few additional frames of animation and moving on to other parts of the game.

Almost 6 hours later and I've completely restructured how sprites are loaded, stored, and referenced by other routines in my Amiga game. As annoying as restructuring is to do in assembler, I'm loving it right now. It's the kind of puzzle my brain needs at this moment.

Thwack! #amiga #indiegamedev

I decided to give up on the data recovery. It would have literally taken days to grab some now-swiss cheese files related to a demo reel I made when I was 22, and some other files I likely have other copies of strewn about elsewhere. I'll survive without it all.

This week was about getting a basic level “editor” working, using a combination of a Ruby script with RMagick and an image from LibreSprite:

The level generation works, and I restructured a ton of code to make dynamic level loading work. However, the more complex levels revealed an issue in collision detection that I need to debug.

To make this easier, I’m finally adding some on-screen debugging to the game:

I needed the ability to write text to the info screen anyway. I also need to tweak the copperlist split screen a bit more (that’s the red glitch), but that can come later.

Next will be fixing that collision detection, then reworking the background art to be two 640px images that are tiled rather than one massive 1000px image and fixing the background rendering pipeline.

There were many more machines and electronics doo-dads there that I didn't get photos of! #retrocomputing #sharp #ti99 #commodore #amiga #vectrex

Hardcore retro gaming. #retrogaming #retrocomputing #ibmpc #atari #pacman #commodore64

Peak computing. #retrocomputing #windows #zork #atari

I went down to a retro computing meetup @bluewizard@mastodon.sdf.org runs on Sunday! I brought my MiSTer and the current build of Bun Runner 2000, which was a big hit. Next few posts will have more pictures from the event. More details at https://www.bluewizard.net/pages/vintagecomputermeetup/.

#retrocomputing #commodore #amiga #acorn

We have a main menu! It’s very simple, but it also forced me to restructure huge chunks of code in order to allow swapping out the menu and the game code.

This included asset loading code, and this restructuring caused me to find a bug that took a few hours to track down. Symptoms:

• The background would occasionally glitch out when swapping buffers
• The glitching would mostly stop if I didn’t allocate memory for sprites.

What it came down to was this line:

; D0 contains the address to the background art ADD.W #GAME_SCREEN_LAST_WORD_POSITION,D0 

I was adding a value to an address and scoping to word boundaries, and it kinda worked, as long as I wasn’t wrapping around a 64k boundary when adding that value to the address. Changing how memory was allocated, as sprite memory was allocated before screen memory, would change the start address of screen memory and make this “work”.

But I have a menu now! Oh and some more animation! The rabbit will angle up and down depending on vertical velocity, and the jetpack has animation now, too!

Next will be changing up some game behaviors, and then on to some fun bits of the game.

Another week of slow progress, but this is mainly due to some really heavy refactoring work. I wanted to use ptplayer for music, and that required having my code in a ready-to-link format. If I was going to do this, I was going to do it right, and so I restructured all of the code using all of the techniques I use when working with higher level languages:

• proper separation of concerns into deep modules
• “data classes” that enforce structure

My biggest problem holding me back was that MonAm did not like it as all when I gave it linked code:

• I lost all my symbols
• Source code mode was non-existent, though that barely worked for me anyways

Along with all the refactoring, I switched to using BDebug in the Barfly assembler package, and I haven’t looked back. Symbols, source code, proper OS 2.0 windows, full mouse support, command line arguments, and lots and lots of great options.

Along with reworking the game code in this way, I restructured my art compression tool to get more practice. I’ve gotten a lot better at restructing assembler code and figuring out the good places to divide up modules. Once I feel really confident that this is the way to go, I’ll write up an article detailing my approach, if you want to try it out yourself.

Oh, and music playback works!

Not as much progress this week, but some good code cleanups and performance enhancements:

• Spreading out redraw work across multiple frames
• Getting background rendering mostly working
• Precalculating double buffer calculations

Next will be getting the double buffering to happen independently between the front and back planes, which will allow for smooth backgrounds and foregrounds. Then I’ll work on externalizing some more of the game from the code, moving maps to separate files that can be loaded in and adding some other colors to the output.

Lots of progress this week!

• Full joystick handling, including getting the jetpack working and decent jumping physics
• Drawing lots more stuff on screen:
  • Textured 4 bitplane floors
  • 1 bitplane ceilngs
  • The jetpack meter
• Collisions with the floor, ceiling, and walls work

I also fixed up some really stupid bugs and got the game working on my MiSTer and A1200:

Additionally, I tightened up the art pipeline so when I’m creating assets, it’s easy to get them into the game. I will need to figure out the best way to automate more of the XPK compression, too.

Next I’ll be getting the rest of the draw operations for the background into the game and spreading the writes to the double buffer over a few frames.

Going to write up a blog post every week with the progress of my finite-at-first runner for the Amiga. My goals:

• write something large in Assembler
• learn as many of the Amiga subsystems as I can
• make an entertaining, easy-to-pick-up game with as many modern sensibilities as possible

I have no timeline to get a WIP out for testing because I’ve never worked in Assembler nor this deeply with the Amiga and AmigaOS before!

This week:

• set up the main game project
• extracted out relevant code from some things I posted to Mastodon
• cleaned up keyboard, mouse, and joystick handling, using OS routines for the first two, and direct CIA access for the joystick
  • The two dots in the upper left are the state of the joystick
• set up file logging for debug messages as printing to stdout while I’ve turned off enough OS things doesn’t work, but writing to a file does
• cleaned up my assembler XPK art compressor and made it more generic so I can compress more objects into different files as needed (think sprites vs. blitter objects vs. backgrounds vs. music)
• Got rabbit rendered on the screen and movable with the joystick
• Animated rabbit frames while moving around on screen

I also learned:

• doing assembler debugging on a PiStorm-equipped Amiga using something like MonAm doesn’t work: https://github.com/michalsc/Emu68/issues/282
  • I tried a build of this branch on my PiStorm32 Lite and tracing in MonAm crashed the machine

It's time...time for a video on the Commodore Amiga Blitter! Topaz walks through the memory copy capabilities of this feature in the context of a small demo written to exercise the blitter, copper, and sprites.

Thanks to Tyrel (@tyrel@mastodon.social), corb0!

• Mastodon: https://oldbytes.space/@TopazRabbit
• Website: https://theindustriousrabbit.com/
• RSS: https://theindustriousrabbit.com/index.xml
• Donate: https://ko-fi.com/topazrabbit

References

Code:

• Cool Bun Demo on Hackerbun (https://code.hackerbun.dev/TheIndustriousRabbit/cool-bun-demo) - All the blitter code I used for this video is here, including the code to convert PNGs to Amiga assembler embedded images used in the main C code.

Documentation:

• Amiga Blitter Hardware (https://amigadev.elowar.com/read/ADCD_2.1/Hardware_Manual_guide/node0118.html) - The Amiga Blitter section of the hardware manual
• SAS/C and DevPac interop (https://amigasourcecodepreservation.gitlab.io/total-amiga-assembler/#xdef-and-xref) - Since I use SAS/C and DevPac, I needed to know how to get the two to talk to each other

Credits

Music:

• "Silly Fun" and "Wallpaper" by Kevin MacLeod
  https://incompetech.com
  CC-BY 3.0 (http://creativecommons.org/licenses/by/3.0/)

SFX:

• Dragon_Wing.wav by Bsdjak
  https://freesound.org/people/Brsjak/sounds/483095/
  CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)
• slap-cards.wav by themfish
  https://freesound.org/people/themfish/sounds/45821/
  CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)
• Bell 3.wav by el1n
  https://freesound.org/people/el1n/sounds/442747/
  CC-0 (http://creativecommons.org/publicdomain/zero/1.0/)

It’s time…time for a video on the Commodore Amiga Blitter! Topaz walks through the memory copy capabilities of this feature in the context of a small demo written to exercise the blitter, copper, and sprites.

Thanks to Tyrel (@tyrel@mastodon.social), corb0!

References

Code

• Cool Bun Demo on Hackerbun (https://code.hackerbun.dev/TheIndustriousRabbit/cool-bun-demo)
  • All the blitter code I used for this video is here, including the code to convert PNGs to Amiga assembler embedded images used in the main C code.

Documentation

• Amiga Blitter Hardware (https://amigadev.elowar.com/read/ADCD_2.1/Hardware_Manual_guide/node0118.html)
  • The Amiga Blitter section of the hardware manual
• SAS/C and DevPac interop (https://amigasourcecodepreservation.gitlab.io/total-amiga-assembler/#xdef-and-xref)
  • Since I use SAS/C and DevPac, I needed to know how to get the two to talk to each other

Credits

Music

• “Silly Fun” and “Wallpaper” by Kevin MacLeod
  • https://incompetech.com
  • CC-BY 3.0 (http://creativecommons.org/licenses/by/3.0/)

SFX

• Dragon_Wing.wav by Bsdjak
  • https://freesound.org/people/Brsjak/sounds/483095/
  • CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)
• slap-cards.wav by themfish
  • https://freesound.org/people/themfish/sounds/45821/
  • CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)
• Bell 3.wav by el1n
  • https://freesound.org/people/el1n/sounds/442747/
  • CC-0 (http://creativecommons.org/publicdomain/zero/1.0/)

Here's my Nandland Go Board (https://nandland.com/the-go-board/) running through some of the exercises from the creator's book and website:

• https://nostarch.com/gettingstartedwithfpgas
• https://nandland.com/download-and-install-the-fpga-tools-and-drivers/

I posted the Verilog source code that I reworked for these examples on my Gitea server: https://code.hackerbun.dev/john/go-board-code

The EGA and VGA video standards share some similarities with how the Amiga did graphics, but the similarities end when it comes to the 256 color graphics that defined 90s PC gaming. Topaz walks you through the basics of how those video modes worked, and what made them get so fast over time.

Thanks to Tyrel (@tyrel@mastodon.social)!

• Mastodon: https://oldbytes.space/@TopazRabbit
• Website: https://theindustriousrabbit.com/
• RSS: https://theindustriousrabbit.com/index.xml
• Donate: https://ko-fi.com/topazrabbit

References

3d game source code:

• Wolfenstein 3D (https://github.com/id-Software/wolf3d/blob/master/WOLFSRC/WL_AGENT.C#L244-L361) - Wolfenstein 3D using latched VGA copies to draw things on screen
• Duke Nukem 3D (https://github.com/grepwood/duke3d/blob/master/source/buildengine/dos_drvr.c#L532) - The DOS driver shovels data into the chunky mode as fast as it can. It didn't use page flipping.
• Quake (https://github.com/id-Software/Quake/blob/master/QW/client/d_copy.s#L20-L148) - Quake shoveling data into either the planar or chained VGA. Quake didn't use any of the page-flipping approaches that unchaned modes allowed, so the only benefit was higher resolutions.
• Commander Keen in Keen Dreams (https://github.com/keendreams/keen/blob/master/id_vw_ae.asm) - The EGA drawing routines used in this game were more sophisticated than in the earlier Commander Keen 1, but all of the fun tricks are still there.

Code on Hackerbun:

• VGA and SVGA code examples (https://code.hackerbun.dev/TheIndustriousRabbit/vga-logic-processor-examples) - My code exploring how the VGA and SVGA modes work in more detail, as well as learning more about x86 assembler.

2d games and the EGA pipeline:

• Duke Nukem II Reconstructed (https://github.com/lethal-guitar/Duke2Reconstructed) - Walks through a ton of detail on how this VGA game used the EGA pipeline, but on a VGA card, to achieve its smooth scrolling
• Lethal Guitar's Duke Nukem platformer blog posts (https://lethalguitar.wordpress.com/2023/11/04/duke-nukem-1s-tile-rendering/) - A much more detailed overview on the EGA drawing pipeline and how it was used effectively for platforming games

Why are, like, half these examples id Software games?:

• Graphics Programming Black Book by Michael Abrash (https://www.phatcode.net/res/224/files/html/index.html) - This book not only has a lot of incredible detail about the x86 processor, the DOS platform, and how these EGA and VGA modes work, but the author also worked on the Quake engine, and his earlier articles helped John Carmack make games like Commander Keen run so smoothly. Even if you're not going to write low-level code for retro machines, the first three chapters are a fantastic read for any software developer who gets caught up in prematurely optimizing anything (code, date, features) at any level of the process. Highly recommended.

Credits

Music:

• "Show Your Moves" by Kevin MacLeod
  https://incompetech.com
  CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)

The EGA and VGA video standards share some similarities with how the Amiga did graphics, but the similarities end when it comes to the 256 color graphics that defined 90s PC gaming. Topaz walks you through the basics of how those video modes worked, and what made them get so fast over time.

Thanks to Tyrel (@tyrel@mastodon.social)!

References

3d game source code

• Wolfenstein 3D (https://github.com/id-Software/wolf3d/blob/master/WOLFSRC/WL_AGENT.C#L244-L361)
  • Wolfenstein 3D using latched VGA copies to draw things on screen
• Duke Nukem 3D (https://github.com/grepwood/duke3d/blob/master/source/buildengine/dos_drvr.c#L532)
  • The DOS driver shovels data into the chunky mode as fast as it can. It didn’t use page flipping.
• Quake (https://github.com/id-Software/Quake/blob/master/QW/client/d_copy.s#L20-L148)
  • Quake shoveling data into either the planar or chained VGA. Quake didn’t use any of the page-flipping approaches that unchaned modes allowed, so the only benefit was higher resolutions.
• Commander Keen in Keen Dreams (https://github.com/keendreams/keen/blob/master/id_vw_ae.asm)
  • The EGA drawing routines used in this game were more sophisticated than in the earlier Commander Keen 1, but all of the fun tricks are still there.

Code on Hackerbun

• VGA and SVGA code examples (https://code.hackerbun.dev/TheIndustriousRabbit/vga-logic-processor-examples)
  • My code exploring how the VGA and SVGA modes work in more detail, as well as learning more about x86 assembler.

2d games and the EGA pipeline

• Duke Nukem II Reconstructed (https://github.com/lethal-guitar/Duke2Reconstructed)
  • Walks through a ton of detail on how this VGA game used the EGA pipeline, but on a VGA card, to achieve its smooth scrolling
• Lethal Guitar’s Duke Nukem platformer blog posts (https://lethalguitar.wordpress.com/2023/11/04/duke-nukem-1s-tile-rendering/)
  • A much more detailed overview on the EGA drawing pipeline and how it was used effectively for platforming games

Why are, like, half these examples id Software games?

• Graphics Programming Black Book by Michael Abrash (https://www.phatcode.net/res/224/files/html/index.html)
  • This book not only has a lot of incredible detail about the x86 processor, the DOS platform, and how these EGA and VGA modes work, but the author also worked on the Quake engine, and his earlier articles helped John Carmack make games like Commander Keen run so smoothly. Even if you’re not going to write low-level code for retro machines, the first three chapters are a fantastic read for any software developer who gets caught up in prematurely optimizing anything (code, date, features) at any level of the process. Highly recommended.

Credits

Music

• “Show Your Moves” by Kevin MacLeod
  • https://incompetech.com
  • CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)

Version 1.1.4 of the AMOS Pro BSD Socket extension is out, and it’s a big one. Thanks to both an anonymous contributor and some improved M68K assembler debugging techniques, this version has multiple crash bugs fixed, as well as an issue that prevented the extension from working well on non-emulated Amigas. Upgrading is highly recommended!

Grab it from Hackerbun Gitea or Aminet:

• Hackerbun Gitea: https://code.hackerbun.dev/TheIndustriousRabbit/amos-pro-bsdsocket-extension/releases/tag/1.1.4
• Aminet: http://aminet.net/package/dev/amos/BSDSocket-Extension

(1.1.3 was an internal release and not published to the public)

There was some great music selections at the Radio Museum. #VCFEast #8track #museum #music #StarWars

Lots of great TV-related stuff in the InfoAge Radio Museum. #VCFEast #television #museum

SCIENCE! #VCFEast #TheSimpsons #museum

Lots of other fun stuff!

* A Nabu set up with a run'n'gun'n'fly game
* A Tandy Color Computer running FujiNet and showing Mastodon toots about Sonic the Hedgehog
* A SGI Personal Iris
* @paulrickards@mastodon.social was pen plotting away

#vcfeast #retrocomputing #nabu #fujinet #silicongraphics

I like little computers and I like BeOS (at least the idea of it and those cool yellow toolbars) so I had a good time at the @ActionRetro@bitbang.social table. #VCFEast #BeOS #HaikuOS #retrocomputing

Lots of Macs, including one I drew Topaz on last year as well! #VCFEast #Apple #Macintosh #retrocomputing #rabbit #furryart #mastoart

I made a joystick! It works on the Amiga and it's real weird. Let's try to play some games with it.

Hot on the heels of 1.1.1 comes even better fixes to string handling in the extension. The issue is that, while the strings returned from the functions were immediately usable, they weren’t being added correctly to the string space AMOS maintains, so you couldn’t do things like concatenate them. I documented the proper usage on the wiki. This fixes up all of the string returning functions in the extension, which means that Socket Recv$ should work as expected now.

Grab it from Hackerbun Gitea or Aminet:

• Hackerbun Gitea: https://code.hackerbun.dev/TheIndustriousRabbit/amos-pro-bsdsocket-extension/releases/tag/1.1.2
• Aminet: http://aminet.net/package/dev/amos/BSDSocket-Extension

I’ve released version 1.1.1 of my BSD Socket extension for AMOS Professional. It fixes two bugs in Socket Inet Ntoa$, a crash bug and an issue where the null terminator in the original string was being copied into the AMOS string, causing issues. There was also an issue with the build script where the latest version of the library was appearing in the wrong place in the archive.

Grab it from Hackerbun Gitea or Aminet:

• Hackerbun Gitea: https://code.hackerbun.dev/TheIndustriousRabbit/amos-pro-bsdsocket-extension/releases/tag/1.1.1
• Aminet: http://aminet.net/package/dev/amos/BSDSocket-Extension

I put up the code and binary for a Smash TV/Robotron-like game I built for DOS and PCs with VGA graphics. It works well enough to be playable.

The code is up on Hackerbun Gitea. It has a bunch of code related to working with the PC and VGA card, and it’s the biggest program I’ve written in C so far. It also has unit tests using CuTest, inline assembler, and compiled sprites built using Ruby.

Take it for a spin if you like. Downloadable files are in the project’s Releases. If you have feedback, send it along. I’m not sure when I’ll get back to working on it because I have a video idea I want to do next, but who knows what the future will bring!

I’ve released version 1.1.0 of my BSD Socket extension for AMOS Professional. It fixes a bug in Dns Get Host Address By Name$ where I was incorrectly handling string termination from AMOS strings. It also adds Socket Herrno to get error code information from the DNS resolver in the network stack.

Thanks to Allanon on Mastodon for finding the issue and testing out the fix!

Grab it from Hackerbun Gitea or Aminet:

• Hackerbun Gitea: https://code.hackerbun.dev/TheIndustriousRabbit/amos-pro-bsdsocket-extension/releases/tag/1.1.0
• Aminet: http://aminet.net/package/dev/amos/BSDSocket-Extension

Young Topaz has an IFF ILBM image he wants to show his dad, but his dad's on his PC. Learn about what it takes to write a simple IFF ILBM reader for DOS.

• Mastodon: https://oldbytes.space/@TopazRabbit
• Website: https://theindustriousrabbit.com/
• RSS: https://theindustriousrabbit.com/index.xml
• Donate: https://ko-fi.com/topazrabbit

References

Source Code:

• Hackerbun Gitea (https://code.hackerbun.dev/TheIndustriousRabbit/iff-ilbm-on-pc-vga) - All code used in this video

IFF Files:

• "ILBM" IFF Interleaved Bitmap (http://www.etwright.org/lwsdk/docs/filefmts/ilbm.html) - The original IFF ILBM document from Electronics Arts and Commodore

PC Development:

• Open Watcom 2.0 (https://open-watcom.github.io/) - The C compiler I used for my PC development
• David Brackeen's 256-Color VGA Programming in C (http://www.brackeen.com/vga/basics.html) - The source for all my VGA learnings
• Ralf Brown's Interrupt List (https://www.cs.cmu.edu/~ralf/files.html) - More info than you could ever want about every PC interrupt

Credits

Music:

• "Werq" by Kevin MacLeod
  https://incompetech.com
  CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)
• "Onion Capers" by Kevin MacLeod
  https://incompetech.com
  CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)

Sound Effects:

• Light Switch by TimoSchmied
  https://freesound.org/people/TimoSchmied/sounds/530973/
  CC-BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
• Male Gasp 1.wav by jawbutch
  https://freesound.org/people/jawbutch/sounds/344407/
  CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/)
• Fast Typing on Mechanical Keyboard by HeinzBBQ
  https://freesound.org/people/HeinzBBQ/sounds/502653/
  CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/)

Young Topaz has an IFF ILBM image he wants to show his dad, but his dad’s on his PC. Learn about what it takes to write a simple IFF ILBM reader for DOS.

References

Source Code

• Hackerbun Gitea (https://code.hackerbun.dev/TheIndustriousRabbit/iff-ilbm-on-pc-vga)
  • All code used in this video

IFF Files

• “ILBM” IFF Interleaved Bitmap (http://www.etwright.org/lwsdk/docs/filefmts/ilbm.html)
  • The original IFF ILBM document from Electronics Arts and Commodore

PC Development

• Open Watcom 2.0 (https://open-watcom.github.io/)
  • The C compiler I used for my PC development
• David Brackeen’s 256-Color VGA Programming in C (http://www.brackeen.com/vga/basics.html)
  • The source for all my VGA learnings
• Ralf Brown’s Interrupt List (https://www.cs.cmu.edu/~ralf/files.html)
  • More info than you could ever want about every PC interrupt

Credits

Music

• “Werq” by Kevin MacLeod
  • https://incompetech.com
  • CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)
• “Onion Capers” by Kevin MacLeod
  • https://incompetech.com
  • CC-BY 4.0 (http://creativecommons.org/licenses/by/4.0/)

Sound Effects

• Light Switch by TimoSchmied
  • https://freesound.org/people/TimoSchmied/sounds/530973/
  • CC-BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
• Male Gasp 1.wav by jawbutch
  • https://freesound.org/people/jawbutch/sounds/344407/
  • CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/)
• Fast Typing on Mechanical Keyboard by HeinzBBQ
  • https://freesound.org/people/HeinzBBQ/sounds/502653/
  • CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/)

For the fourth time I play through the Night in the Woods supplemental games, “Longest Night” and “Lost Constellation”, on the 2023 winter solstice.

For the fourth time I play through the Night in the Woods supplemental games, "Longest Night" and "Lost Constellation", on the 2023 winter solstice.

I play through a bunch of Hop to the Top: Bunny's Revenge and bounce between streaming providers while I get Owncast working. Now that my Twitch- and YouTube-free streaming setup is worked out, expect a full live stream of HttT:BR for realsies!

Download the game and see high scores here: https://rabbit.robsmithdev.co.uk/

I draw your requests on a Quantel Paintbox, specifically a Harriet from the early 90s. Due to streaming issues, I wasn't able to broadcast this live, but I did record the whole stream locally. I made it through three pieces: a rat holding a Quantel RAT (a mouse-like input device), a request from @imrustyok@meow.social for a TV show ad card recreation, and a request from @tyrel@social.tyrel.dev to draw his cat. I thought I was drawing his cat Henry, but it was actually Victor. Oops.

Learn more about the Quantel Paintbox:

• My video about the history and technology within the Paintbox: https://makertube.net/w/kegieNpTzAbT2ukR7EUMTt
• Adrian's website: https://quantelpaintbox.com/
• @DextersTechLab@mastodon.social 's YouTube channel: https://youtube.com/@DextersTechLab?si=0KFDoNNHHRUnfxmq

Stream music by Nihilore: https://nihilore.com

Continued stream go here: https://makertube.net/w/7dyJqokqtdXYJFsURs6tgn

I've taken your requests, as well as a few of my own ideas, and will draw them on a Quantel Paintbox, a Harriet model from the early 90s. Watch and see how digital graphics were made on bespoke art computers long before Photoshop took over the digital art world.

The popular shorthand for digital photo editing is based on the name of software developed in the 90s. However, that activity was already being done by users of a bespoke art computer developed by a British company in the early 80s, and the public could see the output of this machine everywhere. So why is digital photo manipulation not called "being Paintboxed"?

Thanks to DextersTechLab for actual Paintbox footage and technical assistance, Adrian Wilson for lots of feedback and resources!

• Mastodon: https://oldbytes.space/@TopazRabbit
• Website: https://theindustriousrabbit.com/
• RSS: https://theindustriousrabbit.com/index.xml
• Donate: https://ko-fi.com/topazrabbit

Chapters

00:00 - Introduction
00:36 - Digital Video History
01:23 - The Quantel Paintbox
02:33 - Music Videos
02:57 - Paintbox Machines
03:23 - Why is it not called being Paintboxed?

References

Quantel Paintbox Resources:

• DextersTechLab (https://youtube.com/@DextersTechLab) - Paintbox repair videos and lots of other Quantel goodness
• Quantel Paintbox (https://quantelpaintbox.com) - Adrian's site with history on Quantel, the Paintbox, and the media created by this incredible machine

Credits

Music:

• "Sunflower Dance Party" by Kevin MacLeod
  https://incompetech.com
  CC-BY 3.0 (http://creativecommons.org/licenses/by/3.0/)

My 2021 annual playthrough of the Night in the Woods supplemental games, "Longest Night" and "Lost Constellation".

Join me for my yearly play through of the Night in the Woods supplemental games, "Longest Night" and "Lost Constellation". Jump to 08:46 to skip past all my stream setup stuff.

• Mastodon: https://oldbytes.space/@TopazRabbit
• Website: https://theindustriousrabbit.com/
• RSS: https://theindustriousrabbit.com/index.xml

I did it. I finished the animation. Working with this software is more challenging than I expected. It also didn't help that my tablet was having issues with Weylus after a while. I also learn just what Frisket does, and why it's important to Free the Frisket!

Skip to 2:23:54 if you want to see the finished animation playing!

I'll be taking a break from streaming while I focus on the next video, then I'll pick back up with either DeluxePaint V or True Brilliance as my next Amiga art tool to explore.

Stream music by Nihilore (CC-BY 4.0) - https://nihilore.com

Bamboo figures out how to get code he wrote 23 years ago on the Amiga to work for someone today, and it involves a lot of work with libraries.

Thanks to Piotr Kuchno for contacting me and working through debugging the code, and for the videos of the code in use on real Amiga computers! Thanks also to @ijimkoz on Twitter for valuable feedback!

Note: The project name and URL have changed! Go to theindustriousrabbit.com to learn more!

Resources

Intro:

• http://aminet.net/package/dev/amos/BSDSocket - The code I wrote 23 years ago

• https://en.wikipedia.org/wiki/AMOS_(programming_language) - AMOS BASIC

• https://docs.freebsd.org/en/books/developers-handbook/sockets/ - BSD sockets in general

• https://www.youtube.com/watch?v=EVr1AHJaGCk - The Copper Demo video, also written in AMOS, that exercises a bunch of Agnus's features

AMOS Extensions:

• https://www.exotica.org.uk/wiki/AMOS_extensions - List of Amiga extensions
• https://www.kyzer.me.uk/amos/docs/easylife/EasyLife.guide - EasyLife, the extension 16 I wanted
• https://www.kyzer.me.uk/amos/docs/maxsdoorhandler/AMOSDoors4MAXS.doc - The BBS extension

Amiga libraries:

• https://www.thedigitalcatonline.com/blog/2018/05/28/exploring-the-amiga-2/- Amiga library jump tables (the index card bulletin board)
• https://www.ultimateamiga.co.uk/HostedProjects/AMOSFactory/AMOSProManual/11/1116.html - The "equate" system I never used or got working correctly
• https://github.com/cnvogelg/amitools/blob/master/amitools/data/fd/bsdsocket_lib.fd - I used this file to figure out function offsets

Why was my server code not working?

• https://wiki.amigaos.net/amiga/autodocs/bsdsocket.doc.txt - The Amiga BSD socket library docs

Want to try out gaming on the classic Commodore Amiga computer? Topaz walks you through the basics of this retro computer's hardware, and the things you'll need to look for to get your own setup working.

I currently use these emulators:

• Linux: FS-UAE (https://fs-uae.net/)
• Steam Deck: EmuDeck (https://www.emudeck.com/)
• Raspberry Pi: Pimiga 2.0 (https://cubiclenate.com/pimiga/)
• FPGA: MiSTer with the Minimig core (https://github.com/MiSTer-devel/Minimig-AGA_MiSTer)

If you're on Windows, you can run the venerable WinUAE (https://www.winuae.net/).

You can get Kickstart ROMs from Cloanto and their Amiga Forever pack (get at least the Plus Edition for the more modern Kickstarts) and/or from Hyperion if you want AmigaOS 3.2, a modern AmigaOS for applications.

I leave ADF and WHDLoad archive hunting to the viewer!

Thanks to Meredith, Tyrel, Dave!

Read more at https://theindustriousrabbit.com and subscribe to the channel and RSS feed for future updates!

Credits

• Industrious Ferret by Kevin MacLeod
  https://incompetech.filmmusic.io/song/3912-industrious-ferret
  Simplified Filmmusic.io Standard License (https://incompetech.filmmusic.io/standard-license)

I take Digital Creations True Brilliance 2.0 for a spin on my emulated Amiga 1200. I've never used this software before, and I discover it's actually not bad for painting, especially when using my Weylus and Galaxy Tab powered input setup.

Stream music by Nihilore (CC-BY 4.0) - https://nihilore.com

Having trouble getting MiSTerFS to work on the AO486 core? Topaz Rabbit walks you through a workaround you can do on the Linux side of the MiSTer, then describes how that workaround works.

Thanks to Tyrel (@tyrel@social.tyrel.dev), Jim (@ijimkoz@mastodon.social)!

• Mastodon: https://oldbytes.space/@TopazRabbit
• Website: https://theindustriousrabbit.com/
• RSS: https://theindustriousrabbit.com/index.xml

References

• losetup (https://www.man7.org/linux/man-pages/man8/losetup.8.html)
  Details on the losetup command

Credits

• "Industrious Ferret" by Kevin MacLeod
  https://incompetech.com
  CC-BY 3.0 (http://creativecommons.org/licenses/by/3.0/)

Topaz Rabbit walks us through writing a pizza timer app in C on the Commodore Amiga. Follow along and learn about Intuition, GadTools, devices, message ports, IO, and even signals!

Thanks to Tyrel (@tyrel@social.tyrel.dev)!

• Mastodon: https://oldbytes.space/@TopazRabbit
• Website: https://theindustriousrabbit.com/
• RSS: https://theindustriousrabbit.com/index.xml

Chapters

00:15 - Introduction
00:40 - Intuition
01:17 - Opening a Window
01:50 - GadTools
03:31 - setup and teardown
03:53 - Fonts
04:29 - Timer Logic
05:24 - Amiga code documentation
05:53 - Message Ports
06:34 - Intuition Direct Communication Message Port (IDCMP)
09:06 - Time & timer.device
10:01 - Synchronous & Asynchronous IO
11:40 - Alerting the user with DataTypes audio playback
12:43 - Signals
13:27 - Intuition menus
14:19 - The About window
14:45 - App testing with CodeWatcher and avail
15:25 - Conclusion

References

Amiga documentation and tools:

• Elowar (http://amigadev.elowar.com/)
• d0.se (https://d0.se/docs)
• CodeWatcher (http://aminet.net/package/dev/debug/CodeWatcher)

C tutorials:

• P.J. Hutchison's Amiga C tutorials, where I got started with Amiga C (http://www.pjhutchison.org/tutorial/amiga_c.html)

Source code:

• Pizza timer on hackerbun (https://code.hackerbun.dev/TheIndustriousRabbit/topaz-pizza-timer-amigaos-204/)

Credits

Music:

• "Itty Bitty 8-bit" & "Industrious Ferret" by Kevin MacLeod
  https://incompetech.com
  CC-BY 3.0 (http://creativecommons.org/licenses/by/3.0/)
• "Bells" by Nihilore
  https://nihilore.com
  CC-BY-NC 3.0 (https://www.nihilore.com/license)

Sound Effects:

• "Reception Bell" by cdrk
  https://freesound.org/people/cdrk/sounds/264594/
  CC-BY 4.0
• "d-von request, A UFO Abducting 02, Remastered.wav" by MATRIXXX_
  https://freesound.org/people/MATRIXXX_/sounds/659542/
  CC-0
• "Explosion" by FlashTrauma
  https://freesound.org/people/FlashTrauma/sounds/398283/
  CC-0