Andrew Davie

Time is tight. Really tight! The general approach has been to think of the TV frame as the limitating factor for the capabilities of the machine. Whatever you can do in "one frame" (i.e, nominally @60Hz on NTSC or @50Hz on PAL)... that's IT. So in fact you can work out exaclty how much time you have to do stuff. As we've seen in earlier tutorials, the '2600 programmer has to pump data out to the TIA in synch with the TV as it's drawing scanlines. You need to feed the TV scanlines to draw a proper picture. There are 76 cycles per scanline, and 262 scalines per standard TV frame (312 for PAL). So 76 * 262 = 19912 cycles per frame. Multiply that by the NTSC frame rate (actually 59.94Hz) and you get.... 1193525.28 (i.e., there's our 1.19MHz CPU clock speed). It all makes sense.

So, just 262 lines. The visible screen is smaller than that, of course (usually 192 scanlines of actual graphics)-- so we only need to pump data to the screen for a smaller number of lines. The rest is black, nothing to see. See http://www.atariage....timing-diagram/ for a good visual diagram of where the time goes. So, during those blank lines, the CPU doesn't have to pump data to the screen. In fact these two major areas of "blackness" (that is, the vertical blank, and the overscan) account for 37 scanlines (*76 = 2812 cycles) and 30 scanlines (*76 = 2280 cycles). Now that's not exactly swimming in available CPU capacity but it's better than nothing. So the general usage of these blank areas has been to whack in "stuff" that takes a fair bit of time to do.

The problem is, you can't whack in too MUCH stuff. Because when those 37 scanlines of time have elapsed, you MUST be writing to the TIA again to make sure the next frame is displaying properly. Same for the 30 lines of overscan. There's no getting around it; you take too much time, and you stuff up the timing, and consequently the TV picture will roll, judder and basically look horrible. The hard and fast rule has been to simply stay within the limitation, or to reduce the number of visible scanlines to give more processing time for doing more complex STUFF. Each scanline of visible data you sacrificed, you got 76 scanlines of available time to do your stuff. A compromise.

Fortunately, we have the timer registers. Thes are single countdown registers that will regularly decrement a value written to them. I only use TIM64T -- this one counts 64 cycle blocks. If I write 10 to it, then I would expect it to reach 0 some 640 cyles later. So, the usage has been to calculate the amount of time before the screen drawing has to (re)commence, divide by 64, and put that value in TIM64T. By reading INTIM and waiting until that reaches 0, you effectively wait the right number of cycles. You can do your (variable time) "stuff" and not really care about how long it takes (as long as it doesn't take TOO long), and after it's finish you enter a tight loop just reading INTIM and waiting for it to go to 0. When it goes to 0, fire off a WSYNC and then begin the TV frame drawing once again.

That's how it's BEEN done, but that's not how I did it in Boulder Dash!

The INTIM register effectively tells you not only if you're out of time, but also exactly how MUCH time you have remaining (in blocks of 64 cycles if you're using TIM64T). So, if you think about it, you can actually make decisions about if you should call a subroutine based on this value. For example, say you had a small routine which you know takes (say) 1000 cycles to run. That's 1000/64 units (= 15.625). So, if INTIM was reading 16 or greater you KNOW you can call that subroutine and not run out of time! This gets rather nice. Given a guaranteed maximum run-time for any subroutine (and you get this by cycle-counting the subroutine very very carefully), you can use this knowledge to determine if/when it's appropriate to call that subroutine. Furthermore, after you HAVE called the subroutine, you can repeat the process -- look at INTIM and determine if there's enough time to run OTHER subroutines.

So the whole concept of '2600 programming basically changes here. Now we have an asynchronous system, where you have a queue of "tasks" that you have to do. These tasks in Boulder Dash are generally creature logic (process a boulder, the amoeba, etc). Each of these tasks are cycle-counted so we know exaclty how long the worst-case is. And each of these tasks is only run if there's available time. If not, then they simply return and in the next chunk of available time, they will be called again.

So, this is how the timeslicing engine works! Every part of the game logic is broken down into as small (quick) units of code as practicable. Rather than have the whole processing for an object in a single huge and costly block of code, where possible these are broken down into even smaller "sub-tasks". And those tasks are effectively placed in a queue which is processed by the task manager. The task manager is a tight loop which pulls a task off the task stack, vectors to the appropriate handler for the task, and repeats. The tasks themselves are responsible for deciding if there's enough time for them to do their own stuff (i.e., fairly object-oriented in that regard). If a task doesn't think there's enough time (again, by simply reading INTIM and comparing with it's own timing equate), it simply returns. If it has enough time to do its stuff, it does so and makes sure that it's no longer on the task queue. Tasks can even add other tasks to the queue, for later processing!

The upshot of all this is that a game doesn't have to be able to handle the very worst case most expensive thing ever in a single frame. The tasks split across multiple frames, if needed. In other words, there's now a separation between game logic (running over multiple frames if requried) and the frame display (running exactly at the TV frame rate). Yes, Virginia, '2600 games can slow down. Now for most situations this isn't ideal -- but in reality it doesn't really matter. Most of the gameplay for the '2600 Boulder Dash just never slows down. But occasionally, very occasionally (say, when an amoeba turns into 200 boulders and they all start falling at the same time) -- well, the system can handle it. Because although it may only have enough processing power to handle (say) 20 boulders in a single frame, that's OK, because the other boulders are effectively stacked and processed the next frame. And the queue may be really big for a few game loops, and the game will lag... probably not very noticeably... but when the queue is empty again, everything is back to running full speed.

