Sunday, September 27, 2009

Release Candidate

I'm happy to announce that there is a release candidate :)

The goal is to check that the download binaries work (that is, to check if I didn't forget some DLL, asset file, etc.), and also to check for any major bugs that I missed.

To try the release candidate, do the following:
  1. Download it:

    Ubuntu 9.04:

    For Ubuntu 9.04 you also need to get some deps, with a simple

    sudo apt-get install libsdl1.2debian libsdl-image1.2 libsdl-mixer1.2 python libboost-python1.35.0 zlib1g

    Note that the Ubuntu 9.04 version probably will NOT work on other Ubuntu versions (except *K*ubuntu 9.04, etc.) or other Linuxes - you would need to compile from source so it links correctly against your distro's libraries. Compiling from source is actually very easy on Linux, see instructions on and of course feel free to ask for help (here or on IRC, #intensityengine or #syntensity on FreeNode).

  2. Unpack the download and run intensity_client.bat (Windows) or (Linux).

  3. You also need to sign up for a user account, for the release candidate you should do that here:

  4. Aside from that, instructions for how to do stuff (log in, join a game, etc.) are on the wiki, in particular you should read

Note that I am announcing the release candidate here, and not on the main website, because I don't want too many people to try it (since there might be a problem with the binaries) - I'm just looking for a small amount of feedback on the release candidate for now. Then if all is well with the release candidate, the release itself can be in a few days. So, until the release, please don't tell anybody about the release candidate, I'd rather their first impression be of the actual release (which will have an announcement on the main website, new video and screenshots, etc. etc.).

Thanks in advance for testing the release candidate!

Tuesday, September 22, 2009


In this post I'll clarify some things regarding licensing.

First of all, there are two separate topics here: Licensing for the Intensity Engine and for Syntensity. The Intensity Engine is an open source project, while Syntensity is one particular project built using the Intensity Engine (that happens to be run by the same team).

Regarding the Intensity Engine, it uses the AGPL license. I recently elaborated a little more on the website about this, mainly that game content is not considered a derivative work. That is, if you write a game using the API, the game does not need to be AGPL licensed. It's yours and you can license it however you want. Only if you modify the engine itself, as opposed to creating a game using it, does the AGPL license become an issue. It's pretty much how Blender licensing works - make something with Blender and license it however you want; modify Blender itself, and you need to be GPL licensed.

Regarding Syntensity, my original idea was to require that all content be under a creative commons license or something similar, since I see Syntensity as closely related to the participatory culture movement (but in the context of gaming). By requiring such licensing, all the content on Syntensity would be free for use, in Syntensity and elsewhere. But it turned out that wasn't workable - not everyone is willing to use the same license (some artists insist on -NC licenses, for example). So by picking any one license, it would leave a lot of people out. And by picking several incompatible ones, there would be a lot of confusion. So in the end Syntensity will use the most minimalistic and generic licensing for user-created content: Whatever you create in Syntensity is yours, to do with as you want, but you grant everyone a license to use it freely within Syntensity. So how you let your content be used outside of Syntensity is entirely up to you (and you can completely disallow such use), while inside Syntensity we uphold the idea of everyone working together to create more and better games.

(If granting a license to people to use your content within Syntensity is a problem, then don't upload that content into Syntensity - use the Intensity Engine by yourself to run your content however you want, and with whatever license you want. It's open source, and that's what it's for.)

Intensity Engine 0.9.8

I just tagged version 0.9.8 of the engine, which might end up as our release candidate. Changes include:
  • An apparent fix for the big, worrying bug
  • Smoother camera movement (even in mouselook mode)
  • Flag model (4 colors)
  • Some optional, for-future-use API features (action keys, server teleport)
  • Various tool improvements (texture converter & packager, mass texture replacer, etc.)
  • Various bug fixes

Thursday, September 17, 2009

Intensity Engine API Documentation

A first version of documentation for the scripting API - the API you write games/activities in, also known as "the API" ;) - has been uploaded to docs/. You can see it here. It has a 'hello world' example, a tutorial, and a few big examples of actual working code (a plugin, an activity, etc.) with detailed explanations. This should be enough for people to get started with scripting.

