swixel dot net

couchdbkit authentication

Tue, 29 May 2012 08:02:00 +1000

I couldn’t find out how you’re meant to make couchdbkit authenticate against couchdb (for those of us who need to auth for production reasons). Anyway, here’s my solution using nothing but the deps (restkit is a dep of couchdbkit ;)) …

"""
Copyright (c) 2012 A.W. 'swixel'/'aws' Stanley.
Released under the MIT Licence or public domain (whatever you're allowed).
"""
# CouchDBKit
import couchdbkit

# RestKit
from restkit import BasicAuth

# Trivial "convert settings to couchdb database instance"
# (Could be split into two parts if you wanted, but I use one DB per app)
def ConnectToCouchDB(uri="http://127.0.0.1:5984/", database="testdb", username=None, password=None, design_docs="design_docs"):
	# Authenticate
	if(username != None and password != None):
		CouchDBAuth = couchdbkit.resource.CouchdbResource(filters=[BasicAuth(username, password)])
		CouchDBServer = couchdbkit.Server(uri, resource_instance=CouchDBAuth)
	else: 
		CouchDBServer = couchdbkit.Server(uri)

	# Get or create database
	try:
		CouchDB = CouchDBServer.get_db(database)
		CouchDB.info()
	except couchdbkit.exceptions.ResourceNotFound:
		# I let 'Unauthorized' be thrown here, you could catch it, but my 500 error does that ;)
		CouchDB = CouchDBServer.create_db(database)
		CouchDB.info()
		
		# Install views
		loader = couchdbkit.loaders.FileSystemDocsLoader(design_docs)
		loader.sync(CouchDB, verbose=False)

	return CouchDB

Optimising embedded Python: xrange vs range, and file

Fri, 27 Apr 2012 12:59:50 +1000

A number of video games at the moment are using Python as their scripting engine. It bothers me a bit that so many of them are ‘fast’, and at the same time, use uncompiled code for things they shouldn’t.

One large company is using range. It’s Python 2.6. xrange is an iterator, meaning it’s equivalent to a C for loop (i.e. i++ for the index). range is not, it creates a value for each entry in the range (‘start’ through ‘stop’). xrange is fast, xrange uses less RAM, I’m not sure I need to say much more. It’s on the Python website. Here, have some references: [1] [2].

