Fonts! (plus nattering about maps and magnifying glasses)

One of the more popular Wintertree products, back in the good old days, was a package of fonts called Arcane Alphabets. It was a collection of interesting fonts for gamers — mostly interesting alphabets like Ugaritic cunieform, hieroglyphs, and FUTHARK runes, plus really odd stuff like the secret script of the Vehmgericht. People did some fun things with them; I remember one convention where the organizers used the Ogham font as an “alien” sort of font along the bottom edges of the badges, which looked really cool. (that was a college convention unfortunately scheduled the same weekend as the school’s Homecoming … mostly, we vendors sold stuff to each other) I did some other fonts, too — a pack called Mapographer that would let you draw adventure maps in your word processor (how dated is that?) and the only licensed product I ever did, the dwarf fonts from Games Workshop’s Warhammer books. That one never sold very well; I remember writing out a royalty check to send to GW and it was like $5.

So what do fonts have to do with Wintertree Redux?

Continue reading “Fonts! (plus nattering about maps and magnifying glasses)”

Verbs? Nouns?

There are a lot of things about TableMaster that are dated, some of them painfully so. Some are things that I have to deal with as a programmer, such as the fact that TableMaster used to be two programs, not one, and there are some housekeeping issues raised as a result. (I was just dealing with one involving closing all open table files for .INCLUDE this morning) Some are matters of style and appearance; I’ve kept many of those for the sake of continuity and tradition, though the UI does look less Win3.1-ish than it used to. Some are simple practicality, such as my decision to continue using an .INI file (just like in the old days) instead of the Registry, so that TableMaster will be fully portable. But there is one that seems both quaint and, well, weird.

Continue reading “Verbs? Nouns?”

Historical Natterings

I’m looking at the source code for the original GENERATE. The file of subroutines was, according to my comments, originally written for Turbo Pascal 6.0. Talk about a blast from the past! (for those of y’all who are staring blankly at your screens right now, I’m talking about this) I looked it up, and got a real burst of nostalgia from the picture of the box. I think it’s the kind of nostalgia we have for all the things we did the hard way decades ago, though — nice to reminisce about, but not fun to do that way ever again.

I upgraded to Borland Pascal 7.0 before the first release version. I just looked that one up, too. I remember that box very well. That big, cubic, shelf-eating box, stuffed to the top with manuals. According to the site I just looked it up on, there were 11 of them. Sounds right. I probably still have them in a box somewhere; I firmly believe that everything is in a box somewhere, probably in my attic. The scary thing, if you’re trying to find anything in my attic, is that I’m most likely right.

Aaah, nostalgia. Memory allocation on the heap. The whole table structure hanging from one variable, just waiting to become the memory leak from hell. Yeah, I don’t miss it one bit.

My old code has one very important thing, though: the listing of all the TBL keywords and their synonyms. That’s going to save me some typing.  And, in between the moments where I wonder “what was I thinking?” (or even worse, just “was I thinking?”) as I look at my old code, I find a few clever bits. Ima steal those from myself. 🙂

Also, looking at that old code reminded me of how much tidier it was back in the day when one’s compiler didn’t go sticking the event handler for a UI button click or something right in the middle of the lot. Also how much easier it was to find what I was working on. There are now include files. 🙂

Also, I’ve figured out what the first new table pack is going to be. I’d better get TableMaster running so I can start writing tables! 🙂

Same past, different blast

Here’s another scan from the box:

Old Packaging Cover

It’s the outsides of the packaging for TableMaster Deluxe — the pack that had TM/Win and all four table packs on a CD in it (the regular versions were on floppies). The cover was a color copy, so some of it has suffered a bit over the years for the same reason the catalog did — copier toner just doesn’t do well in 140-degree attics — but back in the day, it was pretty cool.

There’s a bigger picture after the jump.

Continue reading “Same past, different blast”

A blast from the past

