Learn Multiplatform Z80 Assembly Programming with Vampires

Don't like to read? you can learn while you watch and listen instead! Every Lesson in this series has a matching YOUTUBE video... with commentary and practical examples Visit the authors Youtube channel, or Click the icons to the right when you see them to watch the Lessons video!

Introduction
The Z80
Numbers in assembly

- A warm up for those who aren't ready to start programming, covers concepts and terminology

- lets learn the basic Z80 commands by example!

- Super simple Hello world examples

- Lets learn some more useful Z80 examples that may help you in your programming

- Using code provided that will talk to the hardware, lets write programs that works instantly on multiple systems!

- Lets look at sprites and tiles on each system

- Lets look pixel plotting on each system.

The next few chapters are quite technical and confusing, but if you want, just skip them for now, and jump straight into the coding! This tutorial is designed so you can do that! You'll need to know the technical stuff explained below one day, but you can come back to it later when you feel you want to!

We'll be using the excellent VASM for our assembly in these tutorials to build for everything except the Amstrad CPC... VASM is an assembler which supports Z80, 6502, 68000, ARM and many more, and also supports multiple syntax schemes... You can get the source and documentation for VASM from the official website HERE

The Z80 is a 4mhz 8 bit processor from the 1980's... now by modern standards, it's slow and ridiculously out of date, so why would you want to learn to develop for it? Well, you can learn a lot about modern computer concepts from the simple Z80, and 4mhz is 4 million commands a second, Which is a heck of a lot when you know how to use them!   These old 8 bits give a simple system with a lot of potential for the creative person... and while one person could never create a game up to the standards of the latest 'AAA' titles... you could very easily create a game that's as good or better than the best games of the 80's!

Whether you're a fan of the CPC, MSX, Spectrum or even the Gameboy these 8 bits have all the power and potential for you to show what you can really do - and you'll learn things doing assembly that you would miss out on with years of C++ or Java development! If you want to make a game with the latest graphics, of course go download Unity... but if you really want to be in control, and to understand everything that's happening in your code, Assembly gives you the power! No operating system, no drivers, you can take control of everything and make anything you want with it!

Assembly development can be confusing at first... but it has very few commands to learn, Everyone has to start simply, so try not to compare what you're doing to others... just look at what you're achieving, and knowing however 'simple' what you're doing is... it's something you made yourself!

The Z80 is an 8-Bit processor with a 16 bit Data bus!
What's 8 bit... well, one 'Bit' can be 1 or 0
four bits make a Nibble (0-15)
two nibbles (8 bits) make a byte (0-255)
two bytes (16 bits) make a word (0-65535)

And what is 65535? well that's 64 kilobytes ... in computers 'Kilo' is 1024, because binary works in powers of 2, and 2^10 is 1024
64 kilobytes is the amount of memory a basic 8-bit system can access

Z80 is 8 bit so it's best at numbers less than 256... it can do numbers up to 65535 too more slowly... and really big numbers will be much harder to do! - we can design our game round small numbers so these limits aren't a problem.

You probably think 64 kilobytes doesn't sound much when a small game now takes 40 gigabytes, but that's 'cos modern games developers have gotten lazy! there's no need to worry about making games small anymore now everyone has 10 TB hard drives... Z80 code is small, fast, and super efficient - with ASM you can do things in 1k that will amaze you!

Numbers in Assembly can be represented in different ways.
A 'Nibble' (half a byte) can be represented as Binary (0000-1111) , Decimal (0-15) or  Hexadecimal (0-F)... unfortunately, you'll need to learn all three for programming!

Also a letter can be a number... Capital 'A'  is stored in the computer as number 65!

Think of Hexadecimal as being the number system invented by someone wit h 15 fingers, ABCDEF are just numbers above 9!
Decimal is just the same, it only has 1 and 0.

In this guide, Binary will shown with a % symbol... eg. %11001100 ... hexadecimal will be shown with & eg.. &FF.

Assemblers will use a symbol to denote a hexadecimal number, some use $FF or FFh or even 0x, but this guide uses & - as this is how hexadecimal is represented in CPC basic All the code in this tutorial is designed for compiling with WinApe's assembler - if you're using something else you may need to change a few things. But remember, whatever compiler you use, while the text based source code may need to be slightly different, the compiled "BYTES' will be the same!

Another way to think of binary is think what each digit is 'Worth' ... each digit in a number has it's own value... lets take a look at %11001100 in detail and add up it's total

If a binary number is small, it may be shown as %11 ... this is the same as %00000011
Also notice in the chart above, each bit has a number, the bit on the far right is no 0, and the far left is 7... don't worry about it now, but you will need it one day!

If you ever get confused, look at Windows Calculator, Switch to 'Programmer Mode' and  it has binary and Hexadecimal view, so you can change numbers from one form to another! If you're an Excel fan, Look up the functions DEC2BIN and DEC2HEX... Excel has all the commands to you need to convert one thing to the other!

But wait! I said a Byte could go from 0-255 before, well what happens if you add 1 to 255? Well it overflows, and goes back to 0!...  The same happens if we add 2 to 254... if we add 2 to 255, we will end up with 1
this is actually useful, as if we want to subtract a number, we can use this to work out what number to add to get the effect we want

All these number types can be confusing, but don't worry! Your Assembler will do the work for you! You can type %11111111 ,  &FF , 255  or  -1  ... but the assembler knows these are all the same thing! Type whatever you prefer in your ode and the assembler will work out what that means and put the right data in the compiled code!

We know what numbers we can have on the Z80, but how do we work with them?
When we need to save our results, we will store them to that 64k of memory mentioned earlier, but the memory is some distance away from the processor... to be fast we want to use the memory built in to the processor.
This z80 memory is called the 'Registers'... there's not much of it, but its really fast - so try to use them to do as much as you can! Each Register can only store one byte (0-255)... but some registers can be paired ... so HL together are 16 bits, and can store 0-65535!

Each of the registers has a 'purpose' it is intended for... Of course you can use any register for anything you want! but they all have 'strengths' because many commands will only work with certain ones... and some commands may be slower or need more code if you use the wrong one!

The format of Z80 commands is as follows
   Command   Destination,Source
and brackets () around a register pair like HL mean 'Address in register __'

so... LD (HL),A means "Load A into the address in HL"
Whereas.... LD HL,&4000 means "Load &4000 into HL"
and... LD B,A means "Load A into B"

