Resurrected Entertainment

Archive for November, 2011

Tototek PCE Pro 32MB Flash Cartridge

November 22, 2011

The device has a few quirks to it that you will soon come to enjoy; however, in order to make its hard love easier to bear I have come up with a nice list to follow if you are trying to use it:

1. Make sure the cable is IEEE 1284 compliant (the cartridge will report a size of zero, if the cable, or if any communication is disrupted between the cartridge and your computer).

2. I assigned the printer port to port 0x278 in the BIOS and in Windows; I also configured the port to use the EPP protocol v1.7.

3. I only use version 1.13 (1.3 depending on where you look) of the DreamWriter software.

4. You do not need the “pceboot.pce” file; ignore it, it’s for something else entirely.

5. When you select multiple ROMS for upload, the DreamWriter software will install a bootloader; however, it will install a Japanese version of it by default, instead of the U.S. version (assuming you are using a U.S. TurboGrafx system). Once you have chosen your ROMs (and have correctly set the U.S. region box for those Japanese games you want to play), you must select the “U.S. Region” checkbox in the lower left corner of the interface — this will ensure the right bits have been flipped on the Japanese ROM.

6. You must start the program after the USB power and printer cables have been connected; the switch labeled “SW” does not need to be “ON” for the upload to work; in fact, I have no idea what that switch does.

7. The program will never show you how much space is occupied on the cartridge (after a fresh execution), or which games have already been flashed, so don’t bother scratching your head. The DreamWriter software only knows how much space remains after writing a set of ROM files.

Launch birthdays for the *Sega 32X and **Nintendo DS!

November 21, 2011

* North American launch date in 1994 for the 32X
** North American launch date in 2004 for the Nintendo DS

The Sega 32X system was designed to breath new life into the aging MegaDrive and Genesis video game console, which was being ripped apart by Nintendo’s juggernaut the SNES. Sadly, it didn’t do so well and quickly evaporated from store shelves. Despite the poor reception, it’s still has a birthday, so make sure you play your favorite title tonight. It shouldn’t be too hard to pick one, given the limited selection of good titles for that platform. It’s probably for the best that we don’t mention the Sega CD either… well, despite my obvious misgivings about the system, I know it is near and dear to a more than a few people. So Sega fans, on this happy day, I salute you!

The Nintendo DS needs no introduction, since many of you have an incarnation of that device sitting in your house right now. With over 149 million units sold worldwide, I think it could be considered a success. Let’s do a little math, shall we?

149,000,000 x $150 + (149,000,000 x (6 * $40)) = $58,110,000,000

That’s an average cost of $150 dollars per unit, and each unit having an average of 6 games which sell for an average of $40 each. Let’s assume that 70% of that amount went to pay for everything from manufacturing, to licensing, to marketing and employee salaries. We’re still talking close to $20 billion in the clear.

So Nintendo Corporation, while you sit upon your mountain of money contemplating this special day, we the bottom dwellers of society raise our filthy hands in a formal salute!

Great site for TG-16 reviews!

Check out this site:

He does a great job of reviewing titles. The videos are both information and entertaining to watch. This should definitely be parked under your review site of choice for TG-16 / Duo, and Super CD games.

Super Snapshot V5 and 64HDD

November 12, 2011

Just a note to say that 64HDD and the version of BASIC stored on the Super Snapshot V5 do not play well together. It should also be noted that my host machine is a 2.4 GHz CPU running DOS with no EMM386 drivers loaded; I am also not running the latest version of 64HDD. The symptom I was experiencing had to do with trying to load a D64 image, or more specifically trying to execute the following command:

LOAD “*”, 10, 1

The 64HDD software would beep a couple of times, and then the C64 would simply hang. It most likely has nothing to do with the specific command and everything to do with the timing between the virtualized drive and the C64 machine. Unfortunately, I cannot tell you where exactly the problem lies in either, since I am unable to debug the problem any further.

Thomson-Davis Editor (TDE)

November 6, 2011

TDE - PE of ChoiceThe Thomson-Davis Editor, or TDE, was the first programmer’s editor to ever grace my hard drive. A programmer’s editor (PE) can be somewhat different than a typical text editor used for typing up README files or other user-level documents. A good PE will usually have a large assortment of features which makes the job of editing source code a little easier. Ironically, these editors can be some of the most obtuse software installed on a desktop system. To use them effectively, you must memorize several obscure key combinations and commands. Once committed to memory, these commands can be very powerful, allowing you to perform several complex editing or searching operations.

As an aside, the usability goals for an editor within an IDE such as Borland C++, seem to be the exact opposite for the goals set out by the authors of many PEs. The editing within IDE is almost universally easy to use, while performing the same tasks within a PE requires practice and certain degree of research. Approaching this from the viewpoint of a novice looking into the dark world of a seasoned, and perhaps a little cynical UNIX-computer programmer, it would seem a little odd since the interface of an IDE can do so many different tasks (and thus have so many opportunities to botch things up), whereas a PE tends to be targeted to one task: editing source code. Surely, with fewer features, it must be easier to craft something which is even easier? It’s almost as if the author of a PE is trying to compensate for lack of development features by throwing in additional editing complexity. For example, how many standard forms of regular expression syntax does your PE support? If you answered anything other than “as many as I want since I can simply write a plug-in to support it,” then you’re not using the right editor.

I stumbled across TDE while browsing the download area for a local BBS. It included the source code for the program which was written in C, and it seemed to have a variety of interesting features; it certainly had more technical features than the QuickC editor I was using at the time. I guess I gravitated towards complexity at the time, and I quickly grew to love TDE and began modifying the source code to suit my needs. If I were to use the latest version of TDE today, I’m betting a lot of those hacked-in features would already be implemented.