The second major gripe I have, which was discussed in a few IRC channels in the last week (Gamesurge and Freenode hosted ones, but not #python), is there was some a pretty shocking attempt we found reversing a game’s binary format. When we got the Python code out of it, it wasn’t bytecode, it was raw text. More importantly, it stored a filename value at the time, and then used __file__. The reason the interpreter got upset was that it tried to use a full path for comparison and if anyone moved the files to a non-standard directory (as many of us do), things went south. By the time we got a patch which removed this joke of a gamebreaking error, we’d already found it, so I thought I’d share that and anyone who suddenly found themselves able to play it in the last week or so, now you know what happened. (No, it wasn’t an indie game.)

Finally, don’t break the argc and argv values. We shouldn’t be using them, but there are better ways to inject data into your interpreter to load new paths. Either feed them argc and argv from your main function, or leave them blank. Throwing random junk in is just weird.

The other option is to write real code. It may be slower than using Python, or Lua, or Javascript, but you have the satisfaction of knowing it’ll be harder to reverse, will almost certainly run faster, and will prevent people from modding parts of games in which you don’t want us poking around. Sure, you could actually think it through and use Lua or Python to inject tables of data (I do this in most of my little tools), marshal the data into lists (or something niftier like a std::vector or a std::map) and write sane code.

Abusing CouchDB for research purposes

Mon, 02 Apr 2012 10:01:57 +1000

Twitter research is something I thought I had overcome; something of the past, a relic of times and thoughts less well processed than those I like to think I have now. Apparently not.

What is unfortunate about social media (at least from my research perspective) is the amount of easy to access, contextually ‘fixed’, data, lowering the number of variables required for analysis. What is fortunate, is, well, what I just said.

To manage what I’m told is a ridiculous corpus, I built a CouchDB. Last time, I took Tweets, reordered their JSON data so _id replaced the id field, then dumped everything except the user data into the database. This was a HUGE amount of data. And I mean huge. It took me three months to load a 12.5% of all tweets in the May 2010 into a database, and used hundreds of GB of data for views. It was nasty.

This time, I stripped everything except the IDs (user + status), the targets (user + status), text, timezone (text form), and UTC offset (which, is more important, but the timezone is pretty). I didn’t keep the retweet field, as it’s missing in some, and not within the scope of what I care about. The result is 531,159,273 tweets loaded in 3 days. The views will take days, if not weeks (if not MONTHS) to build, but I’m limiting what I need, and starting with stale views to get preliminary findings.

Why CouchDB? Indexes, json to json, and the capability to not flip out on me when I do insane things.

The disk array is nothing flash: 4x2TB 5400rpm SATA-II disks running in RAID 10, attached using a round-robin configured dual gigabit NICs (PCI-E). This is managed by Core2Duo 4400 (2GHz per core), with 4GB of RAM. The box holding them does nothing but NFS share to the box running it.

The box running CouchDB is where I really cheat and move away from “commodity”: a Sun Fire X4600 M2 (so 8x dual core Opterons at 2.8GHz per core, with 32GB of RAM, and RAID1 10k rpm SAS drives). Not since moving from CouchDB 0.6 have I come close to using more than 400% (4 cores for those less than familiar with Linux), and the disk i/o is holding — Python appears to be my slow point.

The real problem is that the insertions happen too quickly that the views freak out and CouchDB goes down due to RAM usage issues if I try to update while I insert … but other than that, it’s perfect.

As usual, my loading script is a multiprocessing Python hackjob. I’d move it to C/++, but by the time I rewrote a socket proc-to-proc linking system, master+slave daemon configuration, the Python code would be done … and it’s not like I’m doing anything too far outside of what is already C modules for Python.

My own little world of JavaScript.

Tue, 13 Mar 2012 11:17:21 +1100

My parents bought a Philips Pronto remote control. A TSU9600, to be precise. They also bought an extender — an RFX9600. The protocol it uses is largely unknown to me at this time, but wireshark and a little bit of port mirroring and that shouldn’t be a problem.

The Philips remote runs on a variant of Javascript (prontoscript). Yes, the entire thing is written in what is effectively synchronous javascript.

Enter the Samsung Televisions they have. Interestingly, both of these can have apps written for them in Javascript. This time it isn’t something akin to, it is JS.

Finally, enter their mobiles — Samsungs, both. Now, while Android applications can be written in Javascript (ugh), they have decent browsers, and with the power of jQuery and a box on the network, we have another avenue of Javascript glory.

Enter node.js. Now, I’m ordinarily a Python hacker, or even C++, and, on occasion, an Erlang newbie. However, as node.js is as close to the twisted of javascript I’ve ever seen, I thought I’d give it a whirl. A week or so later, I’m playing with express.js and finding it not entirely irksome.

My idea, at present, is to setup some sort of gateway which takes Pronto commands as if it’s an extender, running as a relay. Using asynchronous calls I can push data to the target device (or extender). This will require some reversing, but should (hopefully) enable a few more homebrew solutions to problems, not to mention ways around lag on the remote itself. My current aim is to reply my old squeezebox javascript blob with something that runs on a server —- passing JSON back and forth, asking the remote to do a non-blocking sleep while waiting for updates on the node.js instance.

I’ve achieved something similar with cherrpy and sockets (in Python), but JS<->JS<->JS should be more fun. Anyway, the project gets fun after that —- hooking up the TV to music controls in the room it’s in…

Introducing: TrendyNode

Wed, 29 Feb 2012 10:20:06 +1100

What I have is a single javascript file, hinged on the use of nodejs.

It stores player information as JSON.

What it can do perfectly:

Let the player “Load” data;
Rotate the saves on save request.

What it can do well enough to work:

Authenticate;
The heartbeat;
Begin the save request.

What it present fails to do:

Save the data — requires additional reversing.

What it will never do:

Circumvent VAC;
Replace TrendyNet (this is for LAN use with achievements on).

Authentication is largely a mystery, but I have a workaround in mind if I cannot work out how part of the auth function works — IP restrictions based on Steam’s OpenID (for the internet) or using IP restrictions on LAN (SteamID still applies here, once logged in, it’s locked until an admin resets it, or 24 hours pass).

I’m also mishandling authentication data at the moment — mostly because I developed this on a ‘system-by-system’ setup, restricted to localhost usage.

If anyone has questions/comments, let me know … it’s not like this system is complex, though the binary is seriously annoying due to the use of std::basic_string.

Dungeon Defenders Servers: Steam and TrendyNet

Mon, 13 Feb 2012 11:19:00 +1100

Generally, I’d hold this back, but having received an infraction for being blunt, and a bit of abuse through member emails, I figured I’d be a little more blunt. Some points:

First: Trendy doesn’t let you use any tools to modify your game.

Second: Trendy apparently actively bans users.

Third: Wireshark is free and lets you look at insecure traffic.

Fourth: Objdump is awesome ; failing that dumpbin will do.

Five: ‘cloudapp.net’ is owned by Microsoft for Azure.

Things you can find out knowing these points:

Steam is used for matchmaking (try: dumpbin /imports:steam_api.dll DunDefGame.exe);
TrendyNet is hosted on Azure, and uses HTTP traffic (not even HTTPS);
TrendyNet hosts all save data, Steam does not;
Saves are not feasible using either Trendy or Steam, the way you could script one is quite simple, but to prevent abuse, it’s not sane;
Apparently suggesting an eight year old with Wireshark can detect Steam, and a ten year old could detect (and reverse) the HTTP used for TrendyNet is insulting (note the fairly trivial introduction video to wireshark, and that there are more). Update: I got an 8 year old to prove me right…

Yes, I have my own TrendyNet backend and decoupled my legitimate install from Steam, without once modifying the game binary …

Brief update: No, I won’t be giving away my own TE backend code at this time. It was an experiment I did for research purposes, so I could better help people having issues, not something to be done to enable hacking. That said, given the average reaction to things, and my assumption of an average level of intelligence/understanding/knowledge, I’m pretty much done with that.

Update: As a note, this is Phase #1.

Dear AMD ...

Sun, 22 Jan 2012 22:17:22 +1100

Dear AMD,

You have APUs which are, quite frankly, neat. They make consoles look terrible, and you could easily push an AMD64/x86 console out every 2 years at a retail price of $1000 (AUD, not USD). You could make a platform which developers could actually target, hook into distribution platforms (like Steam) to do your handy work, throw in an OEM copy of Windows 7, something basic like “MS Security Essentials” for the anti-viral load, keep keyboard/mouse flexibility, but restrict the hardware.

The end result would be games on a platform which isn’t hopelessly outdated in 6 months, but a platform which is accessible and developers could be reasonably expected to support and target. Throw in some sort of neat little sticker programme: “Certified for the AMD Console MK IV”, and you have yourself a winner.

What would the internals look like? A laptop — just add cooling, some glowing bits, and the ability to interface with a TV (oh wait, HDMI does this for you).

Regards,

A nerd (who is sick of bad game ports and shoddy code).

Scripting languages and Interpreters

Fri, 18 Nov 2011 08:24:19 +1100

Recently I’ve been taken with the distinction between scripting languages and their interpreters. Some are fluid, adaptive, and enable all sorts of magic and trickery that I particularly enjoy abusing. On the other hand, there are the rigid kind, which usually feature explicit casting.

I should stop reading compiler design books, but this sort of stuff is just amazing. It’s a bit beyond what I usually like doing, but I can see applications …

Modding and people

Tue, 04 Oct 2011 18:09:31 +1100

Invariably, people don’t appear to understand the effort taken to modify a game, unless of course they are the ones doing it, or have a similar (or better) level of understanding.

Various games bring about people who irk me, but more often than not those who might appear to be culprits of it aren’t, and those who drape themselves in a cloak of understanding often don’t. This reversal is probably more infuriating than anything else because the subjects are either long-time franchise fans or computer scientists, who assume that because it’s the ideal model that it’ll work (or worse, they don’t understand the commercial forces which drives the choices, even though they’ve studied that too).

I could draw a line in the sand between myself and these people, but in so doing I would be cutting myself off the community as a whole, and I would be modding for nobody but myself (which, frankly, would make it much easier).

Tropico 4 isn’t necessarily one of the worse communities, but there is certainly a level of entitlement which rivals Team Fortress 2. The problem with entitlement is that players believe that the publisher or a modder should add/fix/remove something because they think it fits within the scope of the game. Were it necessary, the developer would either add it or possibly DLC it (see maps in the COD franchise).

I’m not saying that everyone out there with their hand out is an idiot, or that they need to have a deep understanding of the game, but many of the complaints aren’t well thought through.

Aside from modding, you then have the people who make you wonder about humanity. Those who have tried everything but removing anti-viral programmes, insisting that an application designed to peer and interfere with other applications couldn’t possibly be causing that fatal cross-thread deadlock that plagues every game on the same engine. You’ve got the people who didn’t read the box/site/page/forum/billboard/poster which screams that their system is inadequate for the game they’re about to buy.

You then have the additional “know-it-alls”, and I don’t mean those who are part way through the code trying to unravel the magic (read: people like me), but the people that rave about X, Y and Z, features, being dead wrong about one or more of the things. Supplemented from time to time with those who want to know every secret to “perfect” their experience and get the best score (why would we give that away?).

To top it off, you have people complaining on various forums about delays and “unhelpful” staff on forums/lists, without registering that maybe, just maybe, there is a reason they’re not giving away the secrets of the game or that they aren’t responsible for the delay but under contract can’t make a comment about the delay.

Finally, there are the people who are trying to be helpful, and correct things that weren’t wrong in the first place. Anachronism has no place in video games, save, perhaps, to demonstrate the path from which the franchise or system has grown. Want features from that game? Go play it. The incremented number at the end of the title says one thing to you: this isn’t the game you’re talking about, it’s a new one. Yes, it looks the same, speaks the same language to you, and probably does many things in the same way. The differences in the game are not that big, I hear them complain, saying that a new game wasn’t worth it. Apparently the difference between your frontal lobe and that of a low-tier primate aren’t either.

Entitlement is the sum of everything wrong with the gaming industry. While you may have a product to move, you can’t bow to people completely or you end up with a fan base expectant on your compliance. (This post is, of course, to say nothing of the people who want “modkits” for engines — but if you want to read it that way, go to the beginning and start with that in mind, it probably works equally as well.)

Tropico 3 and Tropico 4

Wed, 14 Sep 2011 11:56:31 +1000

I’ve now broken both’s file formats. I worked out what Snake did, and I’ve got a semi-functional way to reading the data now.

Bring on the mods.

First step: Injecting a duplicate of the farm that grows gold.

Deus Ex: Human Revolution

Sun, 28 Aug 2011 14:16:41 +1000

Deus Ex: Human Revolution is the best game ever.

I do not care that I am an RTS player, or that I generally hate FPS games, the combination of storyline, mechanics, and gameplay make this the best game I have ever played. The graphics are shiny too, but I didn’t really take that into consideration (never do).

And it's MinGW time...

Fri, 29 Jul 2011 15:07:58 +1000

As all of my code is crossplatform, driven by OpenGL (usually SFML), and uses crossplatform libraries, I thought it high time I stop using VS C++ Express Edition. As such, I’m slowly porting my significant code to use boost (where possible) and be compiled with MinGW. To achieve this I will need to get a nice crossplatform suite setup, probably in a virtualbox.

To do this, I need to compile crossplatform versions of:

SFML (1.6 - trivial);
LibRocket (git version - seems to be trivial);
Freetype (for SFML and LibRocket - should be trivial on Linux XPlatform);
Boost (1.47.0 - because I might as well update);
Python (2.7.2 - so it runs off local 2.x installs for Linux testing);
ZeroMQ (oh noes, the unmentioned variable!).

That’s all that comes to mind for now… oh, and throwing together makefiles for crossplatform magic.

Of course this requires a Debian base install, some magic, and some patience… but for now it’s nice to be able to port things, ssh in multiple times, use screen, suspend dev neatly on the drive, and actually access tools I’m used to using… not to mention setting things up in funky ways.

Hatters will hat.

Mon, 11 Jul 2011 07:48:38 +1000

Alternatively, “hatters are gonna hat”.

You read it here first. Or not. I don’t care either way.

AGPLv3 Ext/Plugin on the way for SourceMod

Thu, 30 Jun 2011 13:22:20 +1000

Disclaimer

I’ll start with the following disclaimer: I am not a lawyer, nor am I pretending to be one. The following post does not constitute, simulate, emulate, or in any way (including the aforementioned) pretend to be legal advice. This is simply my understanding of how my licencing choice affects users.

Backstory

I’m going to release a stable and fast modification for a couple of games … I’m going to release it under the AGPLv3, bearing in mind that I can run it on my own server under GPLv3, thus not sharing my own modifications until stable (or until I feel like it).

I’m told that such an action is open hypocrisy — I’m forcing others to share with others, but keeping my own changesets. Bear in mind that if I take an AGPLv3 changeset into my ‘core’ branch, that I can no longer run my own server’s extension under GPLv3, and will then need to share my own code. Of course, if the idea/notion/whatever already exists, or I have test code which is under the GPL, or may obtain code that is, I don’t need to share it — only if the person who owns the code won’t contribute it as GPLv3, which they can’t, because it needs to be AGPLv3.

What does this mean?

This means that by writing my extension, the include file, and the sample plugin under the AGPLv3 all users of the extension will be required to share their source with anyone who can access the server in such a manner that the extension is relevant to the user’s interactions. This means that if, by way of example, you cannot get past the login page (i.e. cannot pass the ‘password’ stage), you do not have the right to request the plugin source. There are ways around this (as usual), but it’s really a case by case basis.

If you want to release a derivative or extension plugin from my core, or any other derivation of it, you must release it as AGPLv3. There are no exceptions. The only person who can release a GPLv3 version (i.e. not share the source with users on request) is me, and only provided that I do not accept contributions on the AGPLv3 code.

To resolve any potential conflicts, I will maintain my ‘core’ branch, which is solely my work. I will also maintain a ‘community’ branch, on which I will accept contributions from people in the community. My ‘core’ branch is open to suggestsions and requests (which, unless coded by someone else, maintains my right to use it in GPLv3).

Where is your server?

Simply put, I don’t have one, and honestly have no intention of running one. However, if I do run one (say, temporarily off a VPS or a dedicated server I maintain), I want to have the ability to playtest potential features which will be applied to the core (and probably the community version) without having to release them.

Why should I trust you?

I don’t “mod” games these days. I write “meta-mods”, or modifications which support other modifications. Examples of this are the CTX natives I’ve supplied for Counter-Strike Source and Team Fortress 2, and less ‘magically’ Watch That Friendly Fire (which I haven’t really maintained, or fully released), and my plugin for toggling capture points. You might note that none of them are actual gameplay changes (except maybe the capture point breaker), and are designed (more or less) to support your own gameplay modifications. I have no interest in running a server and trying to ‘make profit out of ads on my MOTD’. With all of that said, even if I change my mind and want to run a server and try to ‘monetise’ it (as it were), I would be bound by the licence I chose, such that I could not just take AGPLv3 patches into my own tree.

AGPLv3 Fears

Neither the ‘configuration’ file, nor the ‘offset’ file are bound by AGPLv3 because they do not contain any copyrightable data. Furthermore, if you’re worried, they are attached via SourceMod interfaces, which remain GPLv3.

Is there a way around this so I don’t have to share my modifications to your code?

Only if you can convince me that you should have a GPLv3 version and that others shouldn’t. Good luck I’m unlikely to be swayed.

Why did you choose AGPLv3?

I’m working on a gamemode extension/modification for free. As such, I’m giving this extension and attached plugin (and the availability to edit both) to the community, for free. As such I’d like community members to actually give back, share ideas, and adapt the gameplay, creating a nice, neat, sensible experience for the users of their servers.

But can’t you just violate that and not share it?

Sure. And as the author of the code I could just use the GPLv3 version of my code (as I have the right to change the licence on my work) and adapt and run awesome versions on my own server.

That’s not fair!

Well, considering you’re getting several days worth of work, a re-vitalised version of my old Eventscripts plugin, which will (with any luck) run quickly, cleanly, and neatly, for free, I don’t see how. For anyone who wants to complain that I can use my own code privately, maybe you should write your own GPLv3 version, being certain not to copy my code (you’re free to use GPLv3 code and roll that in, because that’s how the licence works, but you can’t roll in AGPLv3 code unless you’re licencing under AGPLv3).

That’s still not fair!
I hate to be the one to tell you this, but I have the right to not share my code at all, how about instead of whinging at me that I chose a licence that ensures you share, you be grateful?

What if I don’t modify the extension?

Just point users to the core or community repository (to be shared when released).

What if I modify the plugin?

It’s AGPLv3 because it is a derived work (derived from both SourceMod — GPLv3 — and my AGPLv3 extension to SourceMod). Because it is directly attached to my extension, and the include I provide is AGPLv3, no matter whether or not you replicate or rename the variables in the natives, you’re still bound by AGPLv3. In the same way, you’re expected to share your source.

How do I do that?

When I release both extension and ‘sample plugin’ (which is likely to be bare features for the initial release), I will be creating a thread for each. At which point you’ll have the choice of attaching the SourcePawn to a post on the plugin thread, and linking users there, or hosting it in a code repository (on something like Bitbucket or GitHub).

I hate the licence / I won’t use it if it’s AGPLv3 / I hate you / This isn’t fair!

Then don’t use it.

Will you hunt me down and take action if I violate your licence?

Yes. And I’m sure your service provider (be it your ISP, GSP, or other service provider) will want to stay away from violations.

Why?

I’m giving this, with the expectation that others will either use it, or adapt it. Either way, my expectation is that you will share, as I have with you.

But I don’t want to share my exclusive server modifications?!

Then follow the licence. If you’re using my extension, you are required to share the source with anyone who can access your server in a way that makes it known that the plugin and extension are there. If you use the unmodified version of the extension and the plugin, and want to add ‘extra features’, try to find a way separate to it that allows you to do what you need. For instance, if you want the ‘LoneWolf’ to have a specialised weapon rather than what I’m giving it, hook the respawn event then give it to the player on the RED or BLU team (depending on what I do) — just don’t touch the console variable or anything else built into the extension and plugin. That is, you can still modify things around it, but you can’t touch it. So if you want donors who are the LoneWolf to have extra health, you’re pretty stuffed unless you run another hook to override mine (unexpected behaviour alert!), but if you simply want it to look different, or to have icons for some people, you could always hook various other things, based on the team I’m using.

So you’re not making it impossible to add things external to this?

No. If you want to work on the ‘team by team’ basis to do things to the ‘LoneWolf’, you still can. Bearing in mind some things (like OnTakeDamage) are hooked, and so you may experience some strange behaviour, in which case you should probably write it into the extension.

Will you add ‘donor support mode’ to this, whatever this is?

It’s partially supported in what will be the initial release, but I will not be adding stupid things like ‘donors take less damage’ or ‘donors move faster’. There will be options to abuse part of the modification using standard plugin features (advancing user statistics) based on the fact that some people may need them to ‘reset’ players if they mess up a database command.

Will I support admin/donor abuse? No.

I hope that this is all relatively clear. My plan is not to hurt anyone, or to put anyone at a disadvantage. If you feel it’s unfair that I’m not sharing “the best” of my code, or that I’m allowed to maintain my own core to run on my own server, remember that various other authors (I’m looking at ‘voogru’) run private extensions and plugins), sharing some of the neat things, and others still don’t share at all. The only difference between my choice and their choice, is that I choose to share in the first place. The option to keep my code private is taken through my right to licence my code under different licences (my choices being limited to GPLv3 and AGPLv3, as I’m using GPLv3 code).

