Recreating the VM.

For those unfamiliar with the concept, VM is short for Virtual Machine, and the core of The Sims consists of a VM named Edith, which is constantly running the code inside objects (sims are also objects with their own programs for Edith to run).

Now, in TSO, the VM is less important because you only control one sim at a time, but you can still turn on free will to have your sim be autonomous.

The task of recreating Edith is so massive and all-encompassing  that it is hard to imagine where to start, but after quite a bit of research and cooperation with NIOTSO, I’ve decided to start by writing a basic parser for SimAntics (the language that Edith programs are written in) that translates it into a human-readable form. After that, the next step will be to design an interface so that SimAntics programs can easily call functions defined in the Project Dollhouse executable. If all goes well, after a certain amount of time I should have a VM built in C# that can load *.iff files in realtime and run their programs synchronously and display state changes on the screen. The Sims is basically just a graphical representation of such a machine.

Once you’ve grabbed the latest version of the repository, you should download and install Visual Studio C# Express Edition 2008 from here.

Next you’ll need to download and install XNA Gamestudio 3.1, then Lua for Windows, as well as Bass.NET. You can now open TSOClient.sln from trunk\TSOClient\ and compile the client. To compile an application in Visual Studio, simply press F5.

However, the client won’t run unless you have copied the Lua scripts to their appropriate directories. So for now, just press F5 to build the client. This will create a folder called bin in trunk\TSOClient\TSOClient\ with a folder called Debug inside.

The compiled client will be in the Debug folder. You need to create a folder called gamedata inside of Debug, and then copy all the three folders inside trunk\TSOClient\LuaScripts\ to this new folder. Lastly, copy NAudio.dll from trunk\TSOClient\TSOClient\ to trunk\TSOClient\TSOClient\bin\Debug\

When you’ve done this, you can open up Visual Studio again (if you closed it) and press F6 to compile and debug the client. Now the client should run without any errors, providing you have installed TSO on your PC.

If you can’t see that clearly, it is a maid’s body with the arms straight down and the legs tucked above the head. I’m not sure why the legs are like that, but undoubtedly it has something to do with the skeleton. Anyways, what’s important is that I’m nearly there!

Long live Project Dollhouse!

Think about that for a minute. Between 0.01 and 1.00 you can at the least put 9 incremental updates. And if each update takes  6 months to make, that equals out to 4.5 years. Now as far as I know, there is currently only one developer working on Corsix-TH, and hopefully more developers will join as the project matures. That’s my hope for this project as well, but at least these figures should put things into perspective.

I’m still trying to figure out why the root bone is located away from the rest of the skeleton and why the upper arms are above the head, and the lower arms are way down. Other than that, everything seems to be correct.

One, called “patch.php”, is the most important. It sends the right manifest(s) to a client based on what version is passed to it.

<?php

/*The contents of this file are subject to the Mozilla Public License Version 1.1
(the "License"); you may not use this file except in compliance with the
License. You may obtain a copy of the License at http://www.mozilla.org/MPL/

Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
the specific language governing rights and limitations under the License.

The Original Code is patch.php.

The Initial Developer of the Original Code is
Mats 'Afr0' Vederhus. All Rights Reserved.

Contributor(s): ______________________________________.
*/

include 'createzip.php';

