Kurt_Woloch

171.

OK, here's another build... unfortunately, it's a bit faulty one. I tried myself at horizontal repositioning, and basically it works... but the results don't look too clean. I also redesigned the falling men... the ones displayed here are a bit higher (11 instead of 8 scanlines) and come in different clothes. In the end, I plan including multiple different possible men... maybe some of them will only appear in later levels. This build is a bit "dirty" in that the top pixels of the men don't always get displayed due to timing constraints, which come from needing more lines for repositioning players. Aside from that, I increased the height of the men to 11 pixels which seems to fit the proportions of the ship. The RMS Titanic had a draught of 10.5 m. If we calculate 6 scanlines to roughly be 1 meter, a man height of 10-11 pixels seems to be about right, and the ship draught would be 63 pixels. This, however, is the part of the ship under the waterline. Abover the waterline, it currently has 68 pixels at the most erected position, which would equal 11.3 meters. Wikipedia, unfortunately, only gives the draught, not the height above the waterline, but seen in proportion it still seems to be about right. I also increased the acceleration of the men which I initially miscalculated. The new one is by about 300% higher than the old one, and is physically correct. This, however, means that a falling men hits the water surface in about one and a half second, which isn't much time to catch it. Therefore, I plan to (at least in the lower levels) have the men appear in their positions a few seconds before they jump off. This time, of course, should decrease with each level, and maybe also during a level. I'm pretty sure that at the rate they're coming out now, they can't reasonably be caught. :-) Anyway, I've started to completely rewrite the kernel because the current kernel only supports one player, and it should support two... maybe it's not necessary to have them in the upper rows of the screen, but in those scanlines where the boat and people sitting in it appear, we definitely need two players to display them. However, I figured that things might get pretty tight here... we have to do 5 writes in a line, and they have to be all finished by pixel 17, which is when the ship starts drawing. The player data even should be finished earlier because both players theoretically could appear at the leftmost row. However, I think I found a way around this problem by moving some writes to the previous line. So, the new kernal probably will look something like this: LDA (MenGraphicsPointer0),X ;5 cycles STA GRP0 LDA (MenColorsPointer0),X STA WSYNC STA COLUP0 LDA (MenGraphicsPointer1),X STA GRP1 LDA (MenColorsPointer1),X STA COLUP1 LDA ForeColor,Y STA COLUPF This would be the code of one line, after which comes some deciding and branching. The trick is to activate VDEL of player 0 so that its player graphics actually doesn't change until GRP1 gets rewritten. The sequence above uses the first 28 cycles of a line and 12 more somewhere before that... which means it ends at 84 - 68 = 16 pixels into the line, which is exactly what we need. We only need to take care that none of the writes after the WSYNC occurs later than it does in this sequence. We need 44 cycles for the sequence stated above (including the WSYNC), so that leaves 32 cycles per line to do some deciding and checking. I'll see what I can do with that... I plan to do a rather complex kernel, where basically several different versions exist depending on which of the players are displayed and what else happens. This is because I don't have much time to decide in each scanline whether to display player 0 and 1 or not. We'll see if this is practical or not. Theoretically I could also do something like this... LDA DisplayPlayer0 BNE NoDisplay0_1 LDA (ManGraphicsPointer0),X NoDisplay0_1: STA GRP0 LDA DisplayPlayer1 BNE NoDisplay1_1 LDA (MenGraphicsPointer1),X NoDisplay1_1: STA WSYNC STA GRP1 LDA (MenColorsPointer0),X STA COLUP0 LDA (MenColorsPointer1),X STA COLUP1 LDA ForeColor,Y STA COLUPF However, this needs 10 additional cycles, so we only would have 22 left for deciding and checking. We'll see how it turns out... the next version I plan will probably display the currently 2 possible men by using both players and do the repositioning off-screen, providing no provision for on-screen repositioning, which will get re-inserted later, since it's rather tricky... we have to reposition player 1 while still displaying player 0 and vice-versa. But it will bring me closer to what I actually want to achieve... I only haven't got the time to complete it today. ship7924.bin

I don't remember the crash as a "crash" per se, but rather as a shift from console games to computer games. Here in Austria, it probably was a bit different and came a bit later. My "Atari time" was basically the year 1984. I got my Atari 2600 in late January 1984 when my mother had surgery at the hospital. What I did notice was that throughout the year, more and more games became deeply discounted. Normally, games for the Atari were ATS 990 to ATS 1398 each... I don't remember the exact dollar value at that time, but I think it was about 16 ATS for 1 dollar, so that would have been $62 to $87 per game (yes, they were that expensive here). The discounted games usually went for ATS 199 or less. The first discounted games I got at the end of January at some small shopping centre called Massa where the center owner sold them personally in his office. Those were "Hot Shot" games... we picked up Astro Attack, Missile War, Black Hole, Galactic and Sea Monster. Those came in a plastic bag with a "manual" sheet and weren't of the best quality... Then from February or March 1984 on, some stores also started carrying deeply discounted games, often by name brands... we picked up Keystone Kapers at that price, then Cakewalk and Atlantis. The games by Atari seemed to resist that price crash best... though we also picked up their old "Asteroids" at that low price. I still have that box in front of me with it's particularly funny price tag that says "PHOENIX" which is crossed out, replaced by a hand-written "Asteroids". There are 3 prices on that tag... 1.298,-, 998,- and 198,-, which is the price we paid. Near the end of 1984, the Coleco games for the 2600 also got down in price, so we got a "Smurf" for that discount price too. The last Atari 2600 cart we bought during that time was "Pooyan", which never was more than the discount price. Also I remember that in 1984, the TI-99, which we had before the Atari 2600, got discontinued. Actually, we bought the Atari because the TI-99 never got those good arcade ports like Pole Position and Missile Command, but that changed in 1984 when Atarisoft brought out some games for the TI, so we also still bought TI games in that year (which usually were much better than their Atari 2600 counterparts). However, in 1984 the TI-99 was discontinued, and many of its owners migrated to other computers. Finally, I got caught by the C-64 whose killer apps for me were "Gyruss", "Ghostbusters" and "Summer Games", neither of which were available for the Atari 2600 (at least not here). I also noticed that the games for it were cheaper than for the Atari 2600... for instance, they sold "River Raid" for the 2600 at ATS 990,-, but on tape for the C-64 it was half the price. After that I learned that at my school, C-64 owners were heavily swapping software, which was one of the main points for me to get a C-64 with a 1541 floppy drive for Christmas 1984... and it paid off. Basically, I saw the "crash" as a change of how the market in computer games worked... Before the crash games were mainly done by the console or computer manufacturer and sold on cartridges... after the crash they were mainly done by "third party" software houses and sold on tapes and disks. Also, I regard most home computer and console systems and games as either "pre-crash" or "post-crash". The TI-99, ZX-81, VIC-20, Apple II, Sharp's MZ's and the Laser computer line were mainly pre-crash systems, as were the Atari 2600, Philips G7000 and G7400, Colecovision and Intellivision systems. The C-64, Spectrum, Amstrad CPC, MSX and all the 16-bitters are "post-crash" systems, though the C-64 and the Spectrum were around a bit before the crash too, but didn't get off the ground until the crash. The only survivors of the crash were Atari and Commodore, but both of them changed heavily... the Atari 2600 became a discount console, the Atari 400 and 800 were replaced by the XL line (and later by the ST's and TT's), and the VIC-20 made way for the +4 and then the Amiga... and Commodore stopped selling cartridge games for their computers, as Atari did from the ST on. Also, only few software companies survived the crash... most notably Activision, but other than that, each new computer brought with it new software labels specialising in it, such as Aegis for the Amiga. I think this change also had to do with both Atari and Commodore changing management during that time.