If you think that this is unfair, I’d like you to take a moment and consider that I have this extension working under MetaMod:Source, which would mean that I could release a crippled version for free, as a binary, and never give you the source. While I want people to have it, I basically do not want the community’s trust to be abused, so I am taking this road.

I hope you understand my choice, but given the amount of time spend researching various aspects of this (which is part of the reason the CTX modifications are available at all), I believe that this is the best choice.

TF2 hosting: why you want Linux

Mon, 13 Jun 2011 10:12:46 +1000

There are many reasons you want to be on Linux for hosting any Valve game, though many of them are hinged on my experiences.

Subjective

Hosts who can roll out a Linux install, tend to have a better idea of what’s happening;
Hosts who roll out Linux tend to have neat control panels (rolling their own more often than using TCAdmin), which they build, not buy (cheaper!).

Objective:

OpenSource servers lower the cost of the server (as opposed to paying for huge licences);
Extensions are easier to build for Linux, due to opensource toolchains, and easier to read (or at least less obfuscated) code (symbols, woo!).

Now, while some of these may change (free control panel xplatform?; valve stripping symbols from Linux bins), the cost difference should remain.

In my experience, the only host that continues to use Linux in Australia is GameServers.com, who also offer free basic webhosting (like Hypernia and many others), and discounts on voice servers (for who who need them).