There are some special addresses on the Z80 processor that are common to all Z80 systems.
The most important are:
RST0 ($0000 - Reset) which is usually the first command executed as the system restarts.
RST7 ($0038 - IM1 Interrupt) which is called by interrupts (Usually VBlank) in Interrupt Mode 1.
NMI ($0066 - Non Maskable Interrupt) is a special interrupt which can be caused by connected hardware, and cannot be turned off with DI.

Note: These may be 'ROM' on some systems (Like the SMS/MSX and ZX Spectrum). This will make using a custom interrupt handler in IM1 difficult or impossible.

The purpose of the NMI address ($0066) will differ depending on the system.
For Example: On the CPC and ZX Spectrum it's not typically used, however the Multiface II Stop button will cause an NMI interrupt (and a call to address $0066).
On the Master System the NMI is more important. an NMI interrupt occurs when the 'Pause button' is pressed on the console unit.

Address

Purpose

You may want to develop for the ZX spectrum or MSX, but you should start with the CPC and WINAPE! Winape has a built in Assembler and Debugger that are second to none!  In the early days you will make a lot of mistakes, and having the compiler , emulator and debugger in one place will save you a lot of time and problems! You can even develop MSX and SPECTRUM code with it - the MSX and Spectrum versions of ChibiAkumas are compiled in winape too!.... If you dont't use widows, Winape works OK with WINE!