Yes, I thought of that too this morning... actually, the play mechanics of "Parachute" and "Lifeboat" are rather similar... but there still are differences: - In "Lifeboat", you can move your boat into one of 6 positions (2 for letting people get out, 4 for catching them), while in Parachute, there are only 3 - In "Lifeboat", the men don't fall for that long (I think only 4 or 5 positions), while the parachuters have a longer trail - In "Lifeboat" you have to let the people get out of your boat while in "Parachute" they just disappear if you catch them - In "Parachute", in Game B parachuters in the rightmost line can get caught in a tree and free themselves after some swinging (which is dangerous because when they get free they're just one or two positions above your boat). Yes... the Lemmings analogy isn't bad... especially since they all jump in one straight line one after each other. To GET AWAY from Celine Dion? That's a pretty new point... As for the reflections of the ship in the water, I'm afraid they will have to be removed entirely. If you look at my fake screenshot, they're not to be seen there because that would take an additional color register which I don't have - the playfield graphics on those scanlines will get used for the cliffs on the sides, which are brown, and the two players and their colors get used for displaying the men in the boat and the boat itself (with one player left for a man falling into the water due to missing the boat). So, sorry, but the reflections will probably have to be sacrificed...

Since in the last days, I made several attempts of telling everybody what kind of games could be possible in a 2600 kernel and what wouldn't be able to work (see the Bombjack, Bomberman and Smurf's Rescue in Gargamel's Castle threads), I somehow "wanted to know better", so I decided to pick up an old project I started back in 1998, the "Jim's heart will go on demo". This was discussed in length on the Stella mailing list (back then, I did have e-mail access at my working place, but no Internet browser), but I want to recapture the main points for everyone who wasn't around back then... 1. The game was leaning towards the Nintendo Game & Watch game "Lifeboat" 2. The basic game mechanics are as follows: A ship is sinking (the Titanic maybe?). People are jumping off board, hoping to land in a lifeboat which you direct. You have to place your lifeboat in order to catch the falling people. Since the boat only holds 4 people, you have to row to the left or right cliff in order to release the people in your boat. If you don't manage to catch people, they land in the water, and you get a second chance of picking them up from there. But hurry up! A shark circles the waters around your boat, and you have to get to the people swimming in the water before the shark gets to them and eats them. Now, back in 1998, I managed to get something working... you saw a screen with the sinking ship, and some music is playing which you probably know as it was a huge hit back in 1998. However, you couldn't do anything besides watching the ship sink and listening to the music. And here's the improved version. I've taken the next step and included some men jumping ship. However, the game doesn't offer too much improvement over the previous version. It's especially lacking in the following areas: 1. All men look the same, and they aren't animated. 2. All men come down at the same vertical position which shouldn't stay that way. But the repositioning routine isn't yet implemented... 3. The men simply jump into the water and disappear. There is no shark and no lifeboat, which means you still can't do anything. 4. There's a graphical glitch in the display of the men, in that the uppermost line of the men doesn't get displayed in 25% of the cases (that is, if the display starts on a certain one out of every 4 scanlines). To explain what I did... first I changed the display of the ship by stretching it out across four scanlines... 1. Display PF1 (PF0 doesn't get written to in that part) 2. Display PF2 3. Change foreground color 4. would be a management / repositioning line. Each of the numbers above now happens on one scanline, along with displaying player data. Currently, it's only using player 0. As you can see, I tried to do realistic physics, that is, the falling men speed up as they fall. Theoretically, the program would be able to display a fair number of men underneath each other, though in this version no more than two appear at any time. This is limited by the fact that due to my programming constraints, there have to be at least 4 empty scanlines between one copy of player 0 and the next one. This could be changed, however... I've set the timing of the spawning men to about the fastest rate possible under those constraints. A bit faster, and a newly appearing man wouldn't leave enough free scanlines until the one below him gets displayed. I'm still wondering if I should support the display of 2 men on one scanline or not. Technically, it should be possible in a 1-line kernal the way I've laid out the remaining writes now. The tricky part would be determining which player to use for the next man to display, and which one needs repositioning. Anyway... I've attached the current version for you to enjoy. In this message, you'll find a BIN, a screenshot of the current version and a mockup picture I've drawn on paper back in 1998 which should show how the finished game is supposed to look like. Would you also be interested in the source code? Anway... This is the binary. It's 4K at the moment, though only about 640 bytes get used up by data, and another 650 bytes by program code, so that's 1290 bytes, or 31,5% of the space available in a 4K cart. ship7919.bin This is a screenshot of the current version running... And this is the hand-drawn mockup picture. I know I "rounded" the score display at the top, and the man jumping down upside-down in that picture obviously is too large... it's higher than a row of windows, which means the men would have to duck to fit into their cabins! I think a size of 12 scanlines would be about right. Currently, the men are 8 scanlines high, but that could be expanded... however, maybe this would make using a 2nd player necessary... Other than that, I think the mockup picture shows a bit of what I have in mind... the cliffs would be displayed at the bottom of the ship using PF0... the men in the boat would be 2 players which both get repeated... the boat itself would be a quadruple-width player (to leave the other player for a falling man), and at the bottom you see the shark and a man chased by it... the shark would be a double-wide player, and the other player would depict the man swimming from the shark. What's especially important for me in that game is: 1. The display should be colorful 2. All players and sprites should use a 1-line kernel (however, the background graphics don't have to) 3. The movement of the sprites should be smooth (unlike games like DigDug, where the objects jump up and down in steps of several pixels, and games like Spacechase where they jump left and right in the same manner) 4. The difficulty should ramp up rather smoothly, not doing harsh jumps from level to level. I don't know what I'll include next... maybe I'll try to include the cliffs, or get it on in the order of things appearing on screen. We'll see...

16475. Correction for scoring chart: Destroy a homing missile - 100 points.

I don't see it that harsh. The game logic surely could be lifted from the 2600 version, but only to the extent that it's still determining which object should be on screen and where it should move next. But everything else probably would have to be vastly different since the architecture, though somewhat similar, is quite different. The question here is if you want to have a 1:1 conversion or if you want to update the graphics. For the background graphics, it probably wouldn't even be avoidable to update them since the 5200 simply has got a higher resolution than just 40 pixels across in 2 colors. For the foreground objects, well, you could keep the graphics as they are, but that would mean you're using only half of the available players, that is, the smurf and enemies could probably look much prettier on the 5200 than it does on the 2600. Anyway, the "kernel" part would have to be rewritten completely, as far as I see it. For the 7800, well, it depends on what you want to achieve. Without graphics updates, a conversion would make no sense since the 7800 already plays 2600 games. Other than that, the same applies as for the 5200, except for the fact that it would be even harder to keep the graphics as they are... as far as I know, the 7800 doesn't support color-striped, but essentially 1-color objects. On the other hand, you could keep the sound routines the same for the 7800.

Well... for 6 hours work it's pretty good. And it's a start. I just extensibly played the arcade version (or one of them) and then the 1986 MSX version to have something to compare it to. I think the game could be improved in the following order and ways: 1. Scoring... as far as I know, you get 100 points for every enemy killed. If you kill multiple enemies with one explosion, each subsequent enemy is worth 100 points more. 2. Blockers... these are the walls between the playfield grid which can be taken down. I know this is difficult, because it introduces an asymmetric playfield... and you need some way to know which walls are still there and which have been taken down 3. Make the explosions bigger 4. Improve the enemy AI so that they won't go over blockers and bombs (Oh, and you yourself also can't go over them) I know this is rather much to ask for after what you've done already... I'm a programmer myself and know how hard it is to code... especially in assembler. Just for the record, I spent 33 hours so far on programming a version of Tetrinet for the Magnavox Odyssey^3 (or Philips G7400), and what I've produced so far roughly consists of 1 K of code and 1 K of data. So each point I mentioned may well mean 4 more hours of work...

OK, here's mine... 4060 (played with Z26 and keyboard control).

Retrofan is really good at this, isn't he... Well, with a few differences it might be doable... here's where I smell trouble: 1. Top of the screen: The 6-char score is certainly doable, however the display of remaining lives isn't, since the 6-char display already uses both players. The lives display would have to be changed to blocks (as it's done in Centipede, for instance) or use different scanlines (as done in Ms. Pac-Man). 2. Playfield: In the places where there's blocks that can be removed by explosions, the playfield is asymmetrical, that is, taking up a lot of CPU time per line. I doubt if this is possible with a full-width playfield while at the same time displaying a color-striped player and enemies in a single-line kernal. Logically, the playfield would be divided into blocks of scanlines which essentially look the same or are repeating over 2-4 scanlines (4 only for the explosions). Between those blocks of asymmetric playfield, there always would have to be some scanlines showing a symmetric one (e.g. only the steady blocks without the removable ones). A good candidate for those would be where the front side of the blocks gets shown. This, however, requires the removable blocks to have no front side (while there is one in the screenshot), otherwise the playfield wouldn't be symmetrical in those lines. Those lines would get used for things like repositioning the enemy / bomb player, changing the foreground color and setting up some variables for the next block of scanlines. I wonder if 2 scanlines are enough for this, though, since you still have to display the color-striped player sprite (if the other one gets repositioned) or both the player and enemy sprite (if no repositioning takes place). Oh, and the enemy sprites also are a bit too wide (10 instead of 8 pixels).