We don't expect to have complete documentation in time for the launch, but with this document and the work-in-progress wiki, we should have enough for now. (The source code itself also has comments, particularly in the important places, and the example games and activities are helpful as well.)

EDIT: We moved to github meanwhile, the latest docs are here:

Monday, September 14, 2009

Sketch World Demo

I had some spare time today, so I made a simple 'Sketch World' activity:

You can see the code here. What's nice is that this takes only 165 lines of script, and that includes full multiplayer support (everybody has their own color to draw with, sees everyone else's drawings, etc.).

Sunday, September 13, 2009

Intensity Engine 0.9.7

Another engine version, hopefully the last before the launch. Changes include:
  • Unreliable state variables (useful for rapid updates)
  • History-less state variables (useful for event messages)
  • JSON state variables
  • Upgrade to latest V8 trunk, which allows normal building on 64-bit systems (and should be faster)
  • Automatically comment out irrelevant logging code in scripts (very significant speed improvement, given the extensive logging code)
  • Much faster network protocol for asset info querying, when there are many relevant assets
  • Use .js scripts for models instead of sauer-style cfg files
  • Libraries for game modes (including CTF), guns/firing, health, etc.
  • Autogeneration of tedious parts of V8 bindings code, with new automatic validation tests
  • Script commands to combine images and decompress JPEG 2000 images
  • Various tools, for texture configs, image conversion, release packaging, etc.
  • Various bug fixes
No additional features are intended before the launch, just bug fixes. (The launch is still planned for the end of this month.)

Tuesday, September 1, 2009

Full Circle

Just about a year ago, I started to adapt the Cube 2 (Sauerbraten) engine into the Intensity Engine, a generic gaming/virtual worlds platform - something that can run all sorts of 3D environments, and not just games like insta ctf (which, for any non-gamers reading this, means "instagib capture-the-flag", or "one shot you're dead, capture the other team's flag and bring it back to your base"), etc. This involved a lot of work, among other things removing game-specific code and creating an API that lets scripts take the place of that code. In other words, where Sauerbraten has C++ code for insta ctf, the Intensity Engine has only an API, that lets JavaScript code implement all sorts of 3D 'activities', just one of which might be insta ctf (and others of which might not even be games).

Syntensity, however, is focused on games (at least for the near future), and it will launch with insta ctf as its main gameplay mode. So, over the last 4 days I wrote an insta ctf 'activity' for the Intensity Engine entirely from scratch. This ended up taking about 650 lines of code, split up into several components:
  • GameManager: Keeps score, assigns players to teams, and in general manages the game. Plugins for the GameManager let you control things like what determines when the game is over (a high enough score, for example).
  • Health: A plugin for the player class that adds a 'health' attribute ('state variable' in Intensity Engine terminology) to players, and manages player death and respawning.
  • Firing: Handles guns and their behavior (including delays after firing, etc.). A SniperRifle example gun gives the 'insta' gameplay element - one shot and you're dead.
  • CTF: A plugin for the GameManager that handles the flags and their behavior.
By using a component model, the code ends up being very extensible: The 'insta' element is entirely contained in the SniperRifle class, and the 'ctf' element in the CTF plugin. These could easily be swapped out with other plugins to get new gameplay modes.

(All the code is already in the repo, if anyone wants to take a look.)

So, after eliminating all the hardcoded insta ctf stuff in Sauerbraten, we have come full circle to implementing an insta ctf game mode, but this time written in JavaScript, and it's just one example of an activity which the Intensity Engine can run. Amusingly, insta ctf in Sauerbraten and in the Intensity Engine look quite similar from the outside (well, they would if we used the same models), but the internals are entirely different.