if(isset($_GET['Version']))
{
	$ClientVersion = intval(htmlspecialchars($_GET['Version']));
	$NewManifest = "";

	if($handle = opendir(realpath('./patches/')))
	{
		//Find out if there are any manifests newer than the client's version.
		while (false !== ($entry = readdir($handle)))
		{
        		if(intval(str_replace('.manifest', '', $entry)) > $ClientVersion)
			{
				$NewManifest = realpath('./patches') . '/' . $entry . '.manifest';
				break;
			}
		}

		if(empty($NewManifest) || strcmp($NewManifest, realpath('./patches')) == 0)
		{
			header('Content-Description: No New Manifest');
			header('Content-Type: text/html; charset=utf-8');
			echo('<html><body><p>No new manifest!</p></body></html>');
		}
		else
		{
			//Open the new manifest and check if it has a child, which means an
			//incremental update needs to take place...
			$FileHandle = fopen($NewManifest, 'r');

			$Parent = fgets($FileHandle);
			$CurrentChild = fgets($FileHandle);
			$Path = realpath('./patches');

			$Parent = str_replace('Parent=', '', $Parent);
			$Parent = str_replace('"', '', $Parent);
			$Parent = trim($Parent);
			$CurrentChild = str_replace('Child=', '', $CurrentChild);
			$CurrentChild = str_replace('"', '', $CurrentChild);
			$CurrentChild = trim($CurrentChild);

			fclose($FileHandle);

			//This is a compromise. Instead of checking for all childs, just check for the first one,
			//and let the client handle the other children (if any).
			if(empty($CurrentChild) !== true && empty($Parent) !== true)
			{
				$Parent = $Path . '/' . $Parent;
				$CurrentChild = $Path . '/' . $CurrentChild;

				$FilesToZip = array($CurrentChild, $NewManifest);
				$ZipName = './' . strval(rand()) . '.zip';
				create_zip($FilesToZip, $ZipName);

				//Client should check the Content-Description header to figure out what to expect.
				header('Content-Description: Zipped File Transfer');
    				header('Content-Type: application/octet-stream');
    				header('Content-Disposition: attachment; filename='.basename($ZipName));
    				header('Content-Transfer-Encoding: binary');
    				header('Expires: 0');
    				header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
    				header('Pragma: public');
    				header('Content-Length: ' . filesize($ZipName));
    				ob_clean();
    				flush();
    				readfile($ZipName);

				unlink($ZipName);
				exit();
			}
			//There was a child, but no parent.
			else if(empty($CurrentChild) !== true && empty($Parent) == true)
			{
				$CurrentChild = $Path . '/' . $CurrentChild;

				$FilesToZip = array($CurrentChild, $NewManifest);
				$ZipName = './' . strval(rand()) . '.zip';
				create_zip($FilesToZip, $ZipName);

				//Client should check the Content-Description header to figure out what to expect.
				header('Content-Description: Zipped File Transfer');
    				header('Content-Type: application/octet-stream');
    				header('Content-Disposition: attachment; filename='.basename($ZipName));
    				header('Content-Transfer-Encoding: binary');
    				header('Expires: 0');
    				header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
    				header('Pragma: public');
    				header('Content-Length: ' . filesize($ZipName));
    				ob_clean();
    				flush();
    				readfile($ZipName);

				unlink($ZipName);
				exit();
			}
			//There was a parent, but no child.
			else if(empty($Parent) !== true && empty($CurrentChild) == true)
			{
				$Parent = $Path . '/' . $Parent;

				$FilesToZip = array($Parent, $NewManifest);
				$ZipName = './' . strval(rand()) . '.zip';
				create_zip($FilesToZip, $ZipName);

				//Client should check the Content-Description header to figure out what to expect.
				header('Content-Description: Zipped File Transfer');
    				header('Content-Type: application/octet-stream');
    				header('Content-Disposition: attachment; filename='.basename($ZipName));
    				header('Content-Transfer-Encoding: binary');
    				header('Expires: 0');
    				header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
    				header('Pragma: public');
    				header('Content-Length: ' . filesize($ZipName));
    				ob_clean();
    				flush();
    				readfile($ZipName);

				unlink($ZipName);
				exit();
			}
			//There was neither a parent nor a child. This should really never occur.
			else
			{
				header('Content-Description: File Transfer');
    				header('Content-Type: application/octet-stream');
    				header('Content-Disposition: attachment; filename='.basename($NewManifest));
    				header('Content-Transfer-Encoding: binary');
    				header('Expires: 0');
    				header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
    				header('Pragma: public');
    				header('Content-Length: ' . filesize($NewManifest));
    				ob_clean();
    				flush();
    				readfile($NewManifest);

				exit();
			}
		}
	}
}
else
{
	header('Content-Description: Invalid Request');
	header('Content-Type: text/html; charset=utf-8');
	echo('<html><body><p>Invalid request!</p></body></html>');
}
?>

This code depends on another script I found while rummaging through Google:

<?php
//From: http://davidwalsh.name/create-zip-php
function create_zip($files = array(),$destination = '',$overwrite = false) {
  //if the zip file already exists and overwrite is false, return false
  if(file_exists($destination) && !$overwrite) { return false; }
  //vars
  $valid_files = array();
  //if files were passed in...
  if(is_array($files)) {
    //cycle through each file
    foreach($files as $file) {
      //make sure the file exists
      if(file_exists($file)) {
        $valid_files[] = $file;
      }
    }
  }
  //if we have good files...
  if(count($valid_files)) {
    //create the archive
    $zip = new ZipArchive();
    if($zip->open($destination,$overwrite ? ZIPARCHIVE::OVERWRITE : ZIPARCHIVE::CREATE) !== true) {
      return false;
    }
    //add the files
    foreach($valid_files as $file) {
      $zip->addFile($file,$file);
    }
    //debug
    //echo 'The zip archive contains ',$zip->numFiles,' files with a status of ',$zip->status;

    //close the zip -- done!
    $zip->close();

    //check to make sure the file exists
    return file_exists($destination);
  }
  else
  {
    return false;
  }
}
?>