You have to do a "high jump" in order to reach it... by holding the joystick up as you jump.

OK, I redesigned layout number 14 so that it's not that offending anymore, at the same time as clearing up some of the other levels. And yes, I did delete the old version of the attachment, even on my harddisk, so there should be no evidence of the original level 14 layout.

OK, so this is my first entry for the level contest. I drew these by hand, but then I thought if I've already got them ready, I might as well scan them and post them here. I've taken a look at the arcade screenshots and tried to create levels that resemble them in some way while keeping true to the limitations of your kernal. The bomb count on each level has been reduced from 24 to 18 since there are also fewer bomb positions than in the arcade (40 instead of 81). The platforms and walls are represented by lines, and the bombs are represented by circles.

Thanks for the new binary! Looks good so far... but I think you're overdoing it a bit with 40 bombs on one screen... I guess those are all the positions where bombs are possible? Yes, that's true, though I could imagine some simple ways to soup it up: 1. Let the 2 colors of the players "glow", that is, cycle between different colors (but maybe in a different order than the standard one of the Atari pallette... we've seen that too often now in other games. 2. Put some playfield graphics in the background. My favorite would be a blue vertical bar on a reflected playfield that simply changes its position with each frame so that it runs from the middle outwards, when it has reached the edge of the screen, it would start again in the middle. The playfield registers and colors would be set before displaying the title picture, so you don't need any additional writes in the 6-char routine. Another alternative to that would be to "mask off" the title picture on the sides using the playfield graphics so that the title picture itself has two different colors than the border around it. Those two effects also could be combined by having the masked border and still a vertical bar which changes its position inside of the title picture. Or... you keep the black border around the picture, but have an additional 4-pixel blue (or glowing) border around it which gets displayed by PF graphics. Another idea would be to do the "spiral" above and below the box with the title picture. To do this, you would need two different spiral patterns... one would be exactly reflected, and the other gives a spiral if the bits are reversed in the right half from what they are in the left half. Together with reversing the colors, this would give a convincing "spiral" animation. If you use reflected mode (with correctly timed write for the inner PF byte), you only need to code 3 bytes per pattern line, because the right half is exactly the same as the left one, only in one of the patterns the bits are all reversed. I've attached a modification of the screenshot you posed in order to show you some of my ideas. In it, you can see the blue border around the orange and red title box, and the spiral above and below it. Sorry if the colors aren't accuratly out of the 2600's pallette... Yes, I noticed that... though the flying logic could be improved too. Remember, you can "flap" in the arcade version which causes the falling speed to be zeroed on each press of the button. Oh, and when you run off the side of a platform, the falling speed also should start at zero (seems not to be the case now). And when pushing the joystick down, jumping isn't possible... in the arcade that results in an even smaller jump. Looks good and recognizeable so far. Bomb Jack himself somehow doesn't look that good, though, but at the moment I don't know how you could make him look better. Maybe you could color-stripe the main character? Would there be time enough in your 2-line kernal for that?

Hmmm... Title screen? Something like this?

Hey Supercat, the enemies are basically one bird flying around all over the screen and some spacemen walking around on the platforms. Later on the spacemen fall to the ground and transform into flying enemies as well. This is the difficult aspect of the whole affair, i think. You would have a couple of freely moving objects on the screen. hmm... Well, not necessarily... the logic of the enemies could be changed so they never are more than one in a scanline... similar to how Atari did it in Joust and Phoenix. The enemies spawn one after each other, with the bird usually being the first. There are usually two spawning positions per level, if you are on the left half of the screen, the enemies spawn on the right position, and if you are on the right half, they spawn on the left one. After spawning, they walk left and right on their platform for some time, then fall down to the next platform where the start walking again, unless they hit the ground, in which case they transform to flying enemies. Now the screen is divided in "zones". One zone usually is one row of bombs and platforms, and the logic could be changed in a way that the walking men aren't allowed to fall down unless the zone below them has no enemy on it, and a new one is only allowed to spawn if it would be alone in the zone in which to spawn. Similarly, the heatseeking flying enemies as well as the bird would only be allowed to leave their zone if the target zone is free. Now we could get a problem if the bird blocks a zone, and another enemy is in the zone above the bird. Therefore the logic could be changed so that two objects (the two players) are allowed in each zone, one of them being the player. Now, of course, you can't limit the player's movement, so if the player decides to enter a zone where there are already two enemies, those two begin to flicker at 30 Hz, but one of them would try to use the next opportunity to leave that zone. Does that sound feasible? Another idea would be to limit the color changes in the background in order to reduce the number of writes and allow a one-line kernal. What if the foreground only changes between one shade of red (for the bombs) and one platform color (different per level), and background color changes would only occur once per "zone"? Another idea would be to have "double enemies" in some places, that is, two enemies that are actually two copies of the same player, which spawn and fall together (the platform layout of that level would have to allow for that, however).

Well... not really. I only wanted to see what the kernel has to be able to do. In principle, the kernal should repeat as many times as there are possible rows of bombs. Inside that loop, the lines for platforms and the lines for bombs would repeat as well. The levels could be designed to take this into account. The question is what you mean by "customizing" each level. Basically, each level does have different data, so there is already some difference between levels. What you probably mean is if inside the visible area, different branches would be taken depending on the level. If that's the question, then yes, I would suggest that... but only for a small piece of code which either branches to the repositioning code or continues to draw the screen, depending on what's feasible in the given row. Well, looking at Retrofans' mockup, the sprites seem to be 12 scanlines high. And if you think a one-line-kernal isn't feasible, maybe you should think again. I looked at the source code for Coleco's 2600 Donkey Kong (which you can find somewhere on the net), and Mr. Kitchen managed to display an asymmetric playfield (at least in the 1st screen) along with 2 players, one of which (Mario) is even color-striped. But he narrowed down the playfield to 24 of the 40 available columns so that he has only 4 playfield writes per scanline, in addition to the 3 writes for the players. By the way, he repositions the enemy sprite (Mario doesn't get repositioned) in the scanlines where next to nothing is being drawn (in the middle of the ladders). And his kernal differs considerably for the two screens. So, in total he does 7 writes per scanline, which is pretty good in my opinion (probably the maximum you can do). OK, so you are doing 5 PF writes, 2 player graphics writes and 2 color writes per line (FG/BG of the screen), which would be 9 writes, which probably isn't feasible for a 1-line kernel. I see... so you're probably already storing the PF patterns for the running line in zeropage RAM in order to be able to access them faster. This was actually what I was going to suggest, but the catch is that you have to setup those RAM locations somewhere. OK, I see... so the levels can be redesigned so they fit the programming that's possible on the 2600 better.

