Part 1: Title Screen
Do title screens matter?
I think they do. They are like the bow on the wrapping of a present: Not necessary, but kinda cool none-the-less, and almost expected once you realize it is not there.
If you didn’t grow-up in the golden age of Atari video games, you might not realize that a decent title screen for a game was not always a foregone conclusion.
Many computer games had nice title screens, as did arcade games. Computer games had their pedigree from college campuses and the garages and bedrooms, of hobbyists, where free expression was not only possible but encouraged. Early companies like Sirius, Broderbund and MUSE making games for the computers like Apple 2, TRS-80 and Atari 800 used nice title screens to introduce their games in imaginative ways.
Arcade games had to stand alone in large rooms begging for quarters, so very early it was established that they could benefit from elaborate attract modes and title sequences to get people interested in the games they held inside.
But early video games systems with their comparatively limited storage, memory and processing capabilities eschewed title screens for color-cycling static screens, and let the box and manual do the talking. They needed to get as much bang from very little buck as possible.
But this held true even when conventional wisdom might make you think it was not so. Even Atari VCS games one might think would have elaborate title screens given their relative importance and history for the VCS, really did not.
Games like Superman, Adventure, Asteroids, Space Invaders, Missile Command, Yar’s Revenge, Pac-Man, Defender, Berserk and Vanguard eschewed any type of window dressing so every single bit of ROM onto the screen.
The first exception to this might have been Howard Scott Warshaw’s twin releases of Raiders Of The Lost Ark and E.T. both of which featured elaborate title sequences.
Mattel used a standard Green with white text title screen that was facilitated by the system ROM. Coleco used an attractive branding of their logo with simple text to introduce the game, that usually lead into a game select screen.
While not exciting, they were attractive in a way that made it look like Coleco cared about having a common look and feel. This changed over time. By the time War Games and Rocky were released they had added some animated intros that while not exactly title screens, seemed to understand the concept.
I can’t pinpoint the exact moment title screen became important for VCS games, but it was sometime after the release of Ms. Pac-Man in the spring of 1983 when Atari was struggling to make a profit and losing game player mindshare to the likes of Coleco who brought fresh perspective to home video games with arcade-like graphics matched with unique games that did not feel stale.
For instance, Coleco’ pack-in game was Donkey Kong, then still one of the hottest games in the arcade. By contrast, Atari’s 5200 included Super Breakout that, while a decent game, was almost 6 years old at the time.
While the 5200 used a common intro screen similar to Coelco and Intellivision Many of the actual title screens were taken directly from their Atari 400/800 brethren, and while functional, many were not very impressive or uniform and made the games for the system seem like they were created willy-nilly.
In fact, after reviewing them for this lesson, I was surprised at how slap-shod they look. Individually they are fine, but as the “Super System” from Atari, they look amateurish.
So by late summer 1983, The 5200 was not selling well, the VCS business was crumbling because of poor distribution planning and loss of consumer confidence in the platform, while the Colecovision was killing it.
Atari needed to do something.
The approach to title screens on VCS games became much more elaborate. Maybe this was a directive from inside Atari, or maybe it was a result of many of the games being contracted out to GCC, the inventors of Ms. Pac-Man and the eventual designers of the Atari 7800.
Whatever the reason, VCS arcade translations games like Centipede, Dig Dug, Phoenix, Jungle Hunt, and Moon Patrol each contained elaborate title screens and attract modes that went far beyond the arcade games from 1980-1982.
These games were 8 and 16K carts that used bank-switching to creating their impressive title screens. Even if the games themselves could not match Coleco’s near arcade quality, they title screens might pull some people in. In may ways, these title screens from latter VCS games are like animations from the later Amiga and ST “demo scene”. They push the limits of the system in ways no one ever thought possible. In some cases it was lipstick on a pig, but you can’t deny that some of the title screens (and also many of the games) from the last years of Atari Inc.’s VCS output were pretty impressive.
For the 2600 and the 5200, the epitome of the title screen might be Gremlins, a game released for the Atari 800, 5200 and 2600 near the end of Atari’s inc’s reign in the summer of 1984. Both feature attractive title sequences and colorful, decent action games.
It feels like Atari finally learned their lesson on how to present their games that were translations of from other popular media, but it was too little, too late.
With the 7800, it appears Atari was not going to make the same mistake. When it came to the first batch of games GCC designed for the 7800, it is apparent that good title screens were not an afterthought. Since the 7800 was a very capable machine, it was the first time all the games had some kind of standardized title screen.
In fact the first 11 games, all developed for release in 1984, used a very similar style of title screen.
While not all of the screens and logos matched the arcade counterparts, the effect of was a pleasing, almost uniform style for the first time on an American video game console.
When the 7800 was finally released, the 2nd wave of games like Dark Chambers and Cracked used a wide variety of different title screen styles, as did.
Later 7800 games used even more elaborate title screens that mirrored 3rd party screens for competing platforms, for example, Alien Brigade and Motropsycho.
As a kid, I followed each nuanced change, update and advance to video games like it was a work of great art. I loved Atari, but I could see how they were faltering. Seeing the title screens 7800 AND gameplay gave me hope that Atari was doing it right.
However, since these games would not see the light of day for almost two more years, the NES beat the 7800 to the punch with it its own uniform style.
And this, like many other things we’ve discussed in out video and podcast over the years, is essentially what we call “The Vertical Blank”. It’s “what could have been” . The nice thing is, with Atari 7800 Basic we no longer have to speculate about “what could have been”, we can just try it ourselves. It may not be a time machine that lets us go back and change the course of video game history, but it just might be the next best thing,
I try to create a title screen for my games as soon as possible, because it makes me believe they are “real”.
However, from my own personal track record of releasing 7800 games (one), you might think the title screen would be paramount. In fact, my single “released” games, my Last Stand Halloween demo, is the one game I never made a title screen for.
Note: Atari 8-bit
In the last episode I said the Atari 400/800 could display 5 sprites. While this is technically true, it needs more explanation. The Atari 400/800 could display 4 sprites and 4 missiles and the four missiles could be combined into a 5th sprite. The point though, was that the 7800 Maria chip was completely different kind of architecture.
Part 2: What Game Is This?
So now it;s time to take a step back and think about what kind of game we want to make. Don’t worry, we will get some coding done in this lesson too, but just for a bit, let’s think on what exactly we are doing here.
To get inspired, first I’m going to create a “banner” graphic (one that is larger in height that the zoneheight), In this case 96×32.
And we are going to do it in 12 color. This is graphic designed for Atari 7800 graphic mode 160B
Here goes! (watch the video to see the title being drawn)
There is a show on The History Channel named The Secret Of Skinwalker Ranch. If you have not seen it, it’s about a real ranch that is supposedly some kind of portal or interdimensional gateway. On the show they are always shooting rockets into the air with various sensors, trying to simultaneously get UAPs to appear and to figure out where they might be coming from.
They use cows as “biosensors” because there have been some supposed animal mutilations in the area, they fly drones, and the owner of the ranch uses a sleek, black helicopter, flown by his brother, to help with the experiments. It’s simultaneously fascinating and preposterous.
But for the sake of this game we will pretend like it’s all true and there are many ranches like Skinwalker with interdimensional portals above them, and this game takes place on one of them, but not necessarily the one from the show.
The UAP you are flying is sort of interdimensional Uber transport. When a level starts, you arrive above the ranch in your UAP. The portal you came through closes, and the next portal will not open until you collect enough “orbs” to energize the next one. With enough “orbs” collected, the next portal opens and you can slip through to whatever dimension you need to go.
But while you are on the screen collecting orbs over the ranch, the “scientists” on the ground will be shooting rockets at you. They will send drones, and if you miss too many “orbs” the black helicopter will show-up.
If you collide with any of the objects, your “visibility” factor will go up. The worst thing for a UAP is to be so visible that someone can take a full photo of you. If you hit 3 objects on any level, a photo is taken, and the game is over.
However, you have a chance. Cows happen to be your saving grace. If a cow appears on the ground, collect it and your visibility will go down.
You also have your own 1.6ghz wave-beam that can shoot the enemies out of the sky, but you can only have one beam on the screen at a time, so use it wisely. And that’s it. Each level will get harder and harder, but that’s the basic game.
We will use the full screen for the game,and let the player UAP move anywhere.
They game will be styled a bit like Robotron, and we will use it as a way to see just how many animated spirited we can get on the screen
Now let’s load-in that title screen image we just made, and get moving!
Part 3: More Memory And The Banner
So let’s start by changing a bit of the boilerplate we used in the previous lessons. Remember when I said we may only ever need 32K? Well, that was just to not confuse things. But now that you have some idea how things work, and you have seen a little a bit of how the 7800 uses memory, let’s expand the cartridge format a bit.
set romsize 128kRAMset dlmemory $4000 $7FFF
The first line sets the cartridge to 128K ROM, which will give us eight 16k banks to work with. We will not talk about bank-switching yet, we are just getting ready for it. The RAM of “128kRAM” means the cartridge we will be using has an extra 16K RAM available and addressable at all times.
THIS IS HUGE. The Atari 7800 by default has 4K of RAM, which is okay, but not great if we need to track and display lots of objects on the screen with lots of properties.
“Set dlmemory $4000 $7FFF” takes extra RAM and uses it to expand the DisplayList of the 7800, which in-turn will allow more objects per zone.
So now Let’s display our title screen. To do this we will use a new function named “incbanner”. incbanner tell Atari 7800 Basic that the graphic we are loading extends higher than the current zoneheight of 16.
incbanner images/title.png 160B
Notice the 160B that comes after the filename. That tells Atari 7800 Basic that we want to load a 12-color bitmap.
In our _titleLoop function we will now display the title graphic using the plot banner command.
plotbanner title 0 32 50
Plotbanner is similar to plotsprite. The first parameter is the name of the graphic to display, followed by the palette, and x and y location. Notice only set a single palette, even though the sprite use the 12 colors. This is because 160B sprites uses the first four or 2nd four pallettes. For a 12-color graphic specify palette 0 for the first 12 colors, or palette 4 for the 2nd 12 colors
Save the file, then let’s test it out.
First but let’s look at the output window.
Notice at the top, it loaded “title” as two sprites, title00 and title01. That’s what loadbanner does. Also, before we loaded the title, we has 2992 bytes left in bank#1, now we only have 1456, so the title with 12 visible colors is about 1.5K in size! 160B sprites can be large, so it’s good idea to limit them or manage them into multiple ROM banks.
It now says we can have 136 objects per zone. This is because of extra memory we added. Now, practically, there will be no way to get 136 objects per zone in an action game, and we may find out we need some of that extra RAM for our active game data, but for now we will just keep it like this.
What you will see is something like this:
The colors are all wrong and we still have that color cycling background.
The first thing we will fix is the colors.
Recall, we set the color palette for text and sprites above all of our code in our previous examples. But we need to be more flexible than that. The color palettes on the 7800 are redefinable at run-time, and we want to make use of that feature.
So first, let’s move our original color palettes to _initGame.
_initGame lives = 3 score0 = 0 BACKGRND=$00 playerX = 70 playerY = 90 playerAnimFrame = 0 playerAnimWait = 0 rand = randomSeed gosub _randomOrb orbAnimFrame = 0 orbAnimWait = 0 rem pallette 0 text P0C1=$0F P0C2=$0C P0C3=$0A rem pallette 1 player P1C1 = $0D P1C2 = $08 P1C3 = $33 rem orb colors P2C1 = $92 P2C2 = $94 P2C3 = $99
Next, we will create a new label named _setTitleColors. This label will allow ud to set the colors once and then drop into _titleLoop. We donlt need this function now, but when we have a function to restart the game, we will want reset the colors so the title graphics displays correctly
Then, after the _setTitleColors label, we will load all the color constants that Atari 7800 Basic created for the titlegraphic.
_setTitleColors P0C1 = title_color1 P0C2 = title_color2 P0C3 = title_color3 P1C1 = title_color4 P1C2 = title_color5 P1C3 = title_color6 P2C1 = title_color7 P2C2 = title_color8 P2C3 = title_color9 P3C1 = title_color10 P3C2 = title_color11 P3C3 = title_color12
Recall that this is a new feature I just discovered by reading the Atari 7800 Basic Guide (I think from lesson #1). Previously in my games, I had to set all of these colors manually. In some cases, it took DAYS to swap all the colors of a multi-sprite, 12-color graphic, just to get them right.
However, these new constants are created when the graphic is loaded, in the format of [filename]_color[x}. So now we can set the first 4 palettes on the 7800 with these constants! It makes everything easy.
Now that we have set the colors, let’s run the program again and see what happens.
Ah look our colors are right.
Part 4: Cleaning Up
So now that we have a proper title screen graphic, and we have idea for what we are making, let’s clean this up. We no longer need to cycle the background color, as. Let’s be honest, it’s pretty annoying. We will also add a subtitle “Quantum Lay Over”, because in the game we are at sort of interdimensional rest-stop, waiting to get out.
We will also add the and then the text “Fire To Start” as an instruction to the player .
_titleLoop clearscreen plotbanner title 0 32 50 plotchars 'quantum lay over' 3 47 6 plotchars 'fire to start' 2 54 10 if joy0fire0 || joy0fire1 then goto _initGame randomSeed = randomSeed + 1 if randomSeed > 254 then randomSeed = 1 drawscreen goto _titleLoop
For the new text we set the palette colors to 3 and 2, which will use the colors in those palettes to display the text. I’ve rearranged the locations a bit to optimize the look of the title graphic and the text.
When we run it, we see this, which I think is not too shabby.
And there we have it, a decent little title screen for our 7800 game.
So that was shorter lesson this time, but we learned some value things about sprites, colors and memory.
Get the code from GitHub here:
makeathing/Atari7800/Atari7800Basic/Tutorial at main · intotheverticalblank/makeathing · GitHub