So the above is the secret to making much more complex games than have heretofore been produced on the machine. You CAN keep the TV display going full speed (60Hz) while doing processing-intensive game logic. And you CAN do very very very complex game logic taking absolutely heaps of processing time. The trick, as noted, is to separate out the two so they are not synchronous -- and to divide the complex logic into discrete, very quick, sub-components.

Divide and conquer!

It's been a while since I've posted some code, so here's a handy little routine.
The code uses the COLOR/B&W switch for pausing a game. The issue here is that the 2600 and 7800 have different switch-action for that switch. On the 2600 it's a two-position switch so you choose COLOR or you choose B&W and it stays there. On the 7800 it's a momentary switch -- it's only 'pressed' while you're actually pressing it; it doesn't have a state... just pressed or not pressed. So for pause on 7800 you have to press once to pause, and press again to unpause. One other issue, on the 2600 you really don't want the game to pause when it starts up, so the code should detect a change in state, not an absolute position.
The following code handles all of the above, in just a few cycles.
Enjoy.

	;----------------------------------------------------------------------------------------------
	; handle pause button for 2600 and 7800


BW_SWITCH   = 8                 ; SWCHB COLOUR/B&W SWITCH
GAMEMODE_PAUSED = 128           ; gameMode BIT7 SET=paused
GAMEMODE_CONSOLE = 64           ; gameMODE BIT6 SET=2600, CLEAR=7800

				bit gameMode
				bvc .pause7800			  ; 7800 platform

	; 2600 pause logic...

				lda SWCHB
				eor gameMode
				and #BW_SWITCH
				beq .setPauseCol	          ; no different to original state = no pause change
				bne .buttonDown			  ; unconditional

	; 7800 pause logic...

	; When the button is pressed, we check if it is the FIRST time it is pressed.
	; This FIRST time is indicated by the gameMode BW_SWITCH flag being clear.  If it is the first time, we toggle the pause
	; flag (BIT7) AND we toggle the BW_SWITCH flag so continued button-down does nothing.  When the button is
	; released, then we again toggle the BW_SWITCH flag, allowing a FIRST time check once again, when the button
	; is next pressed.

.pause7800

				lda #BW_SWITCH
				bit SWCHB
				beq .pausePress
				ora gameMode                      ; not pressed, so enable first time press
				bne .fixPause			  ; unconditional

.pausePress
				bit gameMode

				beq .setPauseCol2		  ; NOT the first time in pause - so do nothing new

		; Button is down, and we have detected it as a FIRST-TIME button press.

.buttonDown	                eor gameMode                      ; toggle first time flag(7800) or current switch state(2600)
				eor #GAMEMODE_PAUSED              ; toggle pause flag
.fixPause                       sta gameMode


		; Following code a usage-example to set background colour IFF paused. 
                ; This code can be discarded for most users...

.setPauseCol                    lda gameMode                      ; are we paused?
.setPauseCol2                   bpl .exitPause                    ; only show pause colour when actually paused

				ldx Platform                      ; NTSC=0, PAL=1
				lda pscol,x                       ; table with colours for RED for each platform.
				sta BGColour                      ; set main screen background colour variable

.exitPause

gameMode -- one byte variable conatins...
BIT7 current pause state (set = game paused)
BIT6 platform (1 = atari 2600, 0 = atari 7800)
BIT3 internal use for pause state (initialise as shown below)

To detect the platform (2600/7600), do the following on machine startup...

	; Detect 2600/7800 consoles.
        ; Call first-ting on machine init...

				ldy #GAMEMODE_CONSOLE
				ldx $d0
				cpx #$2c
				bne .is2600
				ldx $d1
				cpx #$a9
				bne .is2600
				ldy #0                            ; 7800: bit 6 = 0
.is2600                                                           ; 2600: bit 6 = 1
				sty gameMode                      ; store console type

To use the pause code successfully, you must also initialise gameMode to the current state of the pause switch but DON'T destroy the platform bit (BIT6).
This initialisation works regardless of the machine type...

				lda gameMode
				and #~(BW_SWITCH|GAMEMODE_PAUSED)
				sta gameMode
				lda SWCHB
				and #BW_SWITCH
				ora gameMode                       ; COLOR/B&W  gameMode
				sta gameMode                       ; also, BIT7=0 -- system is NOT paused

Usage... call the pause code once per game loop, and to check if paused or not...

				lda gameMode
				bmi .paused                        ; yes, paused.... pause flag set!

Well. My entire association with the Atari 2600 has been to call it the twenty-six-hundred.
But I found out today at least one person calls it the "two thousand six hundred".
So, mmh. The latter sounds just... wrong. It's the "twenty six hundred"... right?
Cheers
A

Yep, I know DASM is "the standard" and it's used by a "lot" of people.
But I think it's dated, and time to let it die.

Recently I've become aware of CA65 (part of the CC65 package).
It has a one-pass assembler with a separate linker. I like this (particularly the separate linker).

So, I guess, watch this space. I may add a few notes here about using CA65, particularly how it goes with bankswitching formats.

http://www.cc65.org/doc/ca65.html

Cheers
A

I expect there are approximately zero Atari 2600 SECAM users out there.
Nonetheless, Boulder Dash® not only works with PAL and NTSC machines, it is also optimised for good looks on SECAM consoles!
If anyone has a SECAM unit, please let me know. This may be the ultimate in completely pointless programming effort... SECAM compatibility
Anyway, here's a few screen grabs from Stella running the game under SECAM. Given the *incredibly* limited SECAM palette, I'm quite stoked at the outcome.
Even the amoeba is a decent green
Cheers
A