The Tutti "Emulator": A Tomy Tutor Simulator

Tutti has a successor

Warning: The original Tutti is now unsupported

To fill the void, I threw together the original Tutti simulator in 1998. Rather than emulate the hardware, which at the time I didn't fully understand, it simply tried to act like a Tutor as much as possible -- a simpler undertaking at least at that time. Though it was very limited and only supported the title screen, menu and a small taste of BASIC, it was enough to give non-users a feel for the system. It was well received and eventually went through versions 0.2, 0.2a and (in 2003, the last major update) 0.3. It was written for the Commodore 64 because that's where my skills lay, and also because by writing a version anyone could run under a Commodore emulator, it could be run on any system with a Commodore emulator available (and that meant a lot of computers, not just Winblows, er, Windows). Although it was not a complete simulation in any sense of the word, by 0.3 it supported token portions of GRAPHIC mode, GBASIC, BASIC and the MONitor, and allowed basic elemental operations in all of them.

Tutti's major problem was that the system had to be arduously reverse engineered to filter out all the quirks of its programming, and eventually this became dreadfully inefficient and increasingly difficult for me to put together. As the basics were established, the ability for me to update in a timely fashion got weaker and weaker. Moreover, by this point, other more skillful hackers were looking at the Tomy hardware and determined to come up with their own emulators themselves.

In May 2003 Ian Gledhill released a sluggish but functioning SDL-based emulator for Windows, which although glacially slow, was the first real Tomy Tutor emulator and finally brought cross-computing to the Tutor world. Raphael Nabet eventually released his own driver for the MESS multi-system emulator in version 0.70 based on his own work with the Texas Instruments MESS drivers and his research into the operation of the CLA. I tested this driver out while he was working on it, and it seems to work not only efficiently, but authentically.

For this reason, I have decided to discontinue maintaining Tutti and leave it frozen forever at version 0.3, as most people will not want to bother with it. However, I will leave it available for those architectures that can emulate a Commodore 64 but do not have a MESS port (of which there are a few, though this is dropping as MESS reaches more and more systems). Also, because Tutti does not require ROMs to operate, it is the only emulator or simulator that can be fully legally operated by someone who does not own a Tomy Tutor already.

On the other hand, I will consider resuming work on it if there is interest in my doing so, especially since I was hoping to expand the Tutor interface to allow cross-development and importing Commodore image files, as well as fix a few bugs in the system without impacting compatibility. Also, a modified form of Tutti may emerge to emulate the Pyuuta series as to date the MESS driver is not known to support the Pyuuta Jr. or the original Pyuuta. If this is something you think you would like to see, please let me know at ckaiser@floodgap.com.

The below section is the Tutti instruction and "FAQ" page, more or less the same from its final version (0.3), along with screenshots and downloading instructions. Obviously, it is no longer the only simulator or emulator, but most of the rest is current. I leave it more or less as is. Have fun. -- Cameron Kaiser

Tutti (which stands for TUTor Tiny Implementation) is ... wait for it ... the world's only attempt to even simulate the Tomy Tutor. And as the author, I can tell you, bar none, it really sucks and it probably won't get a whole lot better. But hey, for all you emulator phr33aks out there, this is the best it gets. At least you'll be able to play with something that's 20% of one, right? And you'll be able to tell all your friends about it, who will have no idea what the sam heck you're talking about.

Okay, enough self-deprecation. On with the information ...

Current version

• The big news: GBASIC is now officially supported in Tutti, and is fully accessible from the MONitor. It isn't finished yet -- there is no interpreter, and everything but lines like 99 END generates an entry error -- but the screen editor is just about finished and all the little quirks are emulated (like flashing the sprites on every line, the scrolling, etc.) Since we now have an almost exhaustive GBASIC reference, you can count on GBASIC continuing to evolve (see the FAQ question on GBASIC below).
• The MONitor correctly responds to four-letter keywords, like the real machine (e.g. GBAS for GBASIC, BASI for BASIC, GRAP for GRAPHIC mode, etc.).
• A reset key is available (press SHIFT-MON [SHIFT-F1] in the menu or from the Tutor brag screen). This is a debugging feature.
• Tutti now deals with SuperCPU Commodore systems correctly (knock on wood).
• The keyboard emulation subsystem has been overhauled; to wit:
  • SHIFT and alpha lock co-exist correctly, so that SHIFT-lower case gives upper case, and SHIFT-upper case is just upper case.
  • There are now audio cues for the state of the alpha lock (see the instructions section), and the alpha lock correctly resets in the menu.
  • All the characters available on the Tutor's keyboard are now fully available on the C64's. You can now type brackets and braces, as well as the underscore, the carat, the 'degree' (perhaps a 'handaku' character?) and the flat sign (see the instructions section for which keys to use).
  • Alpha lock (Commodore-key) used to get disabled after leaving GRAPHIC mode, but that's now fixed.