The ‘patch.php’ script can be utilized by clients as such;

http://www.webserver.com/patch.php?Version=ClientVersion

Lastly there’s the ‘getmanifest.php’ script which simply retrieves a specific manifest;

<?php
/*The contents of this file are subject to the Mozilla Public License Version 1.1
(the "License"); you may not use this file except in compliance with the
License. You may obtain a copy of the License at http://www.mozilla.org/MPL/

Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
the specific language governing rights and limitations under the License.

The Original Code is getmanifest.php.

The Initial Developer of the Original Code is
Mats 'Afr0' Vederhus. All Rights Reserved.

Contributor(s): ______________________________________.
*/

if(isset($_GET['Manifest']))
{
	$RequestedManifest = htmlspecialchars($_GET['Manifest']);
	$FoundManifest = "";

	if($handle = opendir('./patches/'))
	{
		//Find the requested manifest...
		while (false !== ($entry = readdir($handle)))
		{
        		if($entry === $RequestedManifest)
			{
				$FoundManifest = './patches/' . $entry;
				break;
			}
		}

		if(empty($FoundManifest) || strcmp($FoundManifest, './patches') == 0)
		{
			header('Content-Description: Invalid Request');
			header('Content-Type: text/html; charset=utf-8');
			echo('<html><body><p>No manifest by that name exists!</p></body></html>');
		}
		else
		{
			header('Content-Description: File Transfer');
    			header('Content-Type: application/octet-stream');
    			header('Content-Disposition: attachment; filename='.basename($FoundManifest));
    			header('Content-Transfer-Encoding: binary');
    			header('Expires: 0');
    			header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
    			header('Pragma: public');
    			header('Content-Length: ' . filesize($FoundManifest));
    			ob_clean();
    			flush();
    			readfile($FoundManifest);

			exit();
		}
	}
}
else
{
	header('Content-Description: Invalid Request');
	header('Content-Type: text/html; charset=utf-8');
	echo('<html><body><p>Invalid request!</p></body></html>');
}
?>

It can be utilized as such;

http://www.webserver.com/getmanifest.php?Manifest=ManifestVersion.manifest

I also created a tool for generating these manifests. The important thing, however, is that the two first lines of a manifest are stored as plain ASCII strings so they can be read by ‘patch.php’. Aside from that, manifests can look however you want them to.
Here’s a sample manifest generated by Manifestation;

The added MD5s after filenames are checksums that can be used by clients to verify file integrity.
If you’re looking for a general-purpose way to patch your game(s), I hope I’ve given you some food for thought!

Unfortunately, the FTP-protocol is extremely badly documented (aside from the documents available from IETF, which are extremely terse, contains unneeded bloat and are generally just downright bad). I’ve been able to make my way up to and including the LIST and/or MLSD command (the MLSD being a newer extension command), but when trying to transfer the data containing the directory listing for the root directory, FileZilla never acknowledges that the data was received! Instead it times out and decides that there was a problem receiving the directory listing.

So, I’ve been thinking, would it make sense to just switch to HTTP for transferring patches to clients? It is starting to look extremely tempting. Arguably, I could code my way around the FTP-protocol by introducing non-standard protocol “extensions”, but that would defeat the purpose of using FTP in the first place (namely that it’s a pre-designed filetransfer protocol).

I don’t know if I’ll have the time tomorrow (I should study), but one of these days I’m going to install a copy of Apache on my box and see about making my patch client communicate with it.

So far I’ve been thinking of two possible solutions for a directory structure on the server:

• Dumping a manifest  and all files into the root folder. This would have the downside of making it near-impossible to do incremental updates, unless the manifest contained information about which files belonged to which update.
• Have a manifest in the root folder that points to different versions contained in separate directories. This seems like the best way to go, as it would enable incremental updates without making the manifest needlessly complex.

Once I’ve been able to write some basic HTTP code for the patch client, I’ll make another post with pictures of the client to inform of the progress.

3D head being rendered in the client

As you can see, there’s still stuff to figure out, such as correct rotation and placement in 2D space. There’s also the issue of selecting the right mesh when the corresponding button is pressed, which is currently a little off. But the rendering is in place, and that’s the important thing for now.

Please forgive if things aren’t looking “up to scratch” at the moment, as I am still tweaking the setup to make the website just the way I want it.