I thought about this one a little more... basically, to my knowledge, you can't reposition a sprite on the same scanline as you display an asymmetric playfield because of time constraints. That's why games like Dig Dug and Super Cobra always have "holes" in their playfields to make room for lines where they can do this. At first glance your playfield looks all asymmetric, with the walls and platforms as well as the bombs. But then I looked at the arcade original. And looking at that, it doesn't seem to be undoable to me anymore, because there are not so many vertical walls in one scanline that this would be a problem. I've examined all the screens the arcade original has, and there are only 16 distinct platform layouts. Out of them, 6 are asymmetric, and 10 are totally symmetric. 8 of the 16 layouts have vertical walls (the other ones don't), and out of those 8, only 2 have assymetric vertical walls. Out of those 2, one screen only has one wall at most per line which is displaced from the center. I thought this could be handled by using the ball for the vertical line, at least in the places where you can't draw an asymmetric playfield directly because you reposition sprites. The other one has sort of a "spiral", but there would still be scanlines in that screen where only one wall is shown, and those are not too far apart, so on those there still would be room for repositioning sprites. Other than that, in the arcade version, the bombs are laid out on a 9 x 9 grid, though the total number of bombs in each screen is 24. The maximum number of enemies to appear on screen is 9, in addition there are two bonus items and your player sprite, so 11 sprites in total. As far as I can see, you have laid out the bombs in a 4 x 9 or 4 x 10 grid, so there is only half the number of rows. Could you try to bring that closer to the mockup screen? As far as I can see, on the mockup screen by Retrofan, the bombs are 8 scanlines high, and the platforms are 8 scanlines high too. But that's a bit out of proportion, in my opinion, since on the arcade version, you have bombs that are 16 scanlines high and platforms with 8. I think if the bombs are 8 scanlines high on the VCS, it would be OK to show platforms that are 4 scanlines high, so that the 2 scanlines between the platforms and the bombs on each side could be used for sprite repositioning and playfield setup. How many scanlines do you need to set up the display of a row of bombs or a row of platforms?

Speaking of the Channel F... I've learned that there also was a home computer in the late 70's based on the F8 CPU, called the VideoBrain. It's described on AtariProtos.com. Does anyone know how to program that thing? From what I get from the screenshots, it seems to be a character-based system showing 10 lines x 18 columns, where each character can have one of 16 foreground colors, but the whole screen has the same background color. The characters probably have a matrix of 8x16 pixels or something like that, and at least 16 of them are redefinable. There is one program shown where you can draw on the screen, but the actual drawable resolution here seems to be 32x32 because the image is mirrored horizontally as well as vertically. The whole system only has 1K of RAM, which is less than the Channel F has! But there's no info on how exactly the graphics work and how to program it...

Well... yes, I'd be willing to share the converter program, but only the EXE file, not the source code to it. I made that mistake once... the result is now available as Karaoke Builder Studio, which I don't earn royalties from. And the converter program is in fact a slightly altered version of a program which converts to the CD+G standard instead. By the way, I've also made other variants for the program, converting for the Atari 2600 (2 colors out of 128 per scanline with a vertical resolution of 40), assuming it's possible to rewrite both colors and all playfield bytes in one scanline), the Bally Professional Arcade (4 colors out of 256 per double-scanline with a vertical resolution of 160, assuming it's possible to rewrite all four colors every other scanline), the Thomson EF-9345 graphics chip as used in the VG-8000 computer (basically, 8 colors at a resolution of 200x125, where each 4x5 block can have any 4 colors out of the 8 possible) and the TMS-9918 (video chip of the TI-99, Colecovision, MSX-1 and SG-1000 system and probably others). But all those are lacking output options that would make them really usable. That is, they all only generate a mockup picture on screen, but don't output anything (except for the CD+G version, which outputs CD+G format and has evolved to Karaoke Builder). So.. where do you think I should upload it? >Sorry about the palette, I couldn't see very well what color I should be using on the bubble inkjet printout of the small .jpg->picture you had added, the palette is easily changed as described before. Oh... I see. >Use DASM and MESS to try your code out, use the multiblit routine since that's the fastest. We may have a problem >removing the delay when compiling for old version VES, but removing delay in blit routine works for MESS (hence not >accurate emulation) and it also works on the Channel F II and late version consoles of other brands that has the VLSI chip >instead of all the logic circuitry... Well... that's the problem, I don't want to invest too much time right now because I've got many other things to do, especially now in summer when it's still hot, and we go swimming often which regularly eats away 4-5 hours of the day. >VERY VERY VERY nice work! Oh, thanks! >Do Interkarate+ as well, I'm thinking of making it into a VES-game... OK, I'll try that one... Here's the converted picture... However, something tells me that something doesn't work properly here... I think that game would be best with a solid gray background in the lower part, and the player sprites should consist of red body parts and red, blue and green clothes. But maybe the upper part could be done similarly to what I did here. However, here's the code for it (provided the previous picture worked, which I don't have a proof for yet): gfx.palette.data: .byte % 00010100, % 01010100, % 01010101, % 00010101, % 00010000, % 00011001, % 01010100 .byte % 01000100, % 01000100, % 01000001, % 00010001, % 00010000, % 01000100, % 01000001 .byte % 00010000 gfx.multicolor.data: .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000100, % 01000000 .byte % 00000001, % 00000000, % 00000000, % 00000000, % 00001110, % 11101110, % 11100110 .byte % 10010111, % 10110000, % 01010101, % 01010101, % 11000101, % 01010101, % 01011101 .byte % 01000000, % 01111000, % 00000000, % 10000000, % 00000010, % 01000000, % 00110001 .byte % 00010001, % 11010101, % 01100010, % 00100101, % 10010111, % 10011001, % 10011001 .byte % 01011101, % 10010101, % 01010101, % 01010100, % 01110111, % 01010100, % 00000000 .byte % 00000000, % 00000100, % 01000000, % 00000000, % 01101110, % 00000101, % 01010101 .byte % 01011101, % 01010101, % 01110100, % 00000000, % 01000000, % 00000010, % 11000000 .byte % 01100110, % 10101010, % 10100100, % 10101001, % 01100010, % 01100010, % 00000000 .byte % 00000000, % 00000001, % 00010001, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000001, % 00010000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00010000, % 00000000, % 00000100, % 01010000, % 00010001, % 01000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 11101001, % 01110101, % 01011011 .byte % 10111011, % 01011000, % 10110000, % 00000000, % 00000010, % 00110010, % 00000000 .byte % 00100110, % 01010110, % 01011101, % 10010101, % 10010000, % 00000010, % 10001011 .byte % 10000001, % 01100000, % 00100000, % 11010101, % 01100101, % 10011101, % 01100110 .byte % 01010101, % 10010001, % 11010100, % 01000001, % 00000001, % 01010101, % 01110110 .byte % 01010101, % 01010101, % 01110110, % 01011101, % 11011101, % 11010110, % 11010101 .byte % 01010111, % 10110101, % 01010000, % 00110111, % 01010111, % 01011000, % 00010100 .byte % 01100110, % 01011010, % 01100101, % 10011110, % 01101101, % 01011010, % 00000001 .byte % 01000100, % 01000101, % 01000001, % 01010101, % 01110000, % 00000001, % 01010101 .byte % 11011101, % 01010101, % 01010101, % 01110101, % 10110110, % 01010101, % 01011101 .byte % 01010101, % 01010101, % 11010101, % 01001000, % 10000101, % 10101010, % 10100110 .byte % 01010110, % 01101010, % 01011010, % 01100000, % 00000000, % 00000000, % 00010000 .byte % 00010101, % 01010100, % 01000000, % 01000100, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000100, % 01000101, % 00010001, % 00010001, % 00000000, % 00000000, % 00000000 .byte % 00010000, % 11101110, % 01000101, % 01110000, % 01010101, % 01000101, % 01010101 .byte % 00010000, % 00000101, % 01010101, % 01010101, % 10111011, % 01110111, % 01010101 .byte % 01110111, % 01010101, % 01010101, % 10011011, % 10010101, % 01010101, % 01100010 .byte % 01101001, % 10101001, % 01011001, % 01101001, % 01010110, % 01100001, % 01011110 .byte % 11010000, % 00111011, % 10000000, % 00000100, % 00010100, % 00000000, % 01000100 .byte % 00000110, % 01010101, % 01010001, % 00010111, % 01010100, % 01000100, % 00010110 .byte % 01010101, % 01010101, % 00000000, % 00010101, % 00011001, % 01010001, % 10010111 .byte % 01010110, % 01101010, % 01011010, % 01001110, % 00000000, % 00000101, % 01011100 .byte % 00000000, % 00000000, % 00010101, % 01010101, % 00000000, % 01110111, % 01000000 .byte % 00000000, % 01100111, % 01010000, % 00000001, % 01110111, % 01000000, % 00000101 .byte % 01010101, % 01010101, % 01000000, % 10100001, % 10011010, % 11010111, % 01100101 .byte % 01010101, % 01010101, % 01010001, % 00100101, % 01010101, % 01010101, % 01010101 .byte % 01000000, % 00010101, % 01110110, % 01010101, % 01010101, % 01010111, % 01100100 .byte % 01010101, % 01010111, % 01010111, % 01010101, % 01010100, % 11001101, % 11010101 .byte % 01010001, % 01011001, % 01100110, % 01010010, % 01101010, % 00000000, % 00000000 .byte % 00000001, % 00010101, % 00000000, % 00010101, % 01010101, % 01000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00010000, % 00010001, % 01000101, % 00010001, % 00000101, % 00010100 .byte % 00000000, % 00000000, % 00000101, % 01010101, % 01010101, % 01110100, % 01010011 .byte % 10110000, % 00000000, % 01010101, % 01000111, % 01110101, % 01011101, % 11011101 .byte % 01010101, % 01010101, % 01010001, % 01111001, % 01011101, % 10000101, % 11100101 .byte % 01010001, % 00010101, % 01010111, % 01000000, % 00010101, % 10011001, % 11011110 .byte % 10010101, % 01010101, % 01010101, % 01011101, % 01010101, % 01000000, % 00000001 .byte % 00000101, % 01010101, % 00011001, % 00010100, % 01010001, % 00000000, % 00010001 .byte % 01010001, % 01111001, % 00010000, % 00000100, % 00000001, % 01010000, % 00000001 .byte % 00000101, % 01010000, % 10010101, % 01010110, % 10010101, % 10010101, % 01100110 .byte % 01010101, % 01010001, % 00000001, % 01000101, % 01010101, % 00000000, % 01010101 .byte % 01010101, % 01010101, % 01010000, % 00000001, % 01010101, % 01010101, % 01010101 .byte % 01010101, % 01010101, % 01000001, % 01010100, % 01000100, % 01000100, % 00000001 .byte % 10011101, % 00010001, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 01000000, % 00010100, % 01000100, % 01000100, % 01000000, % 01000100, % 01000100 .byte % 01010101, % 01010001, % 00010001, % 00000000, % 01000100, % 01010101, % 01000100 .byte % 00000001, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000110 .byte % 01100110, % 01011101, % 00011101, % 11011101, % 11011101, % 11100000, % 00000101 .byte % 01010101, % 01010111, % 01010101, % 01010101, % 01010000, % 00000001, % 01010101 .byte % 01010111, % 01010101, % 01010101, % 01010101, % 01000000, % 00011101, % 11100110 .byte % 00101010, % 10010101, % 01111001, % 11011011, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000101, % 01010101, % 01010101, % 01000000 .byte % 01010101, % 01010101, % 01010101, % 01010101, % 01010101, % 01000000, % 01010101 .byte % 01010101, % 01010100, % 00000000, % 00000000, % 00000000, % 00000000, % 00010000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000100, % 01000000, % 00000001 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00010000, % 00010000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00010001, % 00000000, % 00000000, % 00000101 .byte % 00010100, % 01000000, % 01000100, % 01000100, % 01010101, % 01000100, % 01000100 .byte % 01000000, % 00010001, % 01000000, % 01000100, % 00000000, % 00000001, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000101, % 01110101, % 11011110, % 11111111 .byte % 00111111, % 11111111, % 11111111, % 11111111, % 11111111, % 11111111, % 01111111 .byte % 00110011, % 11000100, % 00000100, % 11111111, % 11111110, % 01011111, % 11111111 .byte % 11001111, % 11001111, % 10111001, % 01100110, % 01100101, % 10011001, % 01111111 .byte % 11111111, % 11010101, % 10111011, % 00110000, % 11001111, % 00110011, % 00110011 .byte % 00110011, % 00110011, % 00110011, % 11101101, % 11111111, % 11110100, % 10101010 .byte % 10010111, % 11001100, % 11110110, % 11001100, % 11001111, % 11001111, % 11111111 .byte % 11001100, % 11111011, % 10010101, % 01010110, % 01100110, % 01101100, % 11111111 .byte % 00111111, % 11111111, % 00111111, % 11111111, % 11111111, % 11111111, % 11111111 .byte % 11001111, % 01101100, % 11001100, % 01000000, % 00000000, % 01001111, % 11111110 .byte % 11011111, % 11111111, % 11001111, % 11001100, % 11111111, % 11111111, % 00110011 .byte % 11100101, % 01111111, % 11111111, % 11111110, % 01111111, % 00110011, % 00111111 .byte % 00110011, % 00111100, % 11110011, % 11001100, % 11001111, % 11111001, % 11111111 .byte % 11111111, % 01000000, % 01111111, % 11110011, % 11010101, % 11110011, % 11001111 .byte % 11001111, % 11111110, % 01010101, % 11111111, % 11111101, % 10010111, % 11110100 .byte % 00111101, % 11011111, % 00111111, % 11111111, % 11111111, % 11111111, % 11111111 .byte % 11111111, % 11111111, % 11111101, % 01111111, % 11000111, % 01000010, % 00100000 .byte % 01100101, % 11111110, % 01101111, % 11111111, % 11001111, % 11001100, % 00001101 .byte % 10011011, % 01011101, % 10011101, % 01100111, % 10010101, % 10011000, % 01111111 .byte % 11001111, % 00110011, % 00111100, % 11011011, % 00110001, % 10011100, % 11001100 .byte % 11101110, % 11001100, % 11011011, % 01100111, % 01100111, % 01111100, % 11110101 .byte % 11011110, % 11001111, % 11001111, % 11110001, % 10001101, % 11011011, % 10011001 .byte % 10010111, % 10011110, % 00000001, % 01010000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000100, % 00000100, % 00000000, % 01000000, % 00000000, % 00000000 .byte % 00011110, % 01100100, % 11011011, % 01101110, % 00100111, % 10011110, % 01100010 .byte % 11011100, % 01111001, % 11011101, % 11010011, % 10011110, % 01110011, % 10110100 .byte % 01100010, % 11011001, % 11100111, % 10011110, % 01111001, % 11100100, % 01001110 .byte % 01101101, % 00010110, % 01011001, % 10011110, % 01110000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000100, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00111001, % 11001110, % 01111001, % 11100111, % 01111011 .byte % 00010000, % 01110100, % 00011000, % 10001000, % 10011001, % 10111001, % 11100111 .byte % 10011001, % 00011011, % 10011101, % 00011001, % 10110011, % 00010001, % 11100100 .byte % 11011011, % 10000001, % 10001000, % 01101101, % 11100111, % 01111001, % 11010000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00010001, % 00011011, % 01101100 .byte % 11011000, % 10011000, % 01101110, % 11001011, % 01101101, % 11001101, % 11001101 .byte % 00010001, % 00010011, % 00110111, % 10110001, % 11011011, % 10011101, % 10100100 .byte % 01101110, % 01111000, % 10011110, % 01110000, % 01110111, % 10011110, % 01000010 .byte % 01101110, % 01000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00111011 .byte % 10110110, % 11011001, % 10110111, % 01110111, % 00110110, % 01000111, % 10011110 .byte % 01100000, % 01100010, % 11001110, % 11100010, % 01100010, % 00100110, % 11100111 .byte % 01101100, % 10011110, % 11010011, % 01101101, % 11001011, % 10011011, % 10010110 .byte % 11011011, % 00110011, % 01111001, % 11100000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 01000000, % 01000100, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 10101001, % 00010000, % 10000011, % 00000000, % 00001001, % 10000000 .byte % 00100000, % 00001001, % 11011101, % 10110111, % 01100100, % 01110111, % 01110111 .byte % 01110101, % 01000000, % 00000111, % 01111001, % 10111001, % 00000000, % 10011001 .byte % 11011101, % 00000000, % 00000010, % 01100110, % 00000000, % 00100000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00010000, % 00000000, % 00000000, % 01000001 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00010100, % 00000000 .byte % 00000000, % 00000001, % 00000000, % 00000000, % 00010000, % 01000000, % 00000000 .byte % 00000100, % 00000000, % 00000000, % 00000000, % 01000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000001, % 01000100, % 00000001 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 01000000 .byte % 00000001, % 11011000, % 01111001, % 10000010, % 01101100, % 01110110, % 11011011 .byte % 01110000, % 11011011, % 00100010, % 00001000, % 00111000, % 00011000, % 11101101 .byte % 01010111, % 01111011, % 10000000, % 00000111, % 01000101, % 01111011, % 10111001 .byte % 10111011, % 11011101, % 00000000, % 00000011, % 01110100, % 00000000, % 00010000 .byte % 00000000, % 00000000, % 00010000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000001, % 01010001, % 01000000, % 00000000 .byte % 00000100, % 01000000, % 01000000, % 00000000, % 00000100, % 01000000, % 01000000 .byte % 00000000, % 00000000, % 00000000, % 10010011, % 00110000, % 01110000, % 01110001 .byte % 10110010, % 01111001, % 10111001, % 10110110, % 01110111, % 01110111, % 01100111 .byte % 10011101, % 01011000, % 00000000, % 01100100, % 01011100, % 00000001, % 01000101 .byte % 00010001, % 10110111, % 00111111, % 11111100, % 00100111, % 01100000, % 10111000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000001, % 00010000 .byte % 01000000, % 00000001, % 00000000, % 00000000, % 00000000, % 00000000, % 01000000 .byte % 00000000, % 00010001, % 00000000, % 00000000, % 00000111, % 01110110, % 01100010 .byte % 11011001, % 10111011, % 01001101, % 10110111, % 01110111, % 00011011, % 10011000 .byte % 11100111, % 10011110, % 01111001, % 11010101, % 01010100, % 00000111, % 10011110 .byte % 01000101, % 01010101, % 00000110, % 01111111, % 11111111, % 11110011, % 11111110 .byte % 11011101, % 11010101, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000001, % 00010101, % 01000101, % 00000000, % 00000000, % 00010100, % 01000000 .byte % 00000000, % 00000000, % 00000000, % 00010000, % 00000100, % 00000000, % 00000000 .byte % 01101100, % 01110111, % 01101101, % 11010010, % 01100100, % 11100110, % 01111001 .byte % 11100111, % 00000111, % 00001001, % 11100111, % 00000000, % 00000000, % 00000011 .byte % 00000101, % 10110000, % 00000101, % 01010111, % 01000101, % 11111111, % 00000101 .byte % 11011111, % 11111101, % 00000111, % 10011110, % 00000000, % 00000001, % 00000000 .byte % 00010000, % 00000100, % 00000000, % 01000000, % 00000001, % 00000000, % 00000000 .byte % 00010000, % 00000000, % 00000000, % 01000001, % 00000100, % 01000000, % 00000000 .byte % 00010001, % 00010000, % 00010000, % 00000000, % 00010000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00010100, % 00000001, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000100, % 00000000, % 00000000, % 00010000, % 00000000, % 00000000, % 00011110 .byte % 01111001, % 11100111, % 10010011, % 10011101, % 10110011, % 01111011, % 01101101 .byte % 10110110, % 11011011, % 01111000, % 01111001, % 11100111, % 10010000, % 00011000 .byte % 10011100, % 01010101, % 01010101, % 01111000, % 00111000, % 01111001, % 11101101 .byte % 10000100, % 01001011, % 10011110, % 01110000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000100, % 00000000 .byte % 00000000, % 00000000, % 01001110, % 01111001, % 11100000, % 01101100, % 00000110 .byte % 00001001, % 11100000, % 00000100, % 11100111, % 10010011, % 00000000, % 01111000 .byte % 01000001, % 10110111, % 00000011, % 10011101, % 01010111, % 10011100, % 01101101 .byte % 10110110, % 11011001, % 11010000, % 01011101, % 10000111, % 10010000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000001, % 00000000, % 00000000, % 00011100, % 00000000, % 00000000, % 00110110 .byte % 11010000, % 00000001, % 11011110, % 01110111, % 10011100, % 00000000, % 00000010 .byte % 01000000, % 00000000, % 00111011, % 01111001, % 00000101, % 01010101, % 11100100 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 11100100, % 01000100, % 00000000 .byte % 00010000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000001 .byte % 00000001, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000100, % 00000000, % 00010001, % 00010000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000100, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000010, % 01110000, % 01101101, % 11100100, % 11100111 .byte % 10011110, % 01111001, % 11100111, % 10000110, % 11011011, % 01101101, % 00111001 .byte % 11100111, % 10010011, % 00011011, % 01101101, % 10110110, % 11011000, % 11011011 .byte % 01101101, % 00101110, % 01111001, % 00000001, % 11100000, % 10011110, % 01111001 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000001, % 11100100, % 11100111 .byte % 10011110, % 01111001, % 11100111, % 10011110, % 01111001, % 11011110, % 01111001 .byte % 11100111, % 10011110, % 01111001, % 11100111, % 10011110, % 01111001, % 11100111 .byte % 10011110, % 01111001, % 11100111, % 10011101, % 10110110, % 11011011, % 01101101 .byte % 11100111, % 10011110 KurtAN??? OK, I'll try to do it... I was afraid everyone would fall over me if I did that. Hmm... let's see... how about that one? I've also included a multicolored blue ghost there. For the normal ghosts, I don't think multicolor makes too much sense, since they're only 5x5 pixels anyway. For the blue ghosts, however, red eyes and a grey "dot" which could be a nose or mouth would look nice. When flashing, they should flash to red with blue eyes, to differentiate them from "normal" red ghosts (they can't be flashed to white, and grey is the background color so that they would be invisible). I wouldn't see it that way. One square in the arcade is roughly 2 pixels in your version. Well... I'd say the "harmable" portion of each object should be the 3x3 inner square (safe for maybe the dots to eat). I see... so that's the reason why it's getting faster. Wouldn't it be feasible to only redraw those dots which are near the moving objects?