• The input-a-line library routine has been totally rewritten to correctly allow proper line editing and parsing. Cursor-left and cursor-right are unrestricted, just like the real thing. The 'keybeep' in GBASIC and the MONitor has been made asychronous which should make them a bit more responsive. Buffering and cursor display have been tuned up, and proper cursor bounding has been implemented. Unfortunately, long logical lines (i.e. greater than one physical screen line) are still not yet supported in BASIC.
• A large number of graphics glitches have been corrected: the mildly unstable rasters in GRAPHIC mode have been cleaned up and are much less flickery; various flash bugs are cleaned up; the cursor is much more stable; and Commodore-SHIFT no longer garbles the menu display after quitting GRAPHIC mode.
• Multiple behavioural inaccuracies have been smoked out and repaired.

• What does it run on?

A Commodore 64 and disk drive.

• Oh my gosh, are you nuts?

Certifiably.

• Why a Commodore? Why not a PC?

Several reasons. A big one is portability: if I just wrote this on a PeeCee, it would only ever run on PeeCees and people on Macs (like me), and Amigas, and RiscOS boxes, and Unix boxen, and whatever, wouldn't be able to join in the fun. The advantage is that by writing this on a Commodore 64, not only will it be able to run on a venerable and still widely-supported classic system, but it will also run anywhere a Commodore emulator is available (i.e., just about any modern OS and quite a few older ones).

Most importantly, however, my programming skills on PCs suck and the Commodore 64 is just easier and a lot more fun to program. So there.

If you don't have a Commodore, then get an emulator (I recommend Frodo, since it's fast, free and fully compatible, and absurdly portable: it runs on many Unix flavours, Win95/Win98/WinNT, EPOC, Mac, Amiga, RISC/OS and BeOS; coming soon for PocketPC and Zaurus) and emulate Tutti on the emulator. Ironic, eh?

You can download Frodo from The Official Frodo Home Page.

• Does it need ROMs?

No. See the next question.

• What does it support?

Right now, not too much. Tutti simulates the 9995, and doesn't emulate it (i.e. the ROMs are reverse-engineered and run native on the 6510 -- the 6510 isn't emulating a 9995 running the Tomy ROMs), which means that it's a matter of coding a program that acts like a Tomy rather than a program that acts like the hardware. Hence a simulator, more than an emulator, and that's why you don't need to dump ROMs or, more likely, leech a pirated copy from Dave's Classics Gnutella KaZaa. That's what you were going to do, weren't you? Don't lie.

The hardware that is truly emulated is the sound and video circuitry. The 64's SID sound chip is more than up to the task of doing the sound, and the VIC-II vid chip manages character graphics just fine. However, the VIC-II requires some hellish raster work to emulate 256x192x16 graphics. First, the Tomy 9918ANL has a different palette, and second, it can use 2 colours per 8x1 cell unlike the VIC-II which is limited to 2 per 8x8. The palette multiplexer works (it's flickery but it does the job), but the second, while possible, requires so much CPU overhead to track the raster that the stock 64 may not be up to the task of doing that *and* giving the user snappy response in the paint box. The palette multiplexer is solely in "tinker" phase and isn't in the current version, and probably won't be in the next either. Tutti's overworked IRQ subsystem has enough to worry about without that.

Tape is emulated by the disk drive, if I ever reverse-engineer enough of the Tomy OS to the point where it can save and load things.

BASIC is supported and one of these days will be finished, but right now supports so few keywords as to be largely useful only for getting error messages, and does not support programmatic execution at all currently.

Graphics mode is also supported, along with sprites. However, because of the resolution constraints, you can't actually draw anything yet (though you can move the cursor around and make it look like you're doing something).

The MONitor is supported as of 0.2a.

GBASIC is supported as of 0.3, and the GBASIC screen editor is just about finished, but it doesn't support much more than that yet (everything except the END keyword generates an entry error). You can still play around in it though.

• Why is the aspect ratio so squished?

The Commodore vid chip generates a 320x200 display plus the border; the 9918ANL generates a 256x192 display that, at least on my 1702, goes into the border of the screen. So, I draw the 256x192 screen in the middle 256 pixels of the regular Commodore 320x200 view; this is useful because the overscan can be simulated on the 64 by just showing it the leftover 32 pixels on other side, but since Tutti is effectively drawing a 256x192 screen on a 320x200-plus canvas, it's going to be very horizonally shrunk. The screenshots here have been corrected for this.

• What doesn't it support?

It does not currently support drawing pictures (because of the resolution issue) or drawing or moving sprites; it also does yet not fully support GBASIC or BASIC; and you can't use cartridges or cartridge ROM dumps with it.

• Will you ever support cartridges at all?

No, because Tutti doesn't emulate the 9995, so it can't run the object code. Never fear, because since I like the games so much, I might port them to the 64 anyway separately of Tutti.

• Will you ever support BASIC fully?

Eventually. 'Till then, you're limited to direct mode execution of selected commands (in this version, MENU NEW CLS SCREEN()).

Note that because the SCELL() hack for getting into the Tomy OS depends on oddiments of the Tutor's internal memory organisation, undocumented tricks like that will probaby never be supported. Mercifully, this little backdoor is just about unheard-of in Tutor programs except around Wizard Kludgefinders (tip of the hat to James Host).