The other options out there like Hypernia, which are Windows hosts and give you free voice hosting and webhosting (should you take them up on it).

The real point to be made is that Linux hosts like GameServers come out slightly cheaper (even with a similar vioce server included), and allow modders a greater speed in development, with direct access to all of the toys.

If you want to get serious about tweaking your game, maybe it’s time you switched to a better platform.

( Worried about not being able to test locally? Worry not! You VirtualBox to test locally with a Debian or Ubuntu install, following the simple instructions on srcds.com. )

Intel GPUs and VBOs

Sun, 29 May 2011 10:24:00 +1000

After about a week of playing with code, I ran a test on my laptop: librocket broke, the shaders lagged, and my system came to life and killed everything in the room.

After an uneventful trip to the necromancer, I started looking at where it failed, and the Intel GPU was the first place I checked: that was it. So I added a simple function to a class:

void DetectOGLAdv()
{
    OGLAdvEnabled = true; // Assume it’s good

    // PostFX disable (for those using SFML)
    if(!sf::PostFX::CanUsePostFX)
        OGLAdvEnabled = false;

    // Intel GPUs are horrible
    if(strcmp((const char *)glGetString(GL_VENDOR),”Intel”) == 0)
        OGLAdvEnabled = false;
}

As I find things that break my code I’ll add to it, but I thought it might be useful to point out the VBO fault exists even in the newer cards (at least on Windows).