I have a box in my lap full of old TableMaster stuff! I’ve got the manuals from versions 2 and 3, one of the TM Deluxe packages, and various other things. The TM Deluxe package contains, among other things, my Winter 1998 catalog. It’s half a page, admittedly, more like a price list (all of 11 items if you’re being generous and counting the DOS, Win3.1, and Win95 versions of TM separately). It’s been in a hot attic and it was originally photocopied, so the toner stuck to other pages, and they stuck to it, over the past 18 years. Thankfully the manuals and quickref card were offset printed, so they’ve endured intact.

I’ll put in a break here and put the scan after the break, so it doesn’t fill up the whole first page.

Continue reading “A blast from the past”

First baby steps toward Generate

Well, I still haven’t quite recovered from the weekend trip to another time zone and the seasonal time change (organized, clearly, by people who think cutting a piece off one end of their blanket and sewing it on to the other will make it longer) at once, so I haven’t been quite up to par coding-wise today. But I did get one important thing done: the first bit of framework for what will become the TableMaster table engine. I can call it from the main program now (even though it doesn’t do much) and put the data where it needs to go. Now it’s just about writing code. Or, more correctly, re-writing the code I wrote over 20 years ago, better.

Continue reading “First baby steps toward Generate”

So what IS TableMaster anyhow?

I’ve lived so close to TableMaster for so long — its earliest incarnation dates to the 1980s, and a Sinclair QL — that it’s easy for me to forget that not everyone actually knows what it is I’m going on about.

The way I usually explain it: any random generation table in a game is actually a program meant to execute on a system of humans and dice; TableMaster makes it possible to set it up to run on a computer instead. And moreover, you can go far beyond anything that a game would provide, because the computer can do in seconds what it would take you an hour of dice-rolling and note-taking to produce.

Since this whole description is obviously going to be rather useful, I’ve moved it over to a page (you can find it here) so that people won’t have to search through all the posts to find it.

Good to go…

The GUI isn’t feature-complete yet — it still needs the table editor and the dice roll setting dialog — but it can run tables now. At least, it could if the table engine existed. So that’s the next step: writing (or re-writing) what used to be GENERATE, and of course is now going to be a part of one integrated program.

I’ll probably take a bit of a break this weekend (I have to catch up on some of the “real life” stuff) and then it’s on to the real guts of TableMaster.

Watch this space!

Light at the end of the tunnel

I’ve been partially, but not completely, black-boxing the development of the TableMaster GUI.

Here’s what it looks like right now:

Current Screenshot

Some things never change. There was one thing I’m doing that I couldn’t figure out a really elegant way to do; the only solution seemed to be brute force and awkwardness. So I broke down and looked at my old code to see how I’d done it back then. Yeah. Same way.

Continue reading “Light at the end of the tunnel”

Menus and popups and options, oh my!

Wow … I’d forgotten that I had so many popup menus in there. Right-click menus were kind of a new thing at the time and I kind of went nuts with them.

My design philosophy for the TableMaster GUI, which hasn’t changed, is that it should be up to the user, not to me, exactly how they want to do something. So for any given function, there would be multiple ways to do it: from the main menu, a popup menu, clicking a button, with a hotkey … pretty much any way you thought you might be able to do something, you could. This made for a very useful UI for the user, but a bit of a hairball for the programmer.

The fun (ha!) part at this point is that about a week before I decided to go ahead with the TableMaster project, I got a new computer desk. It’s really an awesome drop-front desk that I found in a cluttered antique shop and fixed up a bit, with little pigeonholes and things and even an almost-secret drawer, but putting it in place necessitated moving several shelving units, building a new bookcase, and disrupting, well, pretty much everything. So my old CD backup of the TM/Win source (which modern Delphi would probably choke on, but at least I could look at what I’d done) is down there … somewhere.

Given a few of the things I’ve found, though — for instance, I’d completely forgotten that I had a built-in table editor with some fairly interesting features, though now I remember it and remember that I wanted to take that farther than I ever did (envisioning something like the Delphi IDE for table writing, which might have been, um, overkill? just a little?) –maybe I should stop coding and start digging.

So here’s another question for the hypothetical readers I imagine I have: Did you ever actually use the TM/Win table editor? Or did you just use Notepad? Is there a reason for me to put that in the first release? In a later release? Never?