OK. I think this is a vast improvement over build 14 which was previously available, in that the game is really working. :-) But why is the new build mentioned in the WIKI, but not linked to? One idea of mine would be to more accurately match the number of dots in the arcade by spacing the dots 2 pixels apart instead of 3 where possible. But that's not so important since the other home versions have fewer dots to eat as well. Then... the flashing of the monsters isn't well executed in that there's a blue ghost which is also blue if dangerous, and that one doesn't flash at all. In the arcade, the blue ghosts flash between blue and white before reverting to their original colors. The AI of the ghosts seems to be weaker in that the ghosts move around more randomly and don't seem to chase Pac Man as much. There's a thread about the exact behaviour of the ghost AI here at AtariAge: http://www.atariage.com/forums/index.php?showtopic=68707 To make up for that, the blue time seems to be a little shorter than on the Arcade. And the collision detection seems to be less forgiving than on the arcade. As far as I understand what's been written about the arcade code, it simply checks what 8x8 field Pac Man and the monsters are on (would translate to a 3x3 field here), and if they're on the same field, collision has occured. Oh, and contrary to what the WIKI says, the game speed does speed up towards the end of each board. But Pac Man and the ghosts always seem to travel at the exact same speed (except for "blue mode"), which isn't true in the arcade (but also is that way in some home ports). But all in all, it's a nice port. It beats the original Atari 2600 version by lengths...