The other workaround is, of course, finding a way to ship MESA drivers for Window to enable users to run it… the real difficulty will be in determining where the MESA drivers start, and DirectX begins (my understanding is that DirectX isn’t influenced, but it’ll be time to find out soon, woo!).

Engine now in the pipeline!

Wed, 11 May 2011 19:38:17 +1000

GWEN didn’t work out; sfengine didn’t work out; but LibRocket did!

So the engine is basically just SFML + LibRocket.

This may seem a bit weak, but you need to remember I have to interface everything, plug up my own stopgap solutions for things — SFML is just a compatibility layer between a bunch of really neat technologies (most notably OpenAL, libsndfile, and FreeType — all of which I was using before) and multiple platforms (I’m yet to actually start work on the Mac here to see how much needs love for GCC and/or Xcode).

LibRocket rocks, but if you’re going to use the included SFML layer, remember to invert the Mousewheel delta (i.e. throw a - before it in the switch), otherwise your mousewheel actions will go backwards ;)

My SFML Engine

Sun, 01 May 2011 08:31:04 +1000

Calling my SFML work an ‘engine’ is a bit of an exaggeration, simply because SFML does most of the heavy lifting for me, using most of what I was using before (including OpenAL, OpenGL, and FreeType), while still giving me the power to use OpenGL.

