[Setup]
; NOTE: The value of AppId uniquely identifies this application.
; Do not use the same AppId value in installers for other applications.
; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
AppId={{8B6CE104-25D3-40E8-8681-F2B7DA29E855}
AppName=Forgotten Times
AppVersion=1.1
;AppVerName=Forgotten Times 1.1
AppPublisher=Morriss, William S.
AppPublisherURL=http://www.example.com/
AppSupportURL=http://www.example.com/
AppUpdatesURL=http://www.example.com/
DefaultDirName={pf}\Forgotten Times
DefaultGroupName=Forgotten Times
AllowNoIcons=yes
OutputBaseFilename=setup
SetupIconFile=C:\FT2\Forgotten Times\res\GameEngine.ico
Compression=lzma
SolidCompression=yes

[Languages]
Name: “english”; MessagesFile: “compiler:Default.isl”

[Tasks]
Name: “desktopicon”; Description: “{cm:CreateDesktopIcon}”; GroupDescription: “{cm:AdditionalIcons}”; Flags: unchecked
Name: “quicklaunchicon”; Description: “{cm:CreateQuickLaunchIcon}”; GroupDescription: “{cm:AdditionalIcons}”; Flags: unchecked; OnlyBelowVersion: 0,6.1

; Set the source to your root directory
[Files]
Source: “C:\FT\Forgotten Times\GameEngine.exe”; DestDir: “{app}”; Flags: ignoreversion
Source: “C:\FT\Forgotten Times\*”; DestDir: “{app}”; Flags: ignoreversion recursesubdirs createallsubdirs
; NOTE: Don’t use “Flags: ignoreversion” on any shared system files

; For these icons, to get them to work with your GameEngine.exe you must set ‘WorkingDir:’ to ‘{app}’ because it creates
; local files
[Icons]
Name: “{group}\Forgotten Times”; Filename: “{app}\GameEngine.exe”; WorkingDir: {app}
Name: “{group}\{cm:UninstallProgram,Forgotten Times}”; Filename: “{uninstallexe}”; WorkingDir: {app}
Name: “{commondesktop}\Forgotten Times”; Filename: “{app}\GameEngine.exe”; Tasks: desktopicon; WorkingDir: {app}
Name: “{userappdata}\Microsoft\Internet Explorer\Quick Launch\Forgotten Times”; Filename: “{app}\GameEngine.exe”; Tasks: quicklaunchicon; WorkingDir: {app}

[Run]
Filename: “{app}\GameEngine.exe”; Description: “{cm:LaunchProgram,Forgotten Times}”; Flags: nowait postinstall skipifsilent

However, all things come to an end, and my current hiatus is no exception. I got a shiny new laptop, and used to it pull together a good deal of the town of Ramu in Forgotten Times 2.

Obviously, that isn’t what happened.

Apparently, I didn’t actually finish it back in law school. I got it mostly finished back in law school. I’d say it was 98% finished. However, trying to squeeze out that last 2% reminded me of just how much work goes into these things.

Happily though, thanks in large part to my very patient wife who played through it 5-10 times as she found bugs and I fixed them, we worked out all the obvious kinks, made a couple of significant upgrades to the interface, and got it all done. Now, I just have to pull the rest of the submission package together and everything will be ready to ship well before the October 1 deadline.

So, was the time I spent (and, in general, the resources spent on lawyers who write software licenses) worth it? I think so. While I don’t care if people give away copies of my games, I would be more than a little annoyed if someone made a changed version and distributed it, or started selling them without my permission. By making explicit what rights I’m granting and withholding, I lay the groundwork for giving effect to my goals down the road. The same principle applies to commercial products as well. By making clear what actions are and aren’t authorized at the outset, a company can set itself up so that if it ever has to enforce its rights, it can do so at a relatively minimal cost. Even better, if rights and restrictions are clear, there’s less chance of a conflict that could lead to expensive litigation ever taking place.

char* CClassicRPGDoc::levelLocationID(int which_level)
{

int counter;
if(which_level > 0)
{
for(counter = 1; counter <= which_level; counter++)
{
strcpy(center_location_ID, locations[center_location_index].getTop().getLocationID());
center_location_index = getLocationIndex(center_location_ID);
}
}
if(which_level = which_level; counter–)
{
strcpy(center_location_ID, locations[center_location_index].getBase().getLocationID());
center_location_index = getLocationIndex(center_location_ID);
}
}
if(which_level != 0)
{
ASSERT(true);
}
strcpy(retval, center_location_ID);
return retval;
};