Hmmm... seems like something went wrong when converting my picture. In the picture I've sent, the background color mostly was set to light grey, while here it's set to light blue for the sky and light green for the meadow part of the picture... the background color light grey doesn't get used at all. I've now modified my converter program so that it puts out the correct .byte strings for gfx.palette.data and gfx.multicolor.data. But I don't know if they're really correct because I haven't tested them. I've downloaded the development pack from the VesWiki, but setting it up would be a bit troublesome, especially in that the newest version of the picture drawing program has the picture stored in two different formats in order to compare the drawing speeds of two different routines. So how could we go on with this? Should we go on with it at all or should we leave the picture as it is? Don't forget that my program is able to convert any picture now... albeit with mixed results. For instance, this would be a converted screenshot of Pole Position: And this is the according code, though I don't know if it's really correct... I had to put a space after each percent sign which normally doesn't belong there, otherwise the code would get jumbled by the forum software. gfx.palette.data: .byte % 01010101, % 01010101, % 01010101, % 01010101, % 00010000, % 01010001, % 01000101 .byte % 00010100, % 01010001, % 00010001, % 00010001, % 00010001, % 00010001, % 00010001 .byte % 00010000 gfx.multicolor.data: .byte % 00111111, % 11111110, % 11101110, % 11101111, % 11111011, % 10111111, % 10110011 .byte % 10110011, % 10111111, % 11111111, % 11111111, % 00111111, % 11111111, % 11111111 .byte % 10111011, % 11111111, % 00111111, % 11111011, % 10111111, % 00000000, % 00000000 .byte % 00000000, % 00100000, % 00000011, % 11111011, % 10010011, % 11101110, % 11111111 .byte % 11111111, % 11111011, % 11111111, % 11001111, % 11111111, % 11111111, % 00111011 .byte % 00111011, % 10111111, % 10111011, % 00111011, % 10111111, % 11111011, % 10111111 .byte % 00111011, % 11111111, % 00010000, % 11000000, % 00000000, % 00000000, % 00001100 .byte % 00101100, % 11110101, % 11110011, % 11111101, % 11101110, % 11111011, % 11111011 .byte % 10110111, % 11101110, % 11101110, % 11011111, % 11111111, % 11111111, % 10111111 .byte % 11111111, % 11111111, % 00111011, % 11111111, % 10111111, % 11111011, % 01111111 .byte % 01000000, % 00000000, % 00000011, % 11000000, % 01111101, % 11111111, % 10110011 .byte % 11110011, % 10111111, % 11111100, % 11111011, % 11111111, % 11101111, % 11111111 .byte % 11111111, % 10111011, % 10111011, % 10111111, % 10111011, % 10110011, % 10111111 .byte % 00111011, % 10111111, % 10111011, % 11111110, % 00001000, % 00000000, % 10010000 .byte % 00001011, % 10110011, % 10111011, % 10110101, % 11111011, % 11111111, % 11101110 .byte % 11111100, % 11111110, % 11101111, % 11111011, % 10111011, % 10111111, % 11111111 .byte % 11111111, % 10111111, % 11111111, % 11111111, % 10111111, % 11111111, % 10111111 .byte % 11111110, % 11111101, % 11000000, % 10110111, % 11011111, % 11111111, % 11111111 .byte % 11111111, % 01110011, % 11111011, % 10110011, % 11111110, % 11110011, % 00111111 .byte % 11111011, % 11111111, % 11111111, % 11101111, % 10111011, % 00110011, % 00111011 .byte % 10111011, % 10111111, % 10110011, % 10111111, % 11101110, % 11111110, % 11101110 .byte % 11111111, % 10111011, % 00111011, % 11101110, % 11001110, % 11111001, % 11111011 .byte % 11111111, % 11111110, % 11111101, % 11111111, % 00111011, % 11111011, % 00111011 .byte % 11101111, % 11001111, % 11111111, % 11111111, % 11111111, % 11111111, % 10111111 .byte % 11111111, % 11101111, % 11111111, % 00111111, % 11110011, % 10111111, % 11111111 .byte % 11110011, % 11111111, % 11001101, % 11010011, % 11111110, % 11101110, % 11111110 .byte % 11111011, % 10111111, % 11110011, % 11111111, % 11111100, % 11101111, % 11001110 .byte % 11101110, % 11101100, % 11101110, % 11001111, % 10111011, % 11101111, % 11110011 .byte % 10111111, % 10111011, % 11111111, % 10111011, % 10111011, % 11001110, % 11101111 .byte % 11111001, % 11111011, % 00111111, % 11111110, % 11111111, % 00111111, % 10111011 .byte % 11011110, % 11101110, % 11111111, % 11101111, % 11111111, % 11111111, % 11111111 .byte % 11111111, % 11001111, % 11001100, % 11111011, % 11111111, % 10111111, % 11111011 .byte % 10111111, % 11111111, % 11110111, % 11111111, % 11101101, % 11010011, % 11111111 .byte % 11101110, % 11111111, % 10111111, % 10111111, % 11111011, % 11111111, % 11111110 .byte % 11001111, % 00110000, % 11000011, % 00110000, % 00111110, % 11101111, % 11110011 .byte % 11111100, % 11111011, % 10111111, % 10111011, % 11111111, % 11101111, % 10111011 .byte % 11101110, % 11101111, % 11111001, % 00111110, % 11101111, % 11111111, % 10111111 .byte % 10111111, % 10111011, % 11111110, % 11101110, % 11111111, % 00110011, % 11111111 .byte % 11110011, % 11111111, % 00111111, % 11101100, % 11110011, % 00111100, % 11111111 .byte % 00110011, % 11111100, % 11101111, % 11001111, % 11111100, % 11111111, % 11111011 .byte % 01111111, % 00111111, % 11111011, % 00110011, % 10111111, % 10111111, % 11111110 .byte % 11111111, % 11111100, % 11001111, % 11110011, % 00110011, % 11110011, % 00111100 .byte % 11001111, % 11111100, % 11111100, % 11001100, % 00111111, % 11111110, % 11111111 .byte % 11101111, % 11101110, % 11111111, % 10111011, % 11110101, % 00111100, % 11101100 .byte % 11111111, % 11111111, % 10111111, % 11101110, % 11111110, % 11001100, % 11110011 .byte % 11001100, % 11110011, % 11001100, % 11111100, % 11111111, % 10110000, % 00000011 .byte % 00111111, % 11111111, % 10111011, % 00111110, % 11001111, % 11101111, % 11111110 .byte % 11001111, % 11111110, % 11010011, % 00111111, % 11110011, % 10111011, % 00111111 .byte % 11001111, % 11111110, % 11111111, % 11110011, % 11110011, % 11110011, % 11110011 .byte % 11111100, % 11001100, % 11001111, % 00000000, % 00111100, % 11000011, % 00001111 .byte % 11111100, % 11001111, % 11101111, % 11001110, % 11111111, % 11001110, % 11110111 .byte % 11111111, % 11001100, % 11111111, % 11111100, % 11101111, % 11101110, % 11111111 .byte % 10110011, % 11110011, % 11110011, % 11110011, % 11110011, % 00111111, % 11111111 .byte % 00000011, % 10010000, % 00111111, % 11111111, % 11110011, % 00111111, % 11101111 .byte % 11101111, % 11111110, % 11101111, % 11111111, % 10010011, % 11001111, % 11111111 .byte % 00110011, % 00111111, % 00110011, % 11110011, % 10111111, % 11110011, % 11110011 .byte % 11110011, % 11110011, % 11111111, % 11001100, % 11000000, % 00110011, % 00000000 .byte % 00111100, % 11110011, % 11111111, % 11001111, % 00110011, % 00110011, % 00111101 .byte % 11110011, % 00110101, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000001 .byte % 10011001, % 10011001, % 10011101, % 11011001, % 10011101, % 10011001, % 11011001 .byte % 10011101, % 10011101, % 10011101, % 10011101, % 10011110, % 01110110, % 11011101 .byte % 10110111, % 10011100, % 00011101, % 00011001, % 10011001, % 10011001, % 11010001 .byte % 11011011, % 00111011, % 00111011, % 00110101, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00100010 .byte % 10001000, % 10001010, % 01100010, % 10001000, % 10011010, % 00100010, % 01100010 .byte % 01100010, % 00100010, % 00100010, % 01100010, % 00100010, % 00101000, % 10001000 .byte % 10100010, % 00101000, % 10100010, % 10001010, % 00100010, % 01100010, % 00100010 .byte % 10101000, % 10001000, % 10001001, % 01011010, % 10101010, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 10101010, % 10101000, % 10101010, % 10101010 .byte % 10100001, % 01000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00001010, % 10001010 .byte % 00101010, % 00100010, % 00100110, % 00101000, % 10100010, % 00101010, % 10100010 .byte % 00101010, % 00100010, % 10001010, % 00101010, % 10001000, % 10001010, % 10100010 .byte % 10101000, % 10001001, % 10001001, % 10001010, % 10101000, % 10100110, % 10101010 .byte % 10101010, % 10001010, % 11100101, % 00101010, % 10101010, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 10001010, % 10101010, % 00101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 10101010, % 10101000, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010 .byte % 00010000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 01000000, % 00100110, % 10101000 .byte % 10001010, % 10001010, % 10100010, % 10001010, % 00101010, % 10101010, % 00101010 .byte % 10101010, % 00100010, % 10100010, % 00100010, % 10101010, % 00100010, % 10101010 .byte % 10101010, % 10100010, % 10101001, % 10100110, % 11101010, % 10100110, % 01010110 .byte % 00010110, % 01100110, % 01111010, % 10101000, % 10101010, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10100010 .byte % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101000 .byte % 10100010, % 11100110, % 01000001, % 00011100, % 11001100, % 11001100, % 00110101 .byte % 01000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000001, % 00000000, % 00000000, % 00000100, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00001010, % 10101010, % 10101010 .byte % 00100010, % 00100010, % 00101000, % 10101000, % 10001000, % 10001010, % 00101000 .byte % 10001010, % 10101010, % 10101010, % 00100110, % 01111010, % 10100010, % 00100000 .byte % 00001001, % 00011001, % 10011001, % 10011101, % 01101110, % 11100110, % 01100110 .byte % 01100101, % 01011101, % 00101010, % 10101010, % 10101010, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10100000, % 00000000, % 00001100, % 11100010, % 11010011 .byte % 00110011, % 00101100, % 01000011, % 01001100, % 11001100, % 11101100, % 01010000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000100, % 00000000, % 00000000, % 00000101 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00100110, % 10001010, % 00101010 .byte % 10101001, % 10101010, % 00100010, % 01101010, % 10101010, % 01101001, % 10101010 .byte % 10100111, % 10000000, % 01011100, % 01101101, % 01010101, % 01010101, % 10011001 .byte % 01011101, % 11101110, % 01100110, % 01110111, % 10111001, % 10110101, % 10011001 .byte % 10111001, % 10011010, % 10101010, % 10101010, % 10101010, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 00100001, % 01010111, % 10010000, % 00110010 .byte % 00001011, % 01101100, % 00111011, % 10110011, % 00111011, % 10010000, % 00011100 .byte % 11001110, % 01000100, % 01001101, % 10110011, % 00110001, % 01011101, % 01000000 .byte % 00000000, % 00000001, % 00000100, % 01000000, % 00000000, % 00000001, % 00000100 .byte % 00000000, % 00000001, % 01000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00010000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000101, % 00001010, % 10101010, % 10101010, % 10101010 .byte % 10101010, % 10101010, % 10101010, % 00000000, % 00000001, % 00000001, % 10011110 .byte % 01001110, % 01000111, % 01001100, % 00111001, % 11000001, % 11011001, % 00000001 .byte % 10111000, % 10111001, % 00010011, % 10110011, % 10110000, % 10110110, % 00100110 .byte % 00010101, % 01000000, % 01000000, % 01000000, % 00000000, % 00000100, % 01010101 .byte % 01010000, % 00010100, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000001, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 01010000, % 00001010, % 10101010 .byte % 10101010, % 10101001, % 10010101, % 01010101, % 01010000, % 00011011, % 01101101 .byte % 00000111, % 10000010, % 11100111, % 10110010, % 11100110, % 11010011, % 10011110 .byte % 11000011, % 10110011, % 00110001, % 11000011, % 10111001, % 11100100, % 11011011 .byte % 01111011, % 01000001, % 00010101, % 01000000, % 00000000, % 00000101, % 00010000 .byte % 00000000, % 00000100, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000001, % 00000000 .byte % 00001010, % 10101010, % 10100000, % 00000000, % 01011000, % 00100100, % 00101100 .byte % 11000011, % 00001110, % 11001110, % 11011100, % 11001100, % 01000111, % 00001100 .byte % 11101101, % 10111001, % 11100100, % 11100100, % 01101110, % 01111001, % 00110011 .byte % 00111011, % 00001011, % 00000110, % 00001011, % 01010101, % 01000001, % 01010101 .byte % 01010000, % 00010100, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000101, % 00000000, % 00000101, % 01010101, % 01110000, % 00000110, % 11010001 .byte % 11001011, % 00011110, % 01111001, % 00011110, % 00010001, % 00111001, % 10110110 .byte % 11101100, % 01000000, % 00110010, % 11010011, % 00110011, % 01101110, % 11000111 .byte % 00001100, % 11011001, % 00011110, % 01110001, % 11100001, % 00011101, % 00010101 .byte % 00010001, % 00010100, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000101, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000010, % 11001110 .byte % 11100000, % 11101110, % 01001101, % 10110000, % 11001110, % 11100111, % 00111011 .byte % 10011100, % 11000000, % 00011110, % 00001011, % 10000101, % 11101110, % 01001000 .byte % 10110011, % 01101110, % 01111001, % 00001011, % 10110000, % 11100010, % 11011101 .byte % 01010011, % 01010101, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 01000100, % 00010000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000001 .byte % 11010011, % 10011110, % 01110100, % 01000111, % 10110000, % 11100111, % 10010000 .byte % 01111001, % 11100111, % 00111001, % 00010101, % 11010101, % 01010101, % 01010100 .byte % 01011101, % 11011101, % 00000110, % 11001100, % 01111011, % 00110111, % 10011110 .byte % 01110100, % 00111001, % 00010100, % 11010101, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 11101100, % 00110011, % 00111011, % 10110000, % 11100111 .byte % 00001100, % 11101100, % 11001011, % 00001011, % 01100111, % 01100111, % 01010101 .byte % 11011101, % 00010011, % 10011110, % 11001110, % 11001100, % 11100110, % 11100000 .byte % 01101100, % 00110011, % 00111011, % 10011100, % 01000101, % 00110101, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 01111001, % 11100100, % 01000001 .byte % 11100111, % 00001110, % 01111001, % 00110110, % 01001101, % 10110100, % 01010101 .byte % 01110111, % 10010001, % 00001101, % 10110110, % 01111001, % 00000111, % 10010001 .byte % 00110011, % 01000111, % 10110110, % 11011001, % 00010011, % 00110110, % 11010101 .byte % 01010101, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 11100000 .byte % 10110011, % 10110011, % 00001011, % 10011110, % 00001011, % 10000010, % 11100000 .byte % 10110000, % 01110111, % 01110111, % 01111011, % 10111111, % 11011101, % 10011110 .byte % 11100000, % 10111011, % 10010010, % 11100011, % 10011110, % 00001011, % 10111001 .byte % 00101100, % 10111001, % 11010101, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000001, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 11010001, % 11100100, % 01111001, % 00011100, % 11001100, % 11010001 .byte % 11001100, % 11010001, % 11100100, % 01111011, % 01101100, % 11101101, % 00110011 .byte % 00110100, % 01110001, % 00110100, % 01110001, % 00110100, % 01110011, % 00110011 .byte % 01000111, % 00010011, % 01000111, % 00010011, % 10010001, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00101110, % 00001011, % 10000010, % 11100010 .byte % 00100010, % 00101110, % 00100010, % 00101110, % 00001011, % 10000010, % 00111000 .byte % 00111000, % 10111000, % 10001011, % 10001011, % 10001011, % 10001011, % 10001011 .byte % 10001000, % 10001000, % 10111000, % 10111000, % 10111000, % 10111000, % 00110101 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000, % 00000000 .byte % 00000000, % 00000000, % 00000000, % 00000000, % 00000111, % 01000111, % 01000111 .byte % 01000111, % 01000111, % 01110111, % 01000111, % 01110111, % 01000111, % 01000111 .byte % 01000111, % 01000111, % 01000111, % 01000111, % 01110100, % 01110100, % 01110100 .byte % 01110100, % 01110100, % 01110111, % 01110111, % 01000111, % 01000111, % 01000111 .byte % 01000111, % 01000101