So the status is:

GUI is GWEN (using an updated/fixed version of voodooattack’s SFML renderer);
Input is working.

That’s really all for now. This is ~24 hours after I started an SFML version of my game…

'sfengine'

Sat, 30 Apr 2011 11:00:42 +1000

While talking to a friend (who is using SFML, which is, for all intents and purposes, an engine in its own right), I stumbled across ‘sfengine’, which contains just about everything I want — except that it runs on SFML 2.0, which is still ‘unstable’ (read: under development). Given I run bleeding edge Gentoo, this isn’t really a downside…

For now I’m suspending work on my engine to have a look at it, as it may well resolve any number of issues I’ve had, including, but not limited to, managing scaling of certain objects.

What is an 'engine'?

Fri, 29 Apr 2011 23:22:55 +1000

I’ve had a few people ask me what exactly an engine is, and why it’s so difficult to make one.

First of all, it is not difficult to make an engine, it is difficult to make a good one (my current work should not be mistaken for a ‘good engine’, at least not yet). The difference between something which works, and something which is both dynamic and clean, is that you can build an ‘engine’ which does precisely what you tell it (by hard-coding every possible outcome), whereas a dynamic/clean engine enables you to add things easily, externally, using an interface of some kind (usually an Application Programming Interface, like an API).

Secondly, to answer ‘what is an engine’ in brief: an engine is effectively a series of mechanisms (functions or methods, with the option for classes or modules, depending on your language). These mechanisms perform logical tasks, like drawing a box, or detecting a mouse click. There are different types or mechanisms (e.g. callbacks which fire when something is done, literally ‘calling back’). There are different purposes (input from keyboard/mouse, audio output, graphical output). Each of these parts require their own distinct components, usually external (unless you’re building the hardware too, in which case you probably have to do it yourself to some extent).

It is not difficult to build basic mechanisms, but it is time consuming to decide what you want. Even though I entered this with a fairly good idea of what I wanted, I have already had to compromise when I found elements I chose to use don’t quite do what I want — and not wanting to have to modify them heavily, thus breaking ease-of-update later, I had to make minor changes (e.g. I now have a single global variable, and this is rather annoying).

I hope this provides an answer suitable to the question. I might, at a later stage, run through building some trivial components in a non-OOP way, for those who are interested (feedback on this would be useful, either here or via IM/e-mail for those who have it, so I know I’m not wasting my time before I begin).