The above function is used in the display of multi-level buildings and was causing me no end of grief. For some reason, instead of returning what I expected (i.e., the ID of the specified floor of a building) it was consistently returning the ID of the floor (i.e., the one the character was in). Even worse, its behavior changed when I ran it through the debugger, and when I traced the values of the variables all the way to the end of the function, they looked the way they were supposed to.

The problem, of course, was the statement in bold text. While the retval[] string had the right value all the way to the end of the function, once the function exited, the memory that string had occupied was deallocated. As a result, rather than passing back the string I intended, I was passing back a memory location which, by that time, was being used for something else (apparently for storing the ID of the current floor, though I have no idea why). Very annoying.

While there are a number of ways to solve the problem (including reworking the logic so that the problem didn’t come up in the first place), I chose the one that was easiest for me, and made retval[] a static variable. Not the most artful way of doing it, but, since static variables are maintained between function calls, it did the job. The final results are that the last upload of Forgotten Times II has a reasonably functional implementation of multi-story building display, and that I’ve learned to avoid writing functions to return local arrays.

It’s strange, but people generally seem to overlook the kind of effort I’ve been putting in over the last few months when they think of programming. When I was in law school telling a girl I knew about my efforts to put together a coherent plot for Forgotten Times 1, she remarked that she’d never thought about programming being about plot, rather than about essentially mathematical problem solving. The same sort of thing happened when I told a friend of mine here in Cincinnati about my programs – to get some sense of them, he asked to measure the number of source lines of code I had written in the engines, and completely ignored the data files.

I suppose it’s not that different from thinking of authors on the Internet as “content providers.” However, I still think it’s a mistake. Since I started writing games, judging the program by focusing on the basic mechanics has begun to seem something like judging a fine wine by looking at the bottle. True, the bottle can tell you something (e.g., where the wine came from, year, etc) but it’s what someone put into it that really makes it special.

Unsurprisingly, that caused no end of heartache which in the end was resolved with a tremendously ugly (but functional) solution – I duplicated the data I needed as global data. At some point, I’ll rationalize things so that I don’t have duplicate data stored as globals and as private members of the document class. At this point though, I’m just happy that I got things working.

The problem with the above approach is that windows shortcuts use absolute locations, and every location is different depending on the name of the user account it’s running under. As an example, if my user name is “Sid” (which, on this computer, it is), then the path name for any file located on my desktop will start with “C:\Documents and Settings\Sid\Desktop\”. Because of this, whenever the zipped distribution folder was downloaded onto a new machine, the shortcut would try and look for the data files the executable needs to run in the location they were stored on the original machine (e.g., “C:\Documents and Settings\Sid\Desktop\FT\Files”) rather than their location after the download (e.g., C:\Documents and Settings\Your Name\Desktop\FT\Files”). The result, predictably, was that the executable would enter an infinite loop, forlornly looking for the data files in a location that simply didn’t exist in its new host environment. Very sad.

Anyway, I ended up deciding to solve this problem by making a wink program demonstrating for a user how to find the executables, and make a new shortcut on their own machines. It isn’t the most elegant solution, but it should get over the fact that I have no real way of knowing what the relevant user names will be on the machines where my programs are downloaded. Someday, I may end up writing a full install script. However, for now, wink it shall be.

Anyway, at this point the first pass at content for the site is up. Next, I want to do some work on the interface, then test everything out, and it’ll be ready to go live.

Now, if I’d been thinking about performance optimization when I originally wrote the game, I would have done something marginally clever, like have a calculation thread constantly running the background, enumerating away, rather than waiting till it’s the computer’s turn to start thinking. I could also have done something like add a timer on the computer’s thinking, and forced it to make a move after it had been enumerating for some set period (e.g., 30 seconds). That second one would actually go hand-in-hand with a third optimization that I didn’t implement: I could have written the code to save intermediate results, rather than only saving the results once the enumeration’s finished (the current approach).

So there are all sorts of optimizations I could implement to help clean up the mess from when I originally wrote it. Alternatively, I could just remove the user’s ability to start the game with an arbitrarily large number of sticks (thereby making sure the game is only played with the smaller numbers where the lack of optimization isn’t a problem). As it happens, in my relatively old age, I have found that there’s another optimization that is more important than the ones I described above: minimizing my own time expenditure. Given that, what will actually happen is that I’m going to remove the functionality that’s causing the problems, and leave the task of optimizing for another day.