I don't think this would work... you convert the random value 0-255 to 0-63, and then add #36 to that... which gives a random value in the range of 36 to 99... not 0 to 99 as you probably would like it to be (unless the LSR command does something else than I expect).

Well, as you can see on that video, it's not only relabeled... the graphics also have been changed a bit, most notably the sprite of the player character, which in the MSX version is male.

Hmmm.... I watched a video of it on YouTube (since I don't have an X-Box myself), and I think it could be nicely done if you adapt it the way Jr. Pac-Man was adapted... by having a similar screen layout to that. What occurs to me first is the distance from one passageway to another which has been increased to 4 dots, compared with 3 dots on the original arcade Pac Man. Each half of the playfield consists of a 6x7 grid, in addition to that there's the monster pit in the middle which derives a bit from the grid. As-is, I think it's pretty undoable on the 2600 since the playfield isn't reflected. However, the playfield is reflected on the horizontal line, so if you turn it around by 90°, you get something that would be doable on the 2600. Instead of the left and right half, you'd get an upper and lower half, and with some simplifications this would be doable. However, since the playfield now would be more high than wide, you'd have to scroll it, like Jr. Pac-Man does. Now each half would be 7 grid positions wide and 6 high, with the whole maze being 7 x 15. This is smaller than the maze of Jr. Pac Man on the 2600 is... that one is 10 wide and 18 high. You could adjust for this by changing around the mazes so that they are 10 wide and 11 high, or something like that. Yes, I think it should be doable this way.