To get started, Download Winape from this Link (I'm using V2.0b2)  and extract it to a folder,
Start Winape by clicking on the icon
You should see the emulator window open and show the Amstrad CPC blue screen... the CPC starts straight away into Basic... and the Amstrad CPC's basic is great for testing ASM code! Don't worry if you've never used a CPC before, this tutorial assumes you know nothing about basic or the CPC! Now, Let's get straight into it and code something! Click on the Assembler menu and select "Show Assembler" - or press F3 on your keyboard!
Select the File Menu, then New to create an empty ASM program
We type in our ASM code into the assembler. Note: Winape uses & to mark Hexadecimal symbols not $ Don't worry about the case as Winape isn't case sensitive.... ORG &8000 is the same as org &8000
Select Assemble from the Assemble menu to compile the program!
You will see the Assembler output.  This shows the actual bytes of code that what you typed ends up as! Check there are Zero Errors ... if there are then you've made a mistake typing! Click on OK! Now this is the magic of Winape - your code is now immediately in the emulators memory - so lets go run it!
Now go back to the blue screen... and type in Call &8000 and hit your enter key Basic should return the message Ready if something else happened, check your code matches the screenshot above! What did it do? well we'll look at that in more detail next!

Congratulations! You just wrote and ran your first assembly program - and you now officially Kick Ass! Now we'll look in detail at what the program did, and how to use Winape's debugger to look at it in detail!

Now you've had a a quick go at assembly, lets look in detail at what that program does! We'll look at each line of the program, and explain what it means.
 

 
Ok, we've read over the code, lets use the debugger to see the Z80 run the code!

If you still have your assembler open, just click on its window If you closed it, just click  Show Assembler from the Assembler menu
Click on the Grey Area next to the command "LD A,4" A red blob will appear! This means before the Z80 runs the command "LD A,4" it will stop, and the Debugger will appear!
Select Assemble from the Assemble menu to recompile the program!
Type Call &8000 again into basic, and hit Enter
If you've done everything right, the debugger will immediately pop up! Lets take a look at what it offers! At the top of the screen you can see the Compiled code... the line the Z80 is running is highlighted. On the Right you can see all the Registers - you should recognize the names! remember our code uses A and B... A is the first half of AF and B is the first half of BC In the middle of the screen you can see the Memory At the bottom of the screen you can see the Rom and other debugger options... don't worry about them now! In the bottom right is the Stack... we'll cover that very soon!
The Debugger has tons of options we're not going to use right now, but feel free to try them later! Try right clicking on things for more options! You can even change the registers and memory by typing new values in! and remember - The worst you can do is crash your emulator, so there's no real harm you can do - so don't be afraid to mess! If you crash your emulator, the memory will be erased, so you'll have to re-assemble your code from the Assembler before Call &8000 will work again!
Now Lets look at what your code does! Press the F7 key on your keyboard (or the single step button on the main window) Keep an eye on the A and B registers in the debugger!
You should see A change to 4... press F7 a few more times and watch what happens
keep pressing F7 again and again until you get to the RET command! You can press it even more if you want, but remember... the debugger isn't just debugging your code, but the whole CPC... so you'll end up debugging the whole of basic!
When your code has finished running we have one thing left to do.... Remember the program wrote to &7000 ? Scroll through the memory browser to find &7000 - and you should see our final value for A  has been saved there!
You can open the debugger by selecting Pause from the Debug menu at any time,  or by pressing F7 - and just close it when you've seen enough and want your emulator to run normally!

Think back on what you've just done, You've written a program, compiled it, run it, and watched everything the program did at the CPU level in more detail than you've probably ever seen any computer work before! Not bad for a days work! - and this is just lesson 1!

Adding a few numbers may not seem much, but it's just the start, and you'll soon find you can make the computer do amazing thing! Also, don't forget, once you understand the basics, you can use pieces of other people's code to do the work you don't want to! These tutorials will show you how to build on the open source code of the Chibi Akumas game to allow you to make big progress super-fast!

I highly recommend you type the programs in yourself, but you can download the source code with comments Here (Contains source for all lessons)

Lesson 2 - Memory copy, Symbol definitions, Loops and Conditional Jumps! Now you've got Winape up and running, and had a go at programming, we can get on with learning some more commands! We're still going to do simple things, but let's use the CPC's screen this time, so you can see the results of your code! The CPC screen memory is at &C000 and takes up &4000 bytes!

Open up the assembler      (Remember: Press F3 or select Show Assembler from the Assembler menu) Create a new document       (File... New) Type in exactly what you see to the right!... there is a typo in this code  - so we're going to have to debug it Once you've typed it in assemble it!       (Ctrl-F9 or Assemble from the Assemble menu)
Oh no! there's an error!... what a surprise! Click OK to close the assembling window, and lets sort that error out!
The error that occurred will be show at the bottom of the screen... double click on it, and the cursor will jump to the error! Whoops, we've put BD ... theres no such pair! correct the error to BC Now reassemble the program, and you should get no errors!
Type Call &8000 and hit Enter
The screen will clear, and the top line or two will have some weird junk on it!

You probably think this is weird, but when we look at the code, This is exactly what we'd expect to happen... so lets break it down line by line!

So we've copied 16k from &0000 to the screen - and what is at &0000 - well some system junk, and any basic programs!
don't believe me?... type:
    10 print "moo"
    Call &8000
and you'll see some more junk appeared! that new junk is your program as it appears in memory!
Of course if you set DE to &0000 and HL to &C000 - you'd copy the screen to your system area - and your machine will hang!
it will also hang if you set BC to &5000... why? well when the destination gets to &FFFF it rolls over to &0000 - again overwriting your system area - but give it a go if you want, there's no harm crashing an emulated machine!

By default the CPC screen starts with &C000 at the 'top' but if you make basic scroll up and down, the 'Top' will move somewhere else, if you press the down cursor until the screen scrolls - then call &8000 again you'll see the junk appear somewhere else You can always reset the cpc by typing "Mode 1" in basic (reset to screen mode 1)

Ok, you've had a quick look at LDIR,
Now lets try another more useful example,

Type in the example code to the right, and assemble it as before
Assuming you got no errors, lets run the program. The ORG was different this time, so type Call &8100
The screen will clear! What's interesting is that this simple ASM code is faster at clearing the screen than the firmware's own CLS command!... and there's a lot of tricks we can do to speed it up even more... but we'll leave them for another day!

What did that code do? well lets break it down!

Mathematics in ASM code in Winape code is pretty dumb... it can't do brackets like 2*(5+1)... and it doesn't do multiplication first.... Usually you'd expect 5+1*2 to be equal 7... but in winape this equals 12! Why? well winape does each command from left to right, so 5+1=6... then 6*2=12...it takes some getting used to, but it does work fine!

We have one last version of this program to try!

Type in the code to the right, and compile it... you should get no errors. There's some new commands in here, but take a look at them in a minute!
Type Call &8200 and hit enter
The screen will do a strange 'fading clear'... Weird huh? Ok, it's not very useful, but it teaches us a lot of good stuff!

Lets take a look at the code, and see why it does what it does!

Now you know how to do a loop! in fact JP Z and JP NZ can be used like LOOPs, IF statements and even CASE statements! Actually - you don't have a lot of choice as assembly has so few commands - but remember... all other programming languages compile down to Assembly - so anything Basic or C can do is possible in ASM - and ASM will always be fastest if you do it right!

So we've used a Label, and a jump (JP) to create a loop!
there are three kinds of Jump command that you should know!

So those are the Jumps we have available, but some of them need a condition too!...
we have 4 main conditions we need to so lets take a look at an example - you don't need to type it in

There are 4 basic conditions we can use in this situation - it's annoying, but what the condition  officially means, and what it does in this case are different

*** Note: while CP always works, not all mathematical commands affect all flags - see the cheatsheet for full details! - eg "inc hl" does not set the zero flag!

Lesson 3 - 'Case Statement' , 8 bit basic Maths, Writing to Ram and Reading from basic We used a Jump to effect a loop last time, but sometimes we'll need to jump to different places depending on a value. Also, lets take a look at how to do some everyday maths in 8 bit... and finally, we'll use a simple basic program to act as a 'frontend' to our assembly Lets get straight into coding!

We're going to write a little Assembly calculator Create a new assembly document, and type in the program to the right. Compile it - you should get no errors! You'll notice that the program takes it's input and output from 4 memory locations: &9000 Command Num &9001 Var 1 &9002 Var 2 &9003 Result We're going to access these from a basic program - which we'll write now!
Type the program in to the right in basic if you're not familiar with Basic, Don't worry about what the commands do, we'll look at them in a moment

ADD and SUB in assembly can add or subtract up to 255 from a register, but if you only need to add or subtract one, use INC or DEC, they increase or decrease a register by 1... INC and DEC commands take only 1 byte, so they're faster than ADD and SUB... and they work on 16 bit registers like HL ADD and SUB only work on the 8 Bit Accumulator, but we'll learn how to do 16 bit equivalents later!

Type RUN to start the program and hit enter. Enter the values for the Variables as 20 and 5, hit enter after each value When asked if you want to Add or Subtract, Enter 1 for subtract The result will be show onscreen!

Feel free to try other values in the program, but it only uses 8 bit registers, so it can only do up to 255, and can't do negative values right! Right now it'll only do Addition and Subtraction because there aren't any built in Multiply or Divide commands on the Z80 - we're going to work around that next!

Lets take a look at the ASM code!

Sometimes in ASM there's a smaller, faster command that  has the exact same result as another! For example, you can use "OR A" instead of "CP 0" "ADD A" instead of "SLA A"... and "XOR A" instead of "LD A,0" The result is identical, but you'll save some speed and memory!... it'll just look a bit odd in your code! It's something you'll want to learn to use.. so why not give it a try now!

In case you're not familiar with CPC basic, lets take a look at the basic code!

Using basic to 'launch' and test your ASM code is a great way to develop quickly and ease testing Using PEEK and POKE to get data to and from your program is a good solution, but you can also pass variables using the CALL command, but it's a little tricky, so we'll cover it later!

We want to add Multiply and Divide commands, but unfortunately the Z80 does not have these commands! but we can simulate them by repeatedly using the ADD or SUBtract commands!

use EDIT 30 to edit the line showing the options, make it the same as This

Run the program!

You'll now be able to do multiplication, but only if the result is less than 255! You'll also see that negative numbers don't work! If you try a number that ends up too high, or below zero, you'll get a strange number, that's because the numbers 'roll around' from zero back to 255 Later we'll upgrade the program to use 16 bit numbers, so we can go from -32768 to 32767! Take a look at the Hexadecimal tutorial at the start of this document if you want to know more about negative numbers now! You can get the source code for this lesson (and all the others) in the sources.7z file... the basic code can be found on the included disk image!

Repeatedly adding or subtracting a number to 'fake' Multiplication or Division is silly and slow, but if you only need to Double or Halve a number you can use bit shifts... we'll cover them soon! You want to try avoid needing Multiplication and division if you can in your code, so design your game not to need anything except halving and doubling... of course you can do x4 or x8 by doubling twice or three times!

There are clever ways of doing Multiplication and Division that are much faster than this... but they are to complex to cover yet... but fear not - they're documented here when you're ready for them!

Lesson 4 - Stack, Strings,Compiler Directives, Indirect registers, CPC Call That was a nice little program, but we still have some basics to cover! You'll have noticed there's not many Registers, and you'll often wish you had more. So what can you do if you have a value you need later, but you need to do something else first? We need some temporary storage, and we have something called the stack for that!

Lets suppose we have a value in A ... we need the value again later, but we need all our registers now too... what can we do? Well that's what the stack is for, it's a temporary store!
The stack is like a letter tray - we can put an extra sheet on the top of - and take it off later, but we can't get one from the middle, so we always get the Last one we put in - this is known as LIFO - Last in First Out
We use PUSH and POP to push a new item onto the stack, and pop it off later.

Lets look at two examples, and see why we want the stack!

Suppose we have a Call 'PrintChar' which will print the character in A ... and another call 'DoStuff' which will change all the registers - how can we keep A the same before and after this 'DoStuff' command?  Well, we could save A to some temp memory - or let the stack take the slack!

don't type this in, it won't actually work!

Both these do the same thing, but  commands like LD (temp),a takes 3 bytes, and PUSH AF takes only 1.. and it's faster! also you no longer need that Temp: db 0 ... so that's another byte saved!

the stack always works in 16 bit - so even if you only want to save B - you'll have to PUSH BC - but don't worry , it's so fast you won't mind!
note:  the F in AF is the 'Flags' (the Z NZ C NC in comparisons) - they're saved with A when you do a push.

You can push lots of different things onto the stack, but remember they will come out in the same order... you can even do  PUSH BC then POP DE to copy BC into DE

The order is important! if you're unclear on how the stack works, you can use the Debugger in winape to step through your program, and see what the stack does as your program works! seeing things happen step by step in the Z80 is a great way to see how things are happening

Lets do an example of the stack! Type in the program to the right!
Type Call &8000 and hit enter. The screen will 'Pause' so press A You should see A|x|A onscreen Run the program again, and press a different letter!

What was the point of that? well lets take a look at what the program does!  I've colored the PUSH, POP commands so you can see what POP gets the matching value that was PUSHED

So we can push items onto the stack, and get them back later so long as we need them in the same order!  But the stack doesn't just operate for us.. the Z80 uses it too
When we do a 'CALL label' command, the current running address is pushed onto the stack - effectively the Z80 does 'Push PC    JP Label'
When we do a 'Ret' command... the Z80 effectively does 'pop PC'
Pc is the program counter - the current address the z80 is running... now this Push PC and Pop PC command don't really exist, but that's what the Z80 does - and you need to know this so you know why this program won't work:

If you don't understand the stack yet, try making some test programs, or editing the one you just typed in! The stack's used so much you'll see plenty of examples - and you'll soon get used to it!

The stack is the fastest way to read and write memory on the Z80 - if you're clever you can use it in a 'tricky way' to quickly do things like fill the screen. We'll learn how to do it later - it's an advanced trick, but if you want to make the Z80 as fast as possible - that's how to do it!

We'll move on from the stack - Lets have a look at another little program! - we're going to use the previous PrintChar command to make a string printing routine.

Type in the program to the right. Assemble it - you should get no errors We'll explain what each line does after we run it!
Use Call &8100 to run the program It will print a little two-line message to the screen!
Chage the first line - put a Semicolon ; at the start of it - this marks it as a 'comment' - which means it does nothing in the code Assemble it - you should get no errors
Run the program again - The message has changed!

Writing somthing as simple as a print string routine may seem a pain - and you're probably wondering why the firware can't do it for you, But writing your own routines is the best idea - firstly - you'll know exactly what they do, and you can change them later to add special functions - and more importantly - you can port them to other systems and they will work the same! The less you use the system firware the better! your Z80 code will work the same on a CPC / Spectrum or MSX - firmware calls will not!

That program probably seems rather long, but there's lots of good stuff in there! Lets take a look at it line by line!

Feel free to try other values in the program, It's important to note that the IFDEF is actually changing the Compiled code - the 'message' that is not shown DOES NOT EXIST in the compiled data! This allows you to compile multiple versions of your program - Chibi Akumas uses this to compile different builds of the game for CPC, ZX spectrum and MSX - and for different languages - all with one code base!

Suppose we have some bytes of data we want to read from a 'bank' of data - but we want to read those bytes by specifying an offset relative to the start address - we can use the Indirect register IX or IY to do this - lets look at an example

Type in the program to the right, and compile it. It's pretty long, but The bottom part is identical to your previously entered one, so just copy and paste it, from your last example - or just add the new code to the bottom of your old one. If it's too long, you can always download the sources file and just run it from there.
Run the program by typing Call &8200 It prints a message inside two kinds of brackets

Don't underestimate calls from basic! A great way to make your first game is to write the logic and input routines in basic, and call out to assembly for things like drawing sprites and music! The important thing is the result you achieve, not the method - so why not make things easy for yourself and do some of the work in basic - you can always convert it to ASM later once you've worked out exactly what you need to do!

Lets look at the program and see how it works!

The Chibi Akumas game uses IX to point to the Player settings - the Player routine gets the Life - position - health etc of the player via IX+... references This allows the same routine to handle both players just by changing the IX reference when the function is called - the first time it points to Player1's data - the second time Player2's

That example of IX was rather useless, but the IX register has a far more useful function on the CPC - we can use it to get data from the Call statement! Lets take a look at an example!

Type in the example to the right - it's rather long - if it's too much trouble, remember all the examples are in the downloadable sources file. The Printstring function is the same as before - so you can just copy and paste it.
Try typing Call &8300 Because you didn't give a parameter You will see a 'usage message' Type Call &8300,12345 You will see '12345' converted to 16bit hexadecimal! Feel free to try it with some other numbers!

We've created a Decimal to Hexadecimal converter! and it gets its data straight from basic!

Lets take a look at the code and see how it works

Using IX is great - but it only works on the CPC - the MSX can pass one variable (see the basic documentation) but other systems cannot really do this - just use the POKE function in the previous example instead! Other than CALL commands IX functions are great for settings data - you can use them for passing references to sets of data that you want to access and alter 'randomly'

Lesson 5 - Bit level operations, Self modifying code Because memory and commands are limited, you'll quite often want to do things at the bit level, You can use bits to alter numbers, create patterns, and with conditions control actions from the different bits in a single byte Lets use the CPC screen to see what bit commands do!

Type in the program to the right, and compile it
Type in Call &8000, and see what happens
The screen colors will have gone weird! It's not clear what happened in 4 color Mode 1 Type in Mode 2... and Call &8000 again!
Try changing the XOR to AND or OR Change %11111111 to other values like %11110000

Lets take a look at what that does to Mode 2 - where each bit is a pixel!

Lets see how that works at the bit level!

Each Bit is a pixel in Mode 2 - but in Mode 1 it takes 2 bits the right half of the byte (%----XXXX) is color 1, the left half (%XXXX----) is color 2 - if both are set the result is color 3, eg (%00010001) will set the right hand pixel to color 3 It sounds weird, but just give it a try and see the results - and you'll soon understand it!

You can use NOT AND and OR to do operations on all the bits, but you need to use A - BIT SET AND RES can check, set and reset bits but can be used on other registers without affecting A

Lets give it a go!

Type the program in to the right and run it. If you remember from before, you'll know IX is used to get parameters.
Switch to Mode 2 Try Call &8050,&40FF Also give Call &8050,&80F0 a go! The first part of the parameter must be &80 or &40 - but try other values for the second part!

Lets take a look at the part of the program with new commands! we're going to skip over commands you should already know!

Each bit number is a position from Right to Left

There are 3 types of single bit commands, they can work on almost any register, where as AND %00000001 or OR %00000001 and CP %00000001 only work on A - and AND or OR will change A - these will not

These commands are great for using 'settings' variables where each bit has a different meaning - In Chibi Akumas the pressed joystick buttons are stored in a single byte and "BIT b,r" is used to test each button. Things like object movements use different bits in a byte to allow a single byte to define all the possible move directions and types the game needs!

Sometimes we want to move the bits around in a byte, this can be be to double or halve a value, or to take a couple of bits 'out' of a byte via the carry.

Lets try out the bit shifting commands! Type in and compile these two examples! there are two versions because one is for shifting Right (&8100) and Left (&8200)
Type Call &8100 and see what happens! You'll want to see it run continuously, so type in a little basic program to repeat the process Try the Call &8200 version - and modify the program to Call &8200!
Try replacing "SRL A" with "RR A" or "RRC A" or "SRA A" - see what each does! Try replacing "SLL A" with "RLA" or "RLC A" or "SLA A" - see what each does! *** Note: SLL is an undocumented Opcode, and may not work on Z80 compatibles... For example it DOES not work on the eZ80 *** We'll take a look at them in detail in a second!

So what do all those commands do? well first we need to understand the Carry Flag!
The Carry Flag is a single bit that stores the 'overflow' from 8 bit maths.

Question: What's 192 Plus 128?
Well in 8 bit maths - it's 64 - with a carry of 1... why? because, 8 bits can only count up to 255, and if there was a 9th bit it would be 1 - and the normal 8 bits would be 64 - confused?  well lets take a look at it in binary

So the Carry allows us to store the 'overflow' from maths - and allows us to use 8 bit registers for 16 bits, or 16 bit register pairs for 32 bits... but they also allow us to do clever things with bits! Some commands use the carry to shift bits in and out of the register
Now lets take a look at what all those commands do!

Shifting bits around can be used to change values in all kinds of ways -for example shifting left doubles a value, Shifting right halves it. You can do repeated bit shifts to take a byte apart, and load it into other registers, or reverse it.

Lets change the subject a bit!
Remember the 2nd program? - it used a parameter passed by IX to decide what command to do?
The screen fill loop runs over 16,000 times, and using CP and Jump commands in that loop slows things down a lot!

What we really need is a way of comparing the parameter, and changing the action that takes no extra processing power... sounds impossible? well it's not... we make the program change its own code!

Because the program is in memory - and we can change memory, we can swap values or commands in our program whenever we want!

Type in the program to the right and compile it, If it's too much trouble, remember, you can always just get it from the sources file!
Run the program with Call &8300,&xxyy Where xx is a command number from 01-03 , and  yy is a bit mask from 00-FF You'll be able to see the result best in mode 2
Try putting a breakpoint in before the loop (at ld hl,&C000 , for example) Notice the NOP commands have disappeared  and been replaced with a different command! (NOP means NO OPERATION - it  does nothing and is just a placeholder)

Lets take a look at the new commands in the program, and see how it works!

Self modifying code doesn't just allow you to make slow conditions fast, you can save memory with temporary variables.

For example, both these do the same thing:

See what we did? rather than storing the variable in a separate temp location, we modified the LD command - so now the variable is in the code, saving memory - and this is faster too!

Self modifying code is tricky, so don't worry about using it for now! One day you may want to make your program as fast and efficient as possible, and Self Modifying code will be waiting to do that for you! Just get used to the normal stuff and remember this as something you need to know about, even if you don't use it!

Lesson 6 -  Lookup table, Screen Co-ordinates, Vector Tables, Basic Parameters Byref We've covered most of the essential commands now, so we can do something pretty impressive this time! We're going to create a program that grabs sprites, and prints them on screen - that you can use from your own basic programs! Enough talk though... Lets make a start!

This lesson's code is quite big, so you may just want to download it from the Sources file. We'll enter it in sections, and look at what each section does, then run it!

Type in the code to the right You can't compile it yet, there's a lot more work to do!

We can use a lookup table to read data from - in this case, our screen location contains 2 bytes, so we add the 'index' (ypos) twice to the start address, then rad in two byte.

The code you've entered coverts X,Y co-ordinates to screen locations - and calculates the position one pixel line down from the current memory location! this will be used to work out where our sprite will be drawn/read from, and to work through the sprite line by line

Aligned code is code that starts from a certain byte boundary - it is used for speeding things up, or look ups - by knowing where the data will start, we can save time by using INC L rather than INC HL - as we can know H will not need to change... the ALIGN command allows us to make assumptions about the position of the following code, without being as rigid as an ORG command

Lets take a look at  what the ALIGN command does In this example we have a few bytes of 1's defined with DB 1,1,1 The ALIGN xx command will align to the next xx boundary... in this case, it aligns to a 16 byte boundary The ALIGN 16 command inserts zeros as required. The DB 2 inserts a 2 - note it's aligned correctly!

Aligned code allows you to do all kinds of clever things! A common trick is to define a 256 byte aligned table - with the "Mask" to erase the background when pixels are color 0 for every possible byte a sprite could contain -  By setting H to the start of the table, and L to the byte - the mask can be applied by LD A,(HL)  AND A It sounds confusing, but you'll soon think of lots of clever things you can use Lookup tables and Aligned code for!

We can't run the code yet, because we're missing the sprite grabber - but lets take a look how it works!

The next part of the program is the sprite grabber!

Type in the program to the right! You still won't be able to compile it without the 3rd part!

This routine grabs a sprite from the screen with "&8000,MEMDEST,X,Y,W,H" - and returns the next free MEMDEST with "Call &8006,@int"

IX and IY are 16 bit register pairs like HL, they're actually made up of 2 registers we can use for whatever we want!
IX is made up of IXH (IX-High) and IXL (IX-Low)
IY is made up of IYH (IY-High) and IYL (IY-Low)

They aren't as fast as other registers - but there are times they are useful - in this example we use them as loop counters!

These registers are undocumented - That means they weren't originally in the Z80 manual - but all Z80's support them, they even work on the MSX Turbo-R's R800 - so don't be afraid to use then! Back in the 80's people didn't know about them, so we can use them to give our programs a speed advantage over the old games!

In CPC basic, putting @ before a variable will pass it as a 'reference' - this means we get the address of int, not the just value - and our program can change the value that the basic variable has! This allows us to store the memory location of sprites in integers in basic!

But make sure you specify they are integers by putting % at the end of the variable - otherwise they will be a floating point number,  eg s1%=0 will define s1% as an integer.

You can pass other data types, but they're harder to use, as you need to know how data such as strings and floating point numbers are stored on the CPC 16-bit integers are easiest to work with, so make sure you put the % symbol at the end of the variable name!

Lets take a look at how it works!

HL has more power than anything else, but sometimes we want to use DE for the same job - well, we can't! but we can swap HL and DE quickly to do what we need - it's faster than any kind of PUSH POP options if you just need to swap the two - in this case it allows us to use LDIR to read from HL, and write to DE!

One last bit to go! The PutSprite routine... don't give up, the finish line is in sight! Type the code to the right! Compile it, you should get no errors!

Now we can Grab sprites, and Print them to screen!
Here's a little Basic program to try it out!

Type in the program to the right. It will define 3 sprites, one of 9 numbers (Stored in S1%) one of 9 letters  (Stored in S2%) one is blank (stored in S0%) Run the program, it will show one of the sprites on screen!

Lets see how our basic program uses the commands

Now you can make and use your own sprites from Basic!

Need more inspiration? try adding the basic code to the right! This will show a sprite on screen, and erase it - you can move the sprite with keys ZX K and M Don't let the sprite go off screen though! there's no checking and it may crash the CPC The basic program is on the Sources.DSK image!

INKEY$ reads a character from the keyboard, it's a quick easy way to read input! In this example we use it to move a sprite around the screen! I'm sure you can think of more interesting things to do with the code in todays lesson!

We can use the same code we just used in our look-up table for calling subroutines - we can take a 8 bit integer, and use it to decide on a Jump.

"CP X    JP Z,YYYY " uses 5 bytes per command!
A Jump block uses 3 bytes for each command!
A vector table uses only 2 bytes per command!

If memory is tight, a Vector table is the best option... and a jumpblock does not get slower when working with a lot of entries - where as repeated "CP x.. JP Z,yyyy" commands will waste CPU power for each command skipped over to find the matching label

We use DW xxxx to define a 16 bit word - we could do the same with 2 DB commands - but that would make no sense in this case

Let's take a look at a vector table! Add another jump to the Jump block below JP GetMemPos
Type in the program to the right and compile it You can run it with Call &8009,x  - where x is 0-2 This will call one of the commands in the VectorTable
if we ALIGN the vector table so all the commands are in the same byte boundary we can make the Vector table lookup simpler!

Lets look at how the Vector Jump works!

Lesson 7 - DI EI, RST x, Custom Interrupts, IM1/IM2, HALT, OTI / OTIR, HALT We're going to learn how to interface with the hardware, and take over the last job of the firmware - so we're going to have to cover a lot of technical content now, so we understand what we're doing! Both examples are included in the Sources download, just enable,or comment out the "Eg2 equ 1" declaration to toggle between the simple example - and the final one

CALL commands take 3 bytes, but there is a special way the Z80 can do a limited call in just 1 byte! these call to an address in the first 64 bytes of the address space!

These are called with the commands RST 1 to RST 7 ... and they each call a different address - depending on the platform they may be in use, or have a special function. of course, if we don't need the firmware, then all bets are off, and we can do whatever we want with them!

Unfortunately because systems like the Spectrum and TI-83 have Read only Memory in the address range &0000-&3FFF - so we can't write our own RST's
The MSX Rom has predefined RST's, but if we page in RAM, then there are none defined

RST's are only really useful when you need to do the same call or a few commands a lot! Sometimes you'll see RSTx followed by a byte or two... (EG EXOS - rst6 on the MSX)  The RST function will be looking at the stack, and reading in the 'calling address' to get the location of these bytes as parameters - then modifying the return address to skip over them!

Lets take a look at the RST's on each system, with the firmware use of them

The one we're really interested in here is RST7 at &0038 - because this one is called automatically by the system hardware when IM1 is enabled.
There will be times we need to do an event with controlled frequency, for example playing music, and to do that we use the 'Interrupts' of the system
Interrupts are when the hardware forces the Z80 to process tasks for it - and up until now we've just let the firmware do them itself, but now we're going to look at how to take them over ourselves

the commands IM0 - IM2 change the interrupt mode of the z80

IM1 is the most useful to us, IM0 is pretty irrelevant to us as programmers, but on the spectrum we can't write our own IM1 interrupt handler, as the rom stops us writing to &0038, but we can use IM2 - but it's more complex... so we'll look at that later!

Not only does writing our own interrupt handler and do 'timed' actions, but if we take over this task from the firmware, then we can be in control of all the Z80 resources - and this includes the 'shadow registers' that' we've not seen until now!

Now we've taken total control of the Z80 from the firmware - and we can use all it's registers without worrying about the effect on the firmware (unless we return to basic!)
This gives us access to the Shadow registers - the Z80's 'spare' set of the registers AF BC DE and HL -  these are switched in by the firmware so that the main registers are not altered and the program can resume once the interrupt is done!

You'll notice that there are no shadow versions if IX or IY

The shadow registers cannot be used in combination their normal counterparts, instead we 'toggle' the shadow versions in or out using two special commands which 'swap' the normal and shadow versions.  Of course we could just use PUSH and POP to get the same effect - but swapping the shadow registers is faster - which is why they exist, to allow the Interrupt handler it's own registers to quickly use without affecting normal ones!

So we can swap just AF... or all the other main registers... because we can's swap just some of the 16 bit registers, if we just need to use one pair such as  DE or HL for a while, PUSH and POP are better...
EXX only works when we need to use ALL the registers...  so times when a separate job needs to be done for a while before carrying on with the main job may be the usage case of shadow registers.
For example In Chibiakumas this is used in the bullet loops, where the main registers are used for calculating bullet position, then the shadow registers are used for player collision detection, before switching back the main registers to continue the loop.

On the systems we're looking at interrupts only occur based on the screen refresh, but the frequency varies depending on the system, some systems need you to 'tell' the hardware the interrupt it's been processed otherwise it'll keep happening immediately again! - lets look at all the Interrupt facts by system so we know what we're dealing with for the systems we're interested in

System	Interrupt frequency	HZ	If interrupt is missed	How to clear the interrupt	Firmware / Interrupt  register usage
	6 times per screen draw (CPC+ can have line interrupts)	300hz	Interrupt happens as soon as possible	no need	All shadow registers used Shadow register BC' must not be changed or firmware will crash
	Once per screen draw	50hz	Interrupt never occurs	no need	Shadow registers are not affected IY must be preserved for firmware to work properly (IY Should be &5C3A?)
	Once per screen draw	50hz	Interrupt happens as soon as possible	in a,(&99) (when chosen VDP status reg is set to default of 0)	Shadow registers are not affected No registers need to be preserved
	Once per screen draw	50hz	Interrupt happens as soon as possible	ld   a,30h out  (0b4h),a	Shadow registers are not affected No registers need to be preserved
	Various such as line based (port 249) (default Interrupt will happen once per redraw)	50hz	interrupt never occurs	no need	Shadow registers are not affected No registers need to be preserved
	Once per screen draw	50hz (PAL) 60hz (NTSC)	Interrupt happens as soon as possible	no need	No default interrupt handler Note &0066 is the NMI interrupt handler, which is executed when the pause button is pressed on the console
	Once per screen draw Non standard - address &0040 is VBLANK	60hz	Interrupt never occurs?	No need	No default interrupt handler

The Interrupts will occur automatically at the appropriate time, but we can wait for one to occur, by using the HALT command... this will cause the Z80 to wait for an interrupt to occur.

There may be times we cannot allow interrupts to occur -   We can stop interrupts from being allowed for a while by using DI - and allow them again using EI...
On most systems if an interrupt is missed it will occur immediately, but on the Spectrum it never happens - see the table above for details.

There are many times you may need to stop interrupts: if you're interrupt handler uses the shadow registers and you need them... if you're communicating with a series of OUTS that interrupts would conflict with (Keyboard and sound chip are on the same CPC ports)... Disabling Interrupts reduces the complexity of debugging too, so if you don't need them, you may as well disable them. Finally there's one special reason why interrupts can't run... If we've altered the stack pointer then the RST7 call cannot occur... we'll learn why you may decide to do that next time!

Interrupts are the only time the hardware takes over the CPU - but there are times we need to give instructions to the hardware, or receive data from the hardware... and we use the commands OUT and IN to send data to the hardware.

If you think of the computer hardware as a telephone system, and each piece of hardware has a phone numbers from 0-255 (called a port)

OUT (xx),yy  will call the hardware at number xx - and give it message yy

IN (xx),yy will call the hardware at number xx - and receive a message which will be stored in yy

Hardware you may access will be things like screen hardware, memory bank switchers, disk systems,joysticks and keyboards - the ports that you'll want to use, and how to use them varies depending on the system.. 

Now! there's a catch!  The Z80 in the  ZX spectrum, Sam Coupe and the CPC are wired oddly... they use 16 bit ports and use BC as the port number - even though the assembly command is Out (C) the command in the assembly code is not the one that effectively occurs when the Z80 runs it....

Even worse, some devices are listening to many ports, so OUT ing to &7F00-&7FFF on the CPC should have the same effect - usually one port is the 'recommended' one, and others just 'may' work (I had color changing code that sometimes worked fine, and other times corrupted disks) 

Let's make this command confusion clear, or this will waste a load of your time!

System	Command in ASM code	Command the system actually runs
	Out (C),A Out (C),C Out (n),A OTIR	Out (BC),A Out (BC),C *** Does not work *** *** Malfunctions ***
	Out (C),A Out (C),C Out (n),A OTIR	Out (C),A Out (C),C Out (n),A OTIR

The Z80 has some 'incremental' commands for OUT like OTIR that are functionally similar to LDIR ... because these commands alter B, and B is used as the address of the OUT command these commands will malfunction...

On the Amstrad CPC we can use port &7F to control the screen colors - and because the CPC interrupt occurs 6 times a screen, by changing the color every interrupt, we can get more colors on screen than normally possible - This is how Chibiakumas gets around 8-10 colors on the 4 color mode 1 screen!
We're going to do this ourselves, in the next example

Outs are confusing and hard work! but you won't want to write them very often! In practice what you'll do is write a function to control the hardware, then you'll forget about how it works and just use that function, so just find a good example online of what you need to do, and just stick to the safe code they use!

Well, that was a lot of theory! but it all fits together into a really neat example!

Type in the program to the right. Compile it, and run it by using Call &8000 Note, this example does not return to basic, so you will need to reset your emulator
This program will change the background color each interrupt. You will see the background color change six times during the screen refresh! (the first one is offscreen!)

How does it work? well lets take a look at the code!

We need to take more care if we need to keep basic and the firmware happy! You'll need to do return to basic, or use firmware calls for screen operations - or disk access! On the CPC we need to keep the interrupt handler we replaced, and back up shadow register BC' - the the firmware will be OK

Now lets take a look at how to change all the colors, and this time we'll do some screen changes in between interrupts - and we'll back up everything so we can return to basic!

Type in the example to the right Compile it, and run with Call &8000 This example will flip the screen colors 10 times, then return to basic
This version will change all 4 screen colors, at all 6 raster points - and returns to basic as if nothing had ever happened!

We can only easily change colors at these 5 points... Drawing each line of the screen takes 64 ticks/cycles... if you want to change color each line, or on a specific line, you need to delay the processor with enough NOP's to get to the line you actually want!

So how does this one work? lets take a look!

We're totally kicking ass now! We've now learned how to communicate with the hardware ports, we've made our own interrupt handler, and we've learned how to use the 'Shadow Registers'... We've now learned almost all the Z80 commands! There's not much left to learn before we know everything!

Lesson 8 - Unwrapped Loops, Stack Misuse for speed & rarer Z80 commands We've covered the all the most important commands, but there are others you may wish to use time to time... Also there's some clever tricks you'll want to know, that are often used for graphics to make sprite and fill routines as fast as they can be!

Lets take a look at the remaining commands the Z80 has that you may wish to know!

There are two registers left that we've not looked at, they have limits, but they may be useful in some cases!

The first one is R... this is used by the system to 'refresh' the memory to keep the data ok in ram... now you should not change this register, because it could cause damage to the memory, buy you can read from it fine - it will have a value in it from 0-127... and as it constantly changes it may be useful as a random number seed!

The other is I... this is used by Interrupt Mode 2 (IM2) - but unless you're using the ZX Spectrum you'll be using IM1, and it does nothing in IM1 - so I is free for you to do whatever you want...
Unfortunately there are only 2 commands, one to load A into I, and another to load I into A ... but it's faster than PUSH and POP - so if you want, you can use it for temporary storage!

The I register isn't a lot of use as a general register, and you'll need it for interrupts if you end up using the Spectrum. In Chibiakumas, The I register is used on systems except the spectrum... an assembler 'Macro' replaces LD I,A with a ld (&xxxx),a command on the spectrum - it takes a little extra memory, but means the spectrum version works without the I register for storage.

Converting 16 bit bytes for screen display is hard, and sometimes you may wish to just use 'Binary Coded Decimal'...

This is where each byte only stores a number from 0-10... this is how ChibiAkumas stores the player score, there are 10 bytes for each of the 10 digits, this makes showing the score quick and easy.

DAA is a strange command I've never had need to use, it's very complex, and you should look at the Zilog manual if you want to really know about it... the main people actually use it is nothing to do with Binary Coded Decimal, but in fact to convert a byte with a value of 0-15 to a hex char using the sample below

there are two other even stranger commands! RRD and RLD, I've never used them, and I can't think why you would, but here they are!

There are some commands which do maths which will also use the Carry flag, this allows mathematical operations to include overflow from previous calculations. There are 8 bit and 16 bit commands, lets take a look at them, Rather strangely the only 16 bit subtract command is with carry - there is no SUB HL,DE!!!

As mentioned there is no way to subtract without the carry, so there may be times we need to set or clear the carry flag... another time will be if we want to use the Carry as a status flag - eg some disk routines set the carry flag if reading worked, and clear it if it failed.

There are two commands

I bet you thought CCF would clear the carry flag, well it doesn't! but there is an easy way to clear the carry flag! just use

Alternatively, you can just convert a positive 16 bit number into a negative one, with the following code!

There are two 'Special' interrupt return commands RETI and RETN... to my knowledge there is no benefit to using these and they have no practice use on any system I know.

We looked before at LDIR, but there is an alternative, LDDR - this version of the command is for use when HL is pointing to the END of the range you want to copy

Rather than copying, there are two 'search' commands, which will scan BC bytes from HL to find byte A ... I have never used them, but maybe I'm missing something!
Lets summarize all those commands

There are a few special bulk IN and OUT commands, however as before, because BC is used as the port address on Amstrad and Spectrum, they may not work, and I doubt you'll ever need them, but here they are!

The INI command may be useful for reading from something like the Keyboard into a buffer... just remember that it decreases  B each time you use it, and the Amstrad and Spectrum won't like that one bit! if you use it in a loop, you'll need to reset B, or do an INI, then an INC B and everything should be fine!

The stack has a couple of special commands, that may help if you're being tricky (Stack misuse - covered soon), some we'll use in a moment, but there's a couple that you should know

Some commands only work with a certain selection of registers, so check the Cheatsheet to see the full range of 'options' available!

Now, lets move on to the lesson!

There are times when we need as much speed as possible, especially when we're drawing to screen... When we loop around a command like LDIR a lot of time is wasted with compare and jump commands, If we have enough memory to spare - we can jump less, and copy more data - lets take a look!

First lets create a 'slow' version with a regular LDIR command - this program will copy the whole screen TO and FROM a 128k memory bank

Type the program in to the right. It gives you 2 commands Call &8000,xx - will copy the screen TO bank xx Call &8003,xx - will restore the screen FROM  bank xx xx should be a CPC bank number from C4-C7 or C0 ... other banks may work if you know how CPC banks work!!! Note, This program will not work right on a CPC464 - as these banks only exist on 128k systems, all the commands will copy to the same bank!

Most of this should be pretty clear to you by now, but lets have a look at that Bankswitch Command!

on the CPC there are 8 possible bank configurations, &C0 is the default, where the main 64k are in memory....  the other options are shown below:

If you have more than 128k, you will have options C8,C9 and so on... up to FF if you have 512k! Note, you cannot use &C2... this swaps out &8000 - which is where your program is, so it would cause a crash!

Now let's unwrap the loop... We're going to make a few changes, and make it faster!
Lets  try this faster version we use 16 LDI commands - by skipping the R (repeat check) for most of the commands we can increase speed by around 25%!

You only need to make a few modifications to your code for this faster version! Replace both the LDIR commands with "Call UseLDI"
Add  this function to the bottom of your code! Try the new commands, you should see they're noticeably faster!

We've sped things up but of course, the code is bigger! We've traded memory for speed! Was it worth it? well that's depends what you can spare... This often the choice you're faced with when programming in 8 bits!

There's not much to look at here, the only thing to note is that LDI, or LDIR set the PO flag to true when BC=0... Note, BC must be a multiple of 16, or this program will miss the 'return' and overwrite all the memory!

There may be times when we need to read or write data super quickly... and there's a clever trick for this... as mentioned before, the Stack pointer offers the fastest reading and writing the Z80 can offer.

As we know the Stack pointer is designed for PUSH and POP, and for CALL's, but if we don't need to do any of these things, we can temporarily alter the stack pointer, and use it to bulk read, or bulk write a block of data super quick!... of course, Interrupts are a call to &0038 - so we'll have to disable interrupts to be safe! (Depending on what you're doing, you MAY be able to allow interrupts - eg if you're only writing... a few bytes would be temporarily corrupted by the interrupt handler's calls and pushes - though there are complex tricks to avoid this)