The code for TDE was a great learning experience for me. It was organized fairly well so it made for relatively easy modifications and creative hacks. I lost the source code for my modified version during The Great Hard-drive Crash in the mid-1990’s. For some odd reason, I didn’t have a single back-up. It was particularly strange since most of my favourite projects were copied onto a floppy disk at some point. Frustratingly, I think I still have a working copy of the original 3.X code on disk! Anyway, the source code had excellent implementation details like fancy text and syntax handling, decorated windows, and reasonably tidy data structures. I don’t remember using any code from the editor in any future project, but I certainly took away a number of ideas. Doublely-linked lists may not seem like a big deal to me now, but I hadn’t read that many books at this point, so glimpses of real implementations using these data structures was very cool and inspiring. I found the windowing classes and structures particularly interesting since some of the windows were used for configuration, others for editing, and some for help. This was the first abstraction for a windowing system within an application I had run across. It was beautiful and gave me a lot of ideas for HoundDog – a future project which was used to track the contents of recordable media like floppies and CD-ROMs, so that I could find that one file or project quickly without needing to use those floppy labels.

The QuickBASIC and the 0xDEAD

November 2, 2011

QuickBASIC is very similar to QBasic since the latter is just a stripped down version of the former. It had a few functions QBasic did not have — such as the ability to compile programs and libraries, allowed for more than one module, and could create programs which were larger in size. It also had this annoying bug where the memory management model in the interpreter was different than the one used by the compiler; this was a problem when your program worked in the debugger, which used the interpreter, but not when the program was actually compiled and run from the shell.

QBasic shipped with MS-DOS 5 and consisted of only an interpreter, meaning it translated small chunks of code into machine code as they were executed (I believe it did cache the translated portions, so it wouldn’t need to translate them again). QuickBASIC was more advanced and had a compiler as well as an interpreter, which allowed it to translate and optimize the machine code it generated before you ran it. It had only one dependency during compilation, and that was the QB.LIB library. Using the QuickBASIC IDE or the command line, you could compile multiple modules into a single target which could be a library or an executable program.

QuickBASIC was handy for prototyping and demos. I didn’t need to do many of these for my own projects; although, I did a lot of experimentation with network interrupts before porting those routines and programs to C. QuickBASIC was mainly used for projects and demos at school and eventually college; many of them were also written in C due to a few course requirements.

While in college, I had written a chat application over a local area network for DOS before the concept became popular. It was using the SPX protocol for some parts, and the IPX protocol for others. It only supported peer-to-peer communication and only with one other person, bit it served as a demo for simple network communication, and many of the students used it quite regularly.

In other programs, I was using Novell Netware interrupts for communication, broadcasts and client machine discovery. I loved it and found coding these applications fun and exciting; my Ralph Brown textbook was well used during this time. I think my interest in programming these network applications stemmed from my days playing DOOM over similar networks. Basically, I just loved lot the potential for interactivity, which is a tad ironic since I was fairly quiet programmer back then. A few of my friends became interested in the software I was writing and one day we decided to play a few practical jokes on my fellow students. We created a custom program for sending messages via the Netware API. These messages could be broadcast to every machine on the network, a group of machines, or a specific machine. When a machine received one of these messages, it would display a dialog and show the user a message. Pretty simple concept, but many people were not aware their machines could even do that, or what it meant to even be on a network.

Simply using the network software which came with Netware wasn’t an option, since the message dialogs produced by those tools contained the name or address of the machine from which the message originated. According to Steve Wozniak, co-founder of Apple Computers and well-known prankster, the most important element to any gag is not to get caught. We needed to customize the message being sent so that it included only the details we wanted to send, and the only way to do that was to write a custom program. This was fairly easy since I had been writing software on Netware for several months, and when the packets were sent off through the network, our machine name was carefully omitted and our address forged.

We used the program to send funny or confusing messages to some of the students. No profanity or crude humour, mind you… well nothing too crude anyway. My goal was always to get the user to believe what the machine was telling them. I had convinced one student her computer didn’t like the way she typed; her keystrokes were always too hard or fast for the computer’s liking. She had actually phoned the administrator’s office and asked them for a computer which didn’t complain so much! Several computers were being used by students to view pornography, so I did my best to make them feel uncomfortable in a public setting. Many of them believed they were being watched by the network administrators, which could have been true (although network monitoring software was generally never used or not available). Anyway, these people quickly shuffled out of the room red-faced, hoping not to get caught on there way out. I still get a giggle out of it even now, when I think about it.

In a way, I am kind of saddened by the complexity of today’s operating systems. Trying to write the same software on modern machines would be extraordinarily more difficult today, mostly because of new operating system features and application stacks. They just aren’t managed in the same way anymore, so a programmer’s ability to exploit a network so directly has disappeared. That being said, I don’t particularly disapprove, it’s just not as easy to have a little fun.

64 KBs Should Be Enough for Anyone

Montezuma's RevengeIf you’ve tried playing a few games on an actual Atari 800 XL computer, or through APE or AspeQt and you end up with garbage on your screen, or perhaps the game or application is behaving weirdly, try disabling the BASIC ROM from creeping into the Atari’s address space. By default, the Atari will copy BASIC from ROM into RAM, which in turn will consume a certain amount of memory (around 8 KB), which is located at the address $A000 and runs until $BFFF. The Atari doesn’t have memory protection mechanisms; if a program overwrites that location, the OS will not tell you about it.

If the program you are trying to load uses most of the Atari’s 64 KB of memory, then will get memory overwrites at certain address locations. This in turn will likely cause corruption of the program and may lead to crashes, asset corruption, and other oddities. To prevent BASIC from being copied into RAM, press and hold the OPTION key during the boot process.