• Will you ever support graphics mode fully?

Yes, to some degree. The internal paint box will probably be fully, or at least largely supported, when I figure out the raster issue. Even if I don't support actually *drawing* pictures in GRAPHIC mode, I do plan to support allowing you to draw images in Doodle!, for example, and import them into GRAPHIC mode. Sprite editing will eventually be supported since there are no raster issues impeding that.

• Will you ever support the MONitor and GBASIC fully?

Definitely. Virtually all the GBASIC keywords are now known and tested, and their behaviours are well-defined, so we finally have the exhaustive (?) resource we need to create a working simulation. Again, because of internal differences between the C64's and the Tutor's graphics architecture, certain tricks such as using CELL workspace for transferring colour and bit pattern data may not work correctly on the C64, but all officially documented behaviour will one day work (granted not much is officially documented ;-). Most importantly, Tutti's GBASIC will also have some of the bugs fixed (including the notorious crash-on-undefined-statement bug), but bugs in keyword interpretation will be preserved so that the emulator doesn't improperly accept programs that won't run on a real Tutor.

Likewise, since the MONitor is now well-documented, its functions will be supported fully as well (they're not that complicated anyway).

Currently supported commands are in the Programming section.

• If you're having so much trouble writing this on a stock 64, why not do it on a SuperCPU?

Because I refuse to write an SCPU-only application. (This is for the Commodore 64 programmers in the audience who know to what I'm referring.)

• Can I load and save graphics, sprites or programs in Tutti?

Not yet (since you can't *create* graphics, sprites or programs ;-), but you will be able to save and load in the future. The format will be Tutti-specific, however, although I will hopefully have documentation on the format. At least this way you can exchange programs for the emulator on-line and load them into your real C64 or your emulated Commodore to run in Tutti, but be advised this approach will not support Tutor-format tape files even if you have a tape recorder or Datasette.

• Will Tutti ever be able to read native Tomy programs?

Cartridge games and software, never, because the CPU isn't emulated (see the specific question about cartridges, and what Tutti supports).

As for cassette tape, maybe one day, but right now it can't because I don't know how to read a Tomy-format cassette. However, a GBASIC or BASIC program may be portable if it's downloaded to a binary dump file that the Commodore can pick up; how you actually *get* the binary and dump it to disk isn't my problem, but as we have since spied on the Tutor BASIC code and learned what the tokens are, there is some hope for at least a conversion process. (We're not that far along with GBASIC yet.)

The issue, though, is getting Tutti BASIC to the point where it simulates all the instructions on the original machine. This is no mean feat, especially since Tomy didn't lose any sleep on technical documentation.

• Then why do I want it if it's so limited?

If you're a casual emulator d00d, you're in the wrong place. This emulator doesn't play any games, and the only games it may ever play are those you write yourself. Leave now. You don't want this. Ask for ROMs on comp.emulators.cbm so I can flame you.

However, if you're a TI freak or interested in what the machine could do or just finding out what it is, this may be your only chance, since you probably won't ever see a Tutor except at a swap meet in Paducah. And it's so bad that I'll perpetually leave it as freeware.

Running it

Just LOAD it and RUN it like a BASIC program.

Important keys

• The Commodore key acts as alpha lock. When you press alpha lock, an audio tone will sound: a low tone if alpha lock is now 'down' (default; upper case only), or a high tone if alpha lock is now 'up' (lower case, and upper case with SHIFT). The menu resets the alpha lock back to 'down' (the default), just like a real Tutor.
• There are several characters on the Tomy Tutor keyboard that the Commodore doesn't have keys for. For the curly brackets, use SHIFT-[plus] and SHIFT-[minus]. For the "flat" character, use SHIFT-@. For the underscore, use <- (the backarrow key at the top left). For the carat, use the up-arrow (next to @). For the degree sign (or maybe it's a 'handaku' symbol), use the English pound sign.
• INST/DEL is ignored. Remember, the Tomy doesn't have a backspace!
• F1 is MON and F7 is MOD. Use MOD to step through graphic modes, and MON to enable the MONitor (only in graphics mode 4 -- press MOD three times from when you first enter GRAPHIC mode to get there).
• Either at the Tutor brag screen or in the menu (this is a debugging feature of the emulator), press SHIFT-MON to reset the emulator back to the Tutti title screen.

In BASIC, type MENU

In graphics mode, get into graphic mode 4 (press MOD three times), and press MON for the MONitor. Then type MENU. If you got into the MONitor but want to stay in graphics mode, type GRAPHIC.

In GBASIC, exit with a line like 99 END, and then type MENU at the MONitor prompt.

Bug reports

These bugs are known, but since Tutti won't be updated further, they won't be fixed. Regardless, send any comments if you like to ckaiser@floodgap.com. Please note that the emulation has always been incomplete. Thanks!

• The screen editor in BASIC won't let you enter long lines or edit entered lines.
• The colours aren't quite right.

Screenshots

Also, since the VIC-II is not patched in this version, the colours are only approximations of the true palette and are not wholly accurate.