Add "JP ClearScreen" to your jumpblock
Add  the code to the right to the bottom of your program There are 32 PUSH DE's in total... so get Copy-Pasting!!

We've done some tricky stuff, so lets take a look!

ChibiAkumas uses Stack in this way to flood fill the background gradient super quick... it fills the screen with a parallax gradient faster than the firmware CLS command! It also uses POP to quickly read sprite data for transparent sprites. In fact when a game does things super fast, it's likely PUSH or POP is being misused somewhere! It's tricky though, so don't worry about it at first, get your game working with the normal stuff,then if you want you can add stack misuse later to up the frame rate!

Congratulations! You've reached the end of this series of lessons... We've covered all the Z80 commands you're likely to ever need, and learned lots of great stuff! But stick around! We've moving on to bigger and better things with new series' of lessons!

This ends the Basic series.. but the lessons are just beginning!... Tune in next week for more Z80 fun!

Note, as the Accumulator does most mathmatical operations you can just enter ADD 4 ... but ADD A,4 has the same meaning... the shorter form will be used in my guide
Note, On the CPC,Sam Coupe and ZX Spectrum due to the way the Z80 is wired OUT commands do not work as stated... OUT (C) will actually do OUT (B).. making commands like OTIR  that use B as a counter likely to cause hardware problems (It caused random disk writes to me!)... OUT (#) will not work at all... OUT  works normally on he MSX  OUT (C) will do Out (C) and Out (#) works as stated