Animation

Animation





Get things moving with Duncan Overton's


graphics program.





It all began whilst watching some software company's logo


reveal itself, stripe by stripe, on the TV screen. Loading


a screen string from tape is a slow operation, quite magi-


cal and entertaining when first seen, but slow. It becomes


plain boring when you have to watch that logo every time


you want to give the Alien Menace a good sorting out.


Having loaded a screen string you wish to use, just one


misplaced finger and it's lost, needing retrieval from


tape (where is that Microdrive?). So why not invent a


routine to shunt screenfuls into memory and recall them


when needed?


This is easy enough to do using PEEK and POKE, PEEKing


bytes from address 16384 onwards and POKEing them into


higher memory. As there are 6912 screen bytes, the process


is even slower than loading from tape, and Machine Code


becomes necessary. For the novice who is only used to


BASIC, the structure of Code operations seems very obscure.


With a little persistence, however, Code seems to be like


any other area of programming, easier to learn once you


have a specific need to be met. Once the sequence of oper-


ations is properly visualised, trial and error will get you


there in the end. One point soon learnt is that you must


tape each program before you RUN it - in Code, crashes are


invariably fatal!


There are over 40,000 bytes available on the 48K for


programs and storage space, so up to 5 screenfuls could be


stored. Program 1 [found below] is a Code routine to move


6912 bytes from one starting adderss to another. In order


that this routine can be used and modified easily, it may


be entered from a DATA statement in BASIC. For this, it


needs to be written in decimal form. Bytes 2,3 and 5,6 are


the addresses, which are written in a manner illogical to


common mortals. Byte 3 is the number of 256s in the ad-


dress, and byte 2 is the remainder from this division. So


addess 33000 is 33000/256 which equals 128, remainder 232,


and is entered as 232, 128, which the little Z80 chip seems


to understand perfectly.


Program 2 [found on the accompanying TZX as "animcode"]


is a BASIC routine to enter and run the Code program using


specified addresses. The Code is placed at the top end of


memory, 64000 to 64020, and is preserved from NEW using


line 1000. Screen strings can be stored as low as 25000 in


memory provided only a small BASIC program is stored as


well. The storage addresses increase by 7000 for each new


entry. Enter and RUN the program, using addresses 16384 and


25000, and then set up a screen design. Enter RANDOMIZE USR


64000, and nothing at all will appear to happen. But with


the specified addresses, the screen is now copied into


memory from 25000 to 31912 (PEEK it and see). Clear the


screen and RUN the BASIC program again, entering address


25000 first and 16384 second. RANDOMIZE USR 64000 again and


your screenful will return, considerably more quickly than


using PEEK and POKE. Four further screenfuls can be stored


and retrieved in the same way.


So what has all this to do with animation? Well, if the


code routine is used to recall screenfuls repeatedly in


cycle, then interesting possibilities arise. Program 3 [on


the TZX as "Starspin"] uses the Code routine, at line 100,


to store 4 designs. These 4 designs are created in line 7


to 70, and are each slightly different. Lines 200 onwards


recall these blocks in cycle continuously, and Hey Presto!


you have an animated Spectrum.


[ Note the red streaks, which are a result of drawing the


new screen over the old screen's attributes. This could be


avoided with a careful set-up of the attributes of each


screen, but that would go a bit far for a demonstration


like this. Note also that a clever machine code programmer


knows about the LDIR instruction, as demonstrated in


"StarLDIR" - which is both rather shorter and slightly


faster than the article's original! ]


For those of us used only to BASIC programming it is


awe-inspiring to calculate that, as one revolution of the


figures takes about 7 seconds, and involves 64 'frames',


then some 63000 bytes are being shunted around each


second!


Spinning wheels, wriggly caterpillars, travelling waves


and rotating solids can all be produced in the same way.








Program 1





HEX MNEMONICS FOR HUMANS


11,XX,XX LD DE,address 1 Set 'read from' address


21,XX,XX LD HL,address 2 Set 'load to' address


06,1B LD B,27 Set up a loop of


C5 PUSH BC 6912 repetitions


06,00 LD B,256


1A LD A,(DE) Put contents of add. 1


77 LD (HL),A into add. 2


13 INC DE Move add. 1 & add. 2


23 INC HL on to next address


10,F9 DJNZ,-6 Other end of


C1 POP BC loop


10,F4 DJNZ,-11


C9 RET Return to BASIC








[ Program 1a - LDIR version





HEX MNEMONICS FOR HUMANS


01,00,1B LD BC,6912 Set number of bytes to move


21,XX,XX LD HL,address 1 Set 'read from' address


11,XX,XX LD DE,address 2 Set 'load to' address


ED,B0 LDIR Move BC bytes from HL to DE


C9 RET Return to BASIC ]