Planet RedBrick

Caroline and Brian (April 23, 2008 10:24 AM) (Submit this blog post to Redbrick Pligg!)

Brian and Caroline on New Year’s eve 2006.

Flickr Page

AWS, AppEngine and the future of data (April 21, 2008 07:48 PM) (Submit this blog post to Redbrick Pligg!)

Since I last blogged about Google’s new AppEngine service, I’ve been playing around with it and comparing it to Amazon’s Web Services, getting a feel for each of their abilities and limitations.

It’s not a like-by-like comparison; Google’s AppEngine is a higher level service. Unlike AWS, it presents an application framework - not an operating system - and it takes full responsibility for balancing the load and handling resilience and diversity. They also have different target markets.

Target markets

Google’s target is direct; developers; there’s no need for any intermediaries like system or data administrators, they can start off for free and ramp up if it takes off, and they can replicate the entire environment on their laptop. The barrier to entry is very low (as long as you know Python) and encourages experimentation. It’s easy to see teenagers writing OpenSocial and MySpace widgets on Google AppEngine. If AppEngine didn’t exist, its stereotypical user would be writing iPhone apps, a shining star developer at some $BigCo, or just the best Counterstrike sniper in their city and that’s not a put down.

Amazon’s target is more serious; entrepreneurs; there’s more control and freedom, at the cost of a little commitment. The services are designed to slot into business plans in ways that make sense to both the lead architect and the CFO. It’s easy to see small but growing enterprises and a bit of a marketing budget using AWS. If AWS didn’t exist, its stereotypical user would be employing more admins, buying more machines and going through the pain of building or renting comms space.

Amazon are adding new services to AWS every few months, and Google are open about their plans to expand on theirs. No doubt we’ll see some interesting new offerings from both of them, but in the meantime we can compare them based on their capabilities today.

Ultimately the differentiators for these kinds of services will probably be the languages supported and the management tooling, but personally, the part I find the most interesting to compare is data storage and processing. I also think it’s the most important fundamental change that these computing clouds bring about.

Information is power, knowledge is wealth and data is very literally the bits they’re made of, or so the cliché goes. The entire field of IT, Information technology is really about data, it’s pretty key stuff, and managing it is the hard part of building an online service. So how do they compare when you want to provide a data-driven service?

Architecting geographically resilient services

Well, before we can quite answer that question we need to go over how a global-scale geographically resilient service looks and works. This stuff is hard, with a lot of theory and problems, so I hope you’ll forgive me if I boil it down to the three big challenges;

Getting a user’s queries to different sites

Using either stupid DNS tricks (seriously, that’s a technical term), IP anycast using BGP, application-level redirection/load balancing or a combination of these, a user’s queries need to get to different sites depending on conditions. At the very least, the system needs to be able to route around an outage of one site. Advanced features include route optimisation, where users queries are served from the location closest to them network-wise.

Getting a user’s data to every site

Even in the most basic case (where all data is local to a single user), there’s a risk that the site a user is being served by will go offline suddenly, so that data needs to be synchronised to every site when written. For more typical cases the entire dataset is being used by all sites anyway, as
global statistics and user data are interesting to other users.

The speed of light

Our present speed limit is the speed of light in a vacuum. You’re probably reading this sentence faster than you could ever send a single photon to your antipode and back again. Planet-scale communications using electromagnetic radiation are forever, intractably, hampered in this way (thankfully our own planet has the conveniently placed Pacific Ocean to keep a tab on the problem).

As if that weren’t bad enough news for us, we don’t beam information through a vacuum but actually slow it down by bouncing it around in tiny bundles of dense glass. Raw bits travel at about 0.66 c. We also have the discourtesy to convert photons to electrons a few dozen times, wrap them in error codes, and shove them into protocols that require math to happen every time they hit a hop on a traceroute.

End result: as information leaves the desktop, and lives in distributed computing clouds, it moves quite slowly and well within the range of human perception.

Outsourcing these hard problems, and getting the benefits and economies of scale that Google and Amazon have, is what these products are really about.

At the intersection of those three challenges is the worst problem of all; handling a data-level netsplit, when users may be interacting with multiple sites that each have different ideas about the state of play. This, more than anything else, exerts the strongest influence on both the data and application architectures.

A common or garden netsplit

Scenario: two (or more) sites stay online and reachable to some internet users, but have poor connectivity to each other. Now neither site has any automated way of knowing that the other is “really†down (ie from the entire internet) or that any slowdown is temporary, so both sites should keep serving users - but data isn’t being synchronized between the sites. There needn’t be a full outage for it to be a problem, it might just be a delay - a clogged link, or some faulty storage infrastructure - but the result is the same, inconsistent data in real time. Or as Amazon put it;

Amazon SimpleDB keeps multiple copies of each domain. When data is written or updated (using PutAttributes, DeleteAttributes, CreateDomain or DeleteDomain) and “Success†is returned, all copies of the data are updated. However, it takes time for the data to propagate to all storage locations. The data will eventually be consistent, but an immediate read might not show the change.

Consistency is usually reached within seconds, but a high system load or network partition might increase this time. Performing a read after a short period of time should return the updated data.

Designers put in multiple resilient paths between sites, add out-of-band management systems, and wake up Network Operation Centre engineers at 2AM to try and minimise these problems, but it can and does still happen. Some commentators think that it’s just matter of time before service providers can get around these problems, but really it’s not, unless they know something about the speed of light the rest of us have missed.

A virtual netsplit

Scenario; there are 2 (or more) sites, say 6,000km, or better expressed as 100ms, apart. There’s a user in the middle, half-way between both. For that user, it only takes 50ms to reach either site, but it takes 200ms for any reliable commit to their data to roundtrip. Adding 200ms of delay to every user query is not acceptable, so we must live with a little lazy data replication.

What happens if they end up being served by both sites? There’s two ways this can happen - one is ordinary enough, their main site goes offline suddenly, and they failover to the other, but their data didn’t make it in time. The other is far more insidious.

When DNS tricks or IP anycast are used for global load distribution, there are bizarre corner cases in which a user may be intermittently served by different sites. Their DNS or proxy servers may have source addresses in different networks, or maybe their ISP doesn’t carry a full routing table and they’re a victim of some equal-cost multi-path routing (although that’s a severe case, which will kill all TCP services anyway, it’s still a problem with low TTL DNS tricks).

If the application queries rely on state from previous requests, it can get very confusing very quickly when the data is taking longer to replicate than the users queries are flipping between sites. (As an aside: imagine this problem multiplied by factorial(N) where N is your total number of users and welcome the pain of implementing a stateful peer to peer network).

So, those are the problems, and there are good and practical engineering measures used to mitigate them; decent global load-balancing techniques will minimise any flipping of users between sites, well-maintained and monitored resilient links between sites will keep splits very rare, and a larger number of more widely dispersed sites will keep alternative sites closer-by and allow for tiered data synchronization.

Why am I going on about netsplits and the speed of light? well, the thing to take from all this is that there are no guarantees about data consistency across sites in real time, and reasons behind this are fundamental. You can have excellent data consistency, at the cost of some latency, or you can have low latency with slower guarantees on data consistency across sites, but never both; sorry.

Often, this doesn’t matter at all, there are so few writes - or they are not critical to interactivity - that it’s acceptable to have a single master site and some delay from far away locations. But many web applications are highly interactive and data heavy. Every time you make a move on scrabulous, you need your opponent to see it. When you add a photo to a set on flickr, you expect your friends to be able to see it.

Data-modeling with Object and Tuple stores

The constraints all of this places on data management have large effects on how both Amazon’s and Google’s load-distribution and data-stores work, they’ve both been designed with this in mind. There’s no referential integrity, uniqueness of records is not enforced at all, nearly all of the features we’ve become addicted to from RDBMSs are missing, and the documentation makes no guarantees of data consistency or even disclaims it.

Developers would love it, but it’s simply impossible to provide a global-scale super-resilient super-low-latency SQL-alike data-store. So what happens when you learn to live with lazy data?

Well it’s 2008, and these days it’s hard to imagine any new web service that didn’t have support for tags and folksonomies. So what if you’re selling furniture online, couches can have tags. Providing services to a salesforce? Yep, you need tags. A forum for talking about candle-making? how could you remember what it was like before tags. Tags tags tags, everybody needs tags. So, let’s add them to an AWS or AppEngine site.

I’ve always thought there was a hidden market to be tapped into in tagged blob storage. Todays dotComs are all about conquering a middleware niche, so why not make the best tagged blob service there is - let other sites worry about what the blob actually is. So this should be easy peasy, right? Tags are just a one to many attribute. We knock up something like;

class Blob(db.Model):
    blob = db.BlobProperty(required = True)
    tag = db.ListProperty(db.Category)

blob = Blob(blob = bindata, tag = ["colmmacc", "cc2.0bync"])

PUT (blob, $uuid), (data, $s3url), (tag, colmmacc), (tag, cc2.0bync)

We’re done, aren’t we? we can now tag blobs, select them by tag, and even the list of tags on a per-blob basis. That’ll add an extra zero to our selling price, and it only took 5 minutes, great stuff. Well, not quite, because we don’t just want tags, the marketing department says that’s not cool enough, we want tagclouds.

That subtle change in usage pattern makes a big difference though. Now we need to count tags across all of our blobs, and probably against other dimensions too - like which users own the blobs, because we want per-user and global tagclouds. To get an idea of the difference in complexity this all implies, have a good read of a suggested SQL schema for tags.

Google’s data-store is really an object store, and rather than designing data schemas, if you think about how you would solve a problem if it was a bunch of in-memory objects, with standard data-structures like trees and indexes, you’ll generally come up with a good data model for your problem. If we try to re-create something like the SQL-schema for tags, we won’t get very far. We can create tag and linker objects;

class Tag(db.Model):
    name = db.StringProperty(required = True)

class Blob(db.Model):
    blob = db.BlobProperty(required = True)

class TagBlobLink(db.Model):
    tag  = db.ReferenceProperty(Tag)
    blob = db.ReferenceProperty(Blob)

but this let’s us down in one big way; we can’t enforce the uniqueness of tags. Although we can hammer out something like;

# See if our tag exists
try:
     t = Tag.all().filter("name =", tagname).fetch(1)[0]

# otherwise create it
except IndexError:
     t = Tag(name = tagname)
     t.put()

without a global, reliable, locking service it’s just not safe - two instances might create identically named tag objects at the same time. The same problem crops up if you try to maintain your own reciprocal indexes of tags and blobs in the Tag and Blob objects themselves - when it’s time to add a new tag or blob, you can’t guarantee uniqueness without a lock-step. Unfortunately Google don’t provide AppEngine authors with access to Chubby or any other locking service.

One solution may be to use the data-store itself as a locking service, but you’d have to have a good idea of any likely data propagation times, build sleep() calls in, and still hope for the best. A better, more acceptable solution, is probably to tolerate some conflicts - simply allow for the possibility of two Tag[tagname = "colmmacc"] objects - and have an offline vacuum process which merges the conflicts, particularly easy in the case like this.

A bigger problem with the Google Datastore API is the extremely poor support for operators and extended query results. It’s not even possible to OR or NOT query conditions, to COUNT full result sets or retrieve more than 1,000 results from any query. That makes implementing our tag-cloud even harder again, because we’re going to have tags associated with more then 1,000 blobs.

If we wanted to build a tag cloud for two users (which would normally use an OR), we would have to read in all of their blobs - 1,000 at a time, store and sort them all to eliminate duplicates and then count the results iteratively. That’s a lot of overhead to have at the application layer.

Amazon’s data-store is all about rows of associative tuples. As all attributes are string-based tuples, it makes it possible for them to indexed in multiple dimensions and directions - and when you think about it, it’s easy to see how almost any data model can be described in that way.

Going back to our simpledb example:

PUT (blob, $uuid), (data, $s3url), (tag, colmmacc), (tag, cc2.0bync)

The great thing about simpledb is that you don’t have to update the whole row at once. You can add one tuple at a time. It might not make it to all sites instantly, but it at least keeps the consistency problem local to that attribute - not the entire row/object. Since I don’t have to worry about keeping a list consistent, I tag the blob by adding an attribute.

There are still some race conditions, but they tend to match human expectations. For example, John at site A might add a tag “foo†at time T, then Sally at site B might add the same tag at time T+1. Then John changes his mind and removes it at time T+2, but then Sally’s change might come in and trounce it. But that’s what happens when humans make conflicting changes in real-time anyway.

SimpleDB has full support for OR’s, NOT’s and other such logical operators. It doesn’t have a COUNT, so you still have to read in the results to count them - this time only 250 results at a time - but at least you don’t need to sort them. Amazon doesn’t have a locking system either per se, though it does have a Queue service, and any CS undergrad will be able to tell you how to implement a semaphore-based lock using a queue. But that’s definitely not what it’s intended for.

Still, both examples are ugly; to get our counts of tags, we’re having to paginate through result sets iteratively, consuming memory and CPU in the process - that’s hardly optimal. One solution would be to replicate in our application what many RDBMS’s do, and to maintain an N dimensional cache of our tag counts, and update it on write.

Distribute the operations, not just values

But that brings me to something else, besides a locking service, that I think is missing. Wouldn’t it be cool if you could distribute operations instead of just values? Lets say our tag cache looked like:

Whether we’re using Amazon or Google’s services, if we want to add a new tag and update the cache, we have to read the value, increment it, and then write it out again. If this happens simultaneously at two sites, our count will be wrong, and we’ll be missing a value.

Instead, imagine an API that let you define those values as counters, and you were given a set of distributable operations, increment(value), decrement(value). The cloud could apply the operation as it distributes, regardless of what the value is. Although the values still won’t be instantaneously consistent, it will be roughly right, and we’re never going to be negating ourselves.

One way to implement this kind of behaviour in application space is to use SimpleDB’s tuples like a stack, pop-ing operations when we’re sure they have successfully distributed. When we want to add or subtract to our total, we push an operation, a row might look like this;

(tag, love), (count, 510), (pending-operation, "increment,timestamp,uuid")

the pending-operation consists of the operation name, a timestamp so that we can later
get rid of them, and a uuid or hostid to handle the case where the same operation occurs at the same time from two different hosts.

Now, when we want to perform a count, we take our total, and proceed through the pending-operations - if any - at runtime. SimpleDB’s eventual consistency model will have been adding pending-operations as the data synchronises, so we might be a bit out, but that’s ok. Then, to keep the stack of pending-operations to a reasonable size, we have an offline process, or a conditional block, which does the following:

for operation in pending-operations:
     # 10 minutes should be plenty of time for operations to propagate
     if now() - operation[timestamp]  > (10 * 60):
            count = operation[operation](count)

     # Pop the operation from the stack
     operation.remove()

Of course to apply the above safely from a conditional block, we’d still need to use a lock - underscoring the importance of that missing feature, but it avoids expensive locking at run time. it’s a bit like have a map-reduce for real-time distributed data, though the examples here are simplistic, there are plenty of useful commutative functions and operators.

Counters like this are common enough in distributed applications, how else would you know how many people have viewed your OkCupid profile that day? But there’s another very closely related data type for which distributed operations rock; inventory.

Let’s say I have 200 concert tickets to sell online, and I’m pretty sure it’s going to sell out in minutes (it’s Bob Dylan performing to a small audience). If I use a global lock and counter, my site is going to be slow, and it will have a hard time as it is. If I start a count at 200 and use a distributed decrement approach like above, there’s a big risk of overflowing past 0 and upsetting some people.

Instead, there’s a better way - use a registry or ticketing system. Have an inventory data-type, and allow it to be divided between the sites on demand. So, say it starts at 200, and we tell the API to carve it up 10 tickets at a time; each site should take a batch of 10 tickets, and when it gets down to only 2 left, request another 10 and so on. This gives us the best of both worlds, we have a local inventory that we won’t take seconds to lock, and we guarantee that we won’t overflow the total.

If you’re using EC2, and you know how many sites you’re running in, you can build this kind of logic into an application easily enough using Amazon’s Simple Queue Service, but it sure would be a nice feature to have available more directly.

Data from the other side

One big gap present in both services is data analysis. That might seem like a trivial thing, but it’s a big deal - analysing your business and usage data can tell you can awful lot about what’s happening and what directions to take.

Both Google and AWS have reasonable services for reporting your usage; there are graphs, logs, and all of the data is there. In Google’s case, since all of the requests go through its application framework, it sees everything and it’s all collated into one easy-to-use analytics-like interface. You get joined-up access to HTTP logs and Python tracebacks.

If I were Amazon, I’d be working on a simple logging service, with plugins for Apache, syslogd, all of the programming language, and whatever else could ever want to log. Having everything in one place is a big deal, you can then correlate events, establish usage patterns and identify attacks and uncommon behaviour.

But what both miss is the higher level; not just the graphs and numbers, but statistical analyses like Holt-Winters projections that will allow users to identify real dips in their throughput which could be due to technical or marketing problems.

Service monitoring and usage analysis is a big problem for businesses, and my guess is that many would jump at the chance to benefit from the scale and experience of a provider like Amazon or Google.

Interesting times

These are certainly interesting times for data management. Internet-scale applications are coming to the masses, and very clever computer scientists and architects are coming up with abstractions and models that allow ordinary developers to cope with the fallout of using a planet instead of a hard-disk.

Are we going to see mid-level services like locking and distributable operations, that are present in some DBMS’s become part of this too? or will they turn out to be dangerous anti-patterns that prove too tempting to abusive and lazy developers. I hope it’s the former, but in the meantime it’s great to think out and learn from the design decisions made by the industry giants. They’ve thought very hard about these things.

The tag-cloud image is from Luca Cremonini, via the Wikimedia Commons project.

Contact Manager powered by TDO Mini Forms and a new bug fix release (v0.10.4) (April 18, 2008 09:03 AM) (Submit this blog post to Redbrick Pligg!)

I’ve just released a bug fix for TDO Mini Forms v0.10.4, get it in the usual places. v0.10.3 broke Custom Fields and also prevented the plugin from running on PHP4 hosts.

Also, sbruner (Steve Bruner) posted on the TDOMF forums that he has used the TDOMF plugin to create a rather nifty Contact Manager Theme for Wordpress. It looks pretty damn cool. Well done!

1 viable item left on my list to do (April 16, 2008 01:02 PM) (Submit this blog post to Redbrick Pligg!)

Check item #7! (“Do some further work on TDO Mini-Formsâ€) Of course I could continue at full steam with it but I decided to slow down. Work will continue, just not as time-consuming.

Also item #6 (“Try again to get a gaming group togetherâ€) occurred without any prompting from me. I was doing some work on our roleplaying group website (moving it to a different address) and the players started to trying to figure out when they can all play next. However, it might not be until July! Must bug them again.

As for item #5 (“Move Hosts for thedeadone.netâ€) will occur when I make enough money from donations for TDO Mini Forms. I’m already half way there for a 1 year hosting planning…

Item #9 (“Upgrade and package the current thedeadone.net themeâ€) won’t happen. It’s been a maybe, but I just can’t muster the energy to do it. I think it really depends on finding a new host for thedeadone.net and getting all that up and running. Then I can think of getting a new theme and closing off the current one.

Which nicely leaves me with only one item left: item #8 (“Write-up and make available some RPG rules I created a long time back: Story Hooks and Passionsâ€). While I think the two systems; Story Hooks and Passion, have since been done much better by Fate’s Aspects, Riddle of Steel’s Spirit Attributes and Shadow of Yesterday’s Keys, I think it’s still worth while closing them off. I did create and use them before I discovered these other systems and they are different and I hope to actually use them in my LH project. They certainly won’t be as long as TDO Fudge Combat v0.1 (short version available here) but they will probably garner about the same level of interest (which is about zero or so).

v0.10.3 of TDO Mini Forms released: an end to register_global and session issues! (I hope) (April 16, 2008 10:57 AM) (Submit this blog post to Redbrick Pligg!)

I’ve just released v0.10.3 of my TDO Mini Forms plugin. Get it in all the usual places.

The biggest changes in this version is that I’ve implemented a work around for the register_globals and $_SESSION issues. It should be noted that 99% of the time these are/were host configuration problems and nothing to do with TDOMF but I got fed up trying to support users on various different hosts who had difficulty turning off register_globals or enabling $_SESSION support. (So if this enables TDOMF to work flawlessly for you, consider donating, because it’s for you I did it. )

But moving forward, whats in store for TDOMF?

I’m currently working on two new features. The first is AJAX support. I did some experiments on v0.10.2 and found I could enable AJAX and everything seemed to work. However I only did “shallow†testing. I’d have to check if there is a limit on the size of the post and if it supports foreign/non-standard characters in posts. I won’t, initially, support fallback to a non-AJAX form, mostly because it would require making sure that all widgets have a javascript-less version (I think they do but I haven’t checked). AJAX was never really a critical feature, however I’m using it to support the other feature, which is a Form Hacker. (AJAX also neatly side-steps the register_global and form data stuff too - maybe I should have implemented this first rather than the fix above! )

The Form Hacker will allow you to modify the generated form without modifying the code. A lot of people want customisation that I haven’t built-in to TDOMF and modifying the code can be a bit of a nightmare with the innovative building-your-form using drag-n-drop/widgets as the code for the form is spread among a lot of files. It also means, that if you modify the code, you can’t upgrade without losing your hacks. I thought this might be an easy feature, and I have the bones already implemented. I added some tags that get expanded when the form is displayed, like user info, form name, form key, etc.

But I hit a snag with preview and validation of a form. Both these features, currently need to update the form once activated, often on a per-widget basis, otherwise if your form fails to validate or you preview your input, all the previous filled in fields are empty - forcing your user to re-input the form! However if AJAX is used then those filled in fields are untouched as only the preview and validation information is passed back. This means I could get an beta version of the Form Hacker out that supports only AJAX to get people using it and feedback on it. I’d like then to extend the Form Hacker so that you can hack individual widgets (not just an entire form) and support conditional tags (so that widgets can fill in previously entered input after validation and preview).

I’ve always tried to get the big features out of the way before concentrating on little bits and pieces and mostly these have been driven by what users have been asking for support and help on. The next big feature in my mind has always been the ability to edit posts. (In the back of my mind, having edit-posts means the plugin hits v1.0 status). It’s not really that big in terms of code but it is in how to implement it because there is a million different ways. Some considerations I have in mind so far:

Your opinions are welcome!

Version info for v0.10.3:

Super Mario (April 15, 2008 03:44 PM) (Submit this blog post to Redbrick Pligg!)

Don’t ask me why I’m posting this, it must be done!

Lyrics !?!
Today, full of energy, Mario is still running, running
Go save Princess Peach! Go!
Today, full of energy, Mario runs
Today, full of energy, jumping!
Today, full of energy, searching for coins
Today, keep going, Mario!

Get a mushroom - it’s Super Mario!
Get a flower - it’s Fire Mario!

Goomba! Troopa! Buzzy Beetle! Beat them all!
Mario is always full of energy and strong!

[Spoken] The only one who can reverse the spell that has captured the Mushroom People is Princess Peach. But Princess Peach is hidden underground, in a far-off castle. Ah, the days of peace… if we could once more return to those days… to save Princess Peach and bring peace back to the Mushroom Kingdom, that is why Mario is on his journey today.

Today, full of energy, Mario is still running, running
Go and beat the Koopa tribe, go!
Today, full of energy, Mario runs
Today, full of energy, jumping!
Today, full of energy, searching for coins
Today, keep going, Mario!

Get a star - become invincible!
Quickly, go save Princess Peach!

Lakitu! Blooper! Cheep Cheep! Beat them all!
Mario is always full of energy and strong!

Today, full of energy, Mario is still running, running
He’s made it to the castle and gets fireworks!
Lightly sidestepping the Hammer Bros.
Show the last of your power, Mario!
It’s been a long journey but it’s nearly at an end
You’ve done it, you’ve done it! You’ve defeated Bowser!

Princess Peach says “Thank youâ€
Mario’s got a great big heart!

Mario’s adventure is over for now, but
Mario’s dream lives forever…

http://view.break.com/487616 - Watch more free videos

[Gizmodo]

Sporting Win All (April 13, 2008 02:19 PM) (Submit this blog post to Redbrick Pligg!)

Kildare went down 2-0 at home to the newest team in the League at the weekend.

A poor display from the home side allowed Sporting Fingal to take all three points - and so the North Dublin team has racked up 3 wins already. There were no outstanding performers on the Kildare side.

Sporting Fingal is a football club born out of the County Council’s dedication to developing the sport in the area. Fingal County Council’s hope is to offer the community top class sporting facilities which will not only be available to their League of Ireland club but also to the local clubs already in the region. Plans are in the pipeline to develop a soccer academy and a modern new stadium in the area. A number of investor’s have come on board under the agreement that the club will be run on a non-profit basis. Community is key and the development of social amenities and social opportunities are the order of the day for this club.

Improvement in Longford (April 13, 2008 01:56 PM) (Submit this blog post to Redbrick Pligg!)

Kildare County earned a 0-0 draw with Longford Town in Flancare Park last week.

All three points could and probably should have been Kildare’s after most of the chances fell to Kildare during the match. Kildare’s on loan striker Kilduff missed a penalty and also the same player hit the post. Most Kildare fans probably would have said that they would be happy with an away draw against a team who battled in the Premier Division last year.

The performance gave Kildare hope after a perceived poor start to the season where they have yet to win and have had two matches postponed already. In particular Colin Fortune stood out in the centre of midfield.

It was Kildare County’s first ever visit to Flancare Park. Flancare is one of the best grounds not only in the First Division but in the entire League. It is a neat little 4,500 capacity all seater stadium since its redevelopment in 2000/2001.

Apachecon EU 2008 (April 11, 2008 03:15 PM) (Submit this blog post to Redbrick Pligg!)

Somewhat unexpectedly, I’ve spent today at Apachecon Europe 2008 in Amsterdam, and managed to deliver a talk on APR on short-notice. It’s been great to catch up with people I haven’t seen in a long time, years in many cases. Hopefully I’ll be in New Orleans later this year to catch up over a full apachecon, and get back to hacking again.

The presentation wasn’t exactly well-prepared, so there are only 13 slides, but for the record … here they are. And yep, even the Hello World example contains a bug!

Check Item #2 and 4… about 6 more to go… (April 09, 2008 04:31 PM) (Submit this blog post to Redbrick Pligg!)

Okay, so I managed to upgrade to Wordpress 2.5. Not as easy as I thought.

I also had to patch WP 2.5 to work on Redbrick as several features don’t work out the box and it’s still messy if your using a virtual host (like me).

The livejournal-crossposter and Slave Me 2 Wordpress plugins both break in Wordpress 2.5. I’ve updated Slave Me 2 Wordpress to work in WP2.5 as from the website for it, looks like there is zero activity. So that’s now working. However the livejournal-crossposter is dead, so no LJ for me until I fix it (again the current website for the plugin has zero activity).

Most of the other plugins seem okay. I have to update NextGen but I need to patch the version I’m currently using (like I have to patch Wordpress) so I haven’t done it yet. (I do like the automated plugin updates).

All of this cutting into actual time in work, so not good again. But now I’m all WP2.5! I have to tidy up and delete all my WP2.3.x dev and test installs now too to really cross out that item, but who’s going to quibble with me?

Of course, I may not do item 3 at all and I’ve added a new wishful-item 10, more of a way of prep-ing to change the theme of my blog.

If you see any problems with the site, after the upgrade, do tell!

Update: NextGen updated and I think I may have got livejournal-crossposter now too. Let’s see.

Google Apps Engine - a quick review (April 08, 2008 06:29 PM) (Submit this blog post to Redbrick Pligg!)

Yesterday Google launched AppEngine, a new hosting service for Python Applications, and having had a few hours to play with it - I’m finding it quite slick. It took about 10 minutes to go from nothing to a fully working first-application from the documentation, with the SDK making things very easy.

I’m going to to write some applications, for personal and work use, so I’ll get a better chance to review it in detail, but so far I’m very impressed - it does what it says on the tin.

From my immediate needs, the only thing that I’d like that is missing is support for scheduled tasks (run this python script in the same context, once an hour) - so that I can pre-generate some particularly burdensome output. Some other things would be nice, like the ability to act as a mail receiving gateway - not just sending e-mails, but that’s mostly useful for helpdesk, or e-commerce style apps, and there are workarounds.

I haven’t been this excited about a Google product in years, this is good stuff! Now, time to port my photo-blog :-)

Check Item #1… 7 more to go… (April 08, 2008 04:28 PM) (Submit this blog post to Redbrick Pligg!)

Item one complete. You can grab a copy of the latest TDO-Forum v0.3 here. It’s compatible with Wordpress 2.5 and all that. Enjoy.

I am getting lost in upgrading… (April 08, 2008 08:45 AM) (Submit this blog post to Redbrick Pligg!)

I had a great blog post in mind and I couldn’t arsed to write it up properly. I have no idea what’s up with me. I’m currently swallowed by this Wordpress 2.5 upgrade and I have code on the brain and I think it has become hard to disengage from that and just get back to the simple pleasure of writing. I’m also a little disappointed I get no reaction to my “TDO Fudge Combat†but I’m not surprised, I don’t really promote my stuff very well anyway.

My TODO list is currently something like this…

*sigh* And when I finish that…

TDO Combat Fudge v0.1.1 – The Blog Cut (April 07, 2008 12:57 PM) (Submit this blog post to Redbrick Pligg!)

This is a cut down version of TDO Combat Fudge v0.1 (a game system for roleplaying “combatâ€): Just the rules, zero explanations, zero context and zero examples. As requested, to make it more blog-digestable.

The scope of this Fudge build is very specific. It only applies to combat (or drama in social context). It doesn’t cover character creation and development or general conflict and checks. However it applies to all combat and scales. It can be applied to overt combat, goal-oriented combat (i.e. races), detection-based combat (i.e. stealth-based), chases and political combat (and anything else you can think of). It can be applied to large-scale conflicts (wars and battles) and small scale. If you don’t see how the rules can be applied to these situations, please check out the original version as it contains examples of all these cases.

The Basics

Original expanded section here

In combat you have two types of attacks: Opposed Attacks and Unopposed Attacks. Attacks are resolved like normal Actions with normal modifiers and set difficulties. Opposed Attacks are those that can be resisted or actively defended against (and are treated like Opposed Actions). Unopposed Attacks are attacks that can’t be defended against (and are treated like an Unopposed Action). An Attack means there is an attacker and a defender. If the defender wins, they stop or block the attack. If the attacker wins, they do a Wound to the defender (though a Combat Manoeuvre could modify this).

When resolving an Attack, participants must choose one (and only one) Protection and one (and only one) Armament if possible. Protection gives some benefit to defence and Armament gives some benefit to attack. Improvers (Protection or Armament) give some numeric benefit to an attack (or defence) while Enablers (Protection or Armament) will allow a participant to attack (or defend against some form of attack). They are rated from 0 to +3 and higher. Some can have fixed ratings that don’t change while others can have ratings that decrease with each usage. Game-masters should be liberal in accepting what can be considered for use as Protection or Armaments; even Faults (in the right circumstances) can be used as Protection or Armaments. Protection can come from non-attack rolls (the degree of success can be used as the rating) however this is not true for Armaments. A Protection can be used to defend against an Unopposed Attack but that does not change the Unopposed Attack into an Opposed Attack. It reduces the success of the Unopposed Attack.

Skills give Combat Manoeuvres. Theses represent trained and/or learned techniques of a Skill that can be used in combat. They can be used to differentiate two similar Skills used in the same combat. For a Skill, each rank above Mediocre grants a character a Combat Manoeuvre Slot for that Skill. These can be filled at any time; it’s up to the individual group of players and game-master what the Experience Point cost might be. Characters can attempt Custom Manoeuvres but at a +1 (or +2) difficulty modifier and some Experience Points (again determined by individual groups). A successfully pulled off Combat Manoeuvre counts as having learned it and can be bought immediately if Slots free. You can find examples of some Combat Manoeuvres here.

Damage in TDO Combat tracks the effects of winning and losing on your ability to continue the combat. There are two types of Damage. Splash Damage is applied to Attributes (default) and Task Damage applies to Personal Combat (task based or rather you can hang it on the Skill being used). The standard Wound Track from Fudge is used to track Damage and Wound penalties are used. High Attributes can give a few extra hit points. During Personal Combat, Task Damage is used but if you exit Personal Combat, Task Damage shakes out to Splash Damage and Hit Points move up to the lowest penalty free Hit Points (a bigger explanation here).

An “Incapacitated†Wound Types cause the character to suffer a Consequence, a “Near Death†causes an Extreme Consequence. Players can chose to take a Mild Consequence for a “Very Hurt†wound instead of losing a hit point. Suffering a Consequence will break out of Personal Combat (and thereby cause Task Damage to shake out to Splash Damage).

Damage is healed dramatically as per this guide:

As a reminder, Wound Type is calculated like this:

Offensive Damage Factor (ODF) = Degree of Success + [Armament] + [Scale]

Defensive Damage Factor (DDF) = [Protection] + [Scale]

Wound Type = ODF - DDF = (DegreeOfSuccess + Armament + Scale) - (Protection + Scale)

Running Combat

Framing the Combat

Framing the Combat is critical. You must answer each of the questions in Framing Combat. If you can’t answer the questions, then there is no Combat to run. Several of the questions have a mechanical impact on the Combat so they must be considered fairly. You can of course Frame a smaller Combat within a bigger Combat or Scene.

More on Framing Combat here

(Stakes) Is it worth going into Combat?

You don’t have to enter combat. You should only go into full Combat if the conflict is high stakes for the player characters (like their lives).

Who are the involved parties and what are the sides?

You can’t have a combat with out at least two antagonistic sides. If you can’t identify at least two sides then you don’t have a Combat. Go no further.

(Abstraction) What is an Attack in this context?

When applying the combat to new circumstances you must at the very least figure out what an Attack is (and by implication then what a Defence, Protection, Armament, Environment, etc. might be). If you can’t even do that, there is no Combat. Go no further.

A Combat consisting of just Unopposed Attacks starts in Mixed Combat mode. Opposed Attacks start in Personal Combat mode (perhaps framed by a Mixed Combat).

(Scaling) What is the minimum size of a Story Element within the Combat?

Combat consists of Events. The default scale of Combat is the smallest perceived Event in Combat (normally an exchange of attacks and defence - not a single attack). You can explicitly use a higher Scale. Please check out the section on Abstracting and Scale for a more in-depth description.

What are the exit conditions for the parties?

The game-master must have some concept of how the combat can end and if there are multiple exit conditions (some of which may be revealed to the players).

Declare Environment Conditions

The Environment always affects combat. The games-master must declare at least one Environment Condition that impacts the Combat. This may manifest as modifiers to tasks, task blockers or enablers or damage over time.

Mixed Combat (Default)

Combat is considered to start as Mixed Combat. Mixed Combat can handle “many to many†type combat. Personal Combat can play out within a Mixed Combat. A round in Mixed Combat is a round of events involving each player characters that is part of the combat. This round of events breaks down to the lowest character-perceived event (default scale), i.e. a Story Element. This is generally equal to an exchange of attacks. A round of Personal Combat is considered the same as a round of Mixed Combat/Story Elements.  Every player should get to act/roll once per round. Initiative/order of play should be random (unlike Personal Combat). Damage done in Mixed Combat is Splash Damage. Character’s actions are not restricted (unlike Personal Combat). The game-master can Pause combat to give a dramatic description of some event.

You can use Mixed Scale in Mixed Combat. If one player is playing at a higher scale then the others, they rolls only once per every two (or more) rounds compared to the other players. This can be used to have a Personal Combat ran on a different Scale to the rest of the Mixed Combat. Significant events during Mixed Combat can still force the player to scale back down to the same level as the other players.

More on Mixed Combat…

Personal Combat

Personal Combat uses the same Scale - you can’t use Mixed Scale (like with Mixed Combat). It applies to combat involving one party against one other party (hence “Personalâ€) or multiple parties. A trait or check is required to gauge initiative and therefore order of actions - you can’t use a random mechanic. Initiative can be affected by Wound penalties. Personal Combat starts when one party makes an Opposed Attack against another. If the character cannot defend them selves then it is an Unopposed Attack and does not start Personal Combat. A round of Personal Combat equals a Story Element of the same Scale. No other actions besides Attack, Defensive Actions or Combat Manoeuvres are allowed during Personal Combat. Personal Combat uses Task Damage. Personal Combat can be used for “Time-shifted Combat“; where a player character is fighting against the works of another party who is no longer present.

Step 1: Declare Stance

Before entering Personal Combat, all parties must declare their stance: Neutral, Defensive, Aggressive and Surprised. Parties unaware they are being attacked are automatically considered Surprised. If Personal Combat is started from an Opposed Attack, then the attacking party is automatically considered Aggressive. If all parties involved declare Defensive, the round ends (no-one attacks each other) but does not exit Personal Combat. Stances give some bonuses (and penalties) to the 1^st Exchange but after that, stance is forgotten.

Aggressive: An Aggressive Stance gives a +1 to any attacks but -1 to any defence.

Defensive: A Defensive Stance gives +1 to any defence but -1 to any attack.

Neutral: A Neutral Stance gives no bonuses or penalties to attack or defence.

Surprised: A Surprised Stance means the character is unaware of an incoming attack. They may be able to make some sort of roll to react but they will be on a -2 penalty.

Step 2: Initiative and Allocate Ranks

Determine Initiative of all parties involved in the Combat using your chosen mechanic. Then from the lowest Initiative to the highest, parties must:

I. Chose Skills: Parties must choose what Skills they are using for Attack and for Defence (if they have a choice). If you use a different Skill for Attack and for Defence only the lowest ranking one counts for Allocating Ranks. You can only use Combat Manoeuvres from the Skill you are using. If you use one Skill for Attack, you can only use Combat Manoeuvres from that Skill for Attack (and likewise for Defence).

II. Allocate Ranks: Parties must also allocate ranks from their chosen Skill (or lowest of their chosen Skills), declaring how many ranks they are putting into the 1^st Exchange. They start with twice the number of ranks in the lowest of their chosen Skill (this is to keep difficulties consistent between Exchanges and outside of Personal Combat). Anything unallocated can be used for Combat Manoeuvres and the 2^nd Exchange. Combat Manoeuvres, that require a roll, also require ranks from this “poolâ€.

To handle multiple parties in Personal Combat, the defending party must allocate ranks to each attacking party. External parties can give Protection to an involved party but cannot give Armaments. If they are giving a party Armaments, they are considered an attacker (which exits Personal Combat).

III. Declare Action: Parties must now declare their action: Attack, Defend or a Combat Manoeuvre. Parties with the higher initiative act first.

Parties with the higher initiative go first so generally the parties with lower initiative will be defending. However both parties could attack each other. In this case the party with higher initiative attacks first (the second party has no defence). Damage is applied and then the second party can attack (the first party now has no defence). Depending on the context, parties may have access to a Combat Manoeuvre that allows them to “buy†initiative. Such a Combat Manoeuvre may take Fudge Points, ranks or even Experience points, which ever is most applicable. This may be used to try and strike first if both parties are attacking, a very risky technique.

Step 3 and 4: 1^st and 2^nd Exchanges

Parties with the higher initiative act first so in the 1^st Exchange they normally make an Opposed Attack using the allocated ranks from Step 2. The winner of this roll can then take or keep initiative for the 2^nd Exchange. If there is a tie, the attacker maintains initiative. Damage is resolved and Task Damage is applied instantly taking from any allocated ranks for the 2^nd Exchange. Repeat for 2^nd Exchange (parties now allocate ranks for the 2^nd Exchange from their remaining unused ranks).

If all parties decide to attack in either Exchange, the party with the initiative (2^nd Exchange) or higher initiative (1^st Exchange) attacks first with an Unopposed Attack. Damage occurs and then the second party can attack also with an Unopposed Attack.

End of round. As long as no exit condition has occurred, start next round and go back to Step 2.

Exiting Personal Combat

The flow of Personal Combat is like this:

Personal Combat can stop if:

When Personal Combat is stopped, the Task Damage is shaken out to Splash Damage. Parties can re-engage Personal Combat again but must start from Step 1.

More on Personal Combat…

Fun Mode Variant

Fun Mode can be applied to both Mixed and Personal Combat. Fun Mode states simply that there are no Consequences suffered by the participants. The first to suffer what would be a Consequence loses the combat. A participant can explicitly decide to break the rules and do a full-out attack. This becomes obvious to all parties only after the first full-out attack is resolved, which means that a player may not be aware that an in-coming attack is actually a full-out attack. Regardless if that full-out attack succeeds or fails, it is obvious that Fun Mode is over and normal combat takes over. If you want to know what to use Fun Mode for see here.

More

For examples, notes and guidance please refer to the original draft of the system. Comments are welcome.

Oops! (April 05, 2008 07:11 PM) (Submit this blog post to Redbrick Pligg!)

Taken by Colin this is a great capture of Trevor making a mess of it! Or maybe he’s just using his Jedi powers.

Flickr Page

TDO Mini Forms for Wordpress 2.5: 0.10.2 (April 03, 2008 07:42 AM) (Submit this blog post to Redbrick Pligg!)

I made version 0.10.2 of TDO Mini Forms avaliable yesterday. The main purpose of this release is to make TDO Mini Forms compatible with Wordpress 2.5. You can download it from the usual place.

As per usual, please leave feedback on the support forums.

Update on TDO Mini Forms migration to Wordpress 2.5 (April 02, 2008 08:58 AM) (Submit this blog post to Redbrick Pligg!)

Thanks to those who donated! Much appreciated.

As it turns out the migration is going a lot easier than I had anticipated. Functionally TDO Mini Forms works fine under Wordpress 2.5 but much of the admin backend was screwed up.

The only thing left to do is make sure that the changes I’ve made will also work on 2.3.x.

Once I’ve released v0.10.2 I can get back to answering everyone else’s comments, so please be patient.

(Please leave comments and feedback on TDO Mini Forms on the forums please)

Gruesome details of real-life sword play in Dublin! (March 31, 2008 11:09 AM) (Submit this blog post to Redbrick Pligg!)

specky_ie on LJ saw the footage of the guy who lost his hand when he was attacked by a sword in Dublin a little while ago. Morbidly fascinating:

Ick! Pumping blood and body parts!

On the other hand (pun not intended) I can’t believe the guy kept fighting after he lost hand, but I guess it makes sense with adrenalin pumping and pure survival instinct. It may colour my descriptions of fights in-game. I’d imagine a trained sword-fighter would have downed the guy with the first strike (or perhaps I’ve just watched too many samurai movies as a child) but because the guy was not trained, any damage he did was pure luck.

Wordpress 2.5 and TDO Mini Forms (March 31, 2008 10:36 AM) (Submit this blog post to Redbrick Pligg!)

The last release of TDO Mini Forms plugin (version 0.10.1) hasn’t been tested on the newly released Wordpress 2.5 until today and a number of problems are cropping up.

The list right now is:

If you find any others, please report them on the support forums.

I’ve setup a  testbed to investigate and attempt to correct these issues but it may take a while. I was aware of the upcoming 2.5 release and I guessed at least the Form Widgets screen would get borked, but it’s just a glut of work that needs to be done. I was in the middle of implementing a new feature (a form “hackerâ€), that will have to be put on hold to do this work. I’m not particularly excited by doing it as it doesn’t improve TDOMF as such. If you are desperate for it or have been a long time user of TDOMF and want to upgrade Wordpress 2.5, then I’d recommend perhaps donating (see the link on the main page of your TDOMF install) as it’s a great way to get me motivated. However, it will get done, with or without encouragement.

Voetpad (March 29, 2008 01:41 PM) (Submit this blog post to Redbrick Pligg!)

… a small laneway about 100m from Joost’s Leiden offices.

Flickr Page

TDO Combat Fudge v0.1 (March 28, 2008 05:30 AM) (Submit this blog post to Redbrick Pligg!)

An Example Fudge Implementation of “Combat Profilesâ€

If you don’t have time to read all this, then check out the cut-down version v0.1.1!

What started as some rough ideas and thoughts on the combat experience in roleplaying games, developed in a kind of simplistic theory I called “Combat Profilesâ€. After some discussion, I put together this system as an example of using these concepts. In fact, putting together this system has helped me scope and define the ideas into something more tangible, but that’s for another day. This system priorities player-experience over strategy or realism but doesn’t try to exclude anything either. I don’t know if it delivers, as I haven’t tested it yet.

It uses Fudge and Story Elements, as I believe they are uniquely suited to “Combat Profiles†compared to the other systems I’ve played (of course I haven’t played every system out there). It is task-based (i.e. not “conflict resolutionâ€), another of my biases I guess. However I believe the general principals can be applied to other systems. It’s geared as a system that can be applied to all settings and all combat situations. The system attempts to define what combat is to understand how to apply it.

This system is in part inspired by the Shadow of Yesterday RPG, Riddle of Steel RPG, Spirit of the Century RPG, Fate System, several Fudge Factor articles and the FudgeList. If you are familiar with these sources, their influence should be obvious.

What are Combat Profiles?

At the end of 2007, I had a lengthy discussion on the Fudge List last year about a concept I came up with that I originally called “Combat Profilesâ€. The intention was to describe the different types of “combats†in roleplaying games. Combat though, in this case was just as much about physical violence as other scenarios like social events, large-scale battles, wars, etc. Combat is an essential element of any roleplaying system even if you don’t have physical fighting. Drama is conflict and big conflict is combat. Therefore a generic-oriented combat system is applicable across many types (if not all) roleplaying games. If a story or game doesn’t have some form of drama, why then are you playing it?

As it turns out, calling them “Combat Profiles†was a too ambitious. I had come up with only two “profiles†and these can be stretched and bent to cover practically any other combat. They are more “modes†of combat and I ended up also identify a number of combat archetypes, which would fit the idea of profiles much better. This combat system attempts to take advantage of two main profiles/modes and how they can be applied to combat archetypes. I’m pretty sure there are systems out there that probably do this a lot better but I don’t know them and anyway, I like to tinker.

Initial Notes

This is a conceptual system, which is in other words a system that hasn’t been play-tested. If it gains some traction, I may actually do something serious with it (I was thinking of using it for my LH project) but right now this is very much a thought exercise. By me writing up the system, I’m also designing it. But if anyone is inclined to try it, please inform me of your results!

What this system does not try to cover:

The Rest of Your Fudge Build

I’m assuming you are familiar with Fudge. If not, but your familiar with RPG systems in general, then most of this will still be familiar to you. We are going to be using Attributes and Skills. Fudge at its most flexible allows players to choose their own Attributes and Skills, even to drop the use of Attributes altogether (Fate and Spirit of the Century replace Attributes with “Aspectsâ€). However for TDO Combat Fudge to work, not only do we need Attributes, everyone needs to have the same set of Attributes (be patient, all will be explained). Attributes describe the raw abilities or potentials of your character. Your set of Attributes needs to cover all the bases, specifically all the types of combats (in the abstract) that you intend to have in your game. (Or rather the damage they can suffer). If you’re going to have physical combat, you probably need something like Strength, Stamina and/or Agility. If you’re going to have social combat you’ll probably need Charisma, Wits and/or Appearance, etc. You don’t have to have four or five Attributes per type of combat, just one can be enough. Your choice of Attributes will probably flavour your combats a lot. For example, you might have something like this:

(Based off Five-Point Fudge)

As for Skills, we need to make sure the granularity of the Skill choice is fine-tuned for TDO Fudge Combat. When we get down to Combat you should be using just one Skill to attack and defend in any one combat. I don’t mean that you can’t have several combat Skills (such as different martial arts) but that your Skills aren’t broken down beyond having a max of two Skills for the one type of combat: one for defending and one for attacking.

We’ll also be using Story Elements. If you use Story Elements normally, you don’t have to change anything outside of combat, however once the fists, insults or bullets start flying, we’ll have to place some constraints on Story Elements, which we’ll explore later.

You must have also some way to determine Initiative (determining order of characters’ actions). It can’t be some random mechanism but it should be noted that Initiative is not used all the time in combat. You could use a Skill (even one specifically for this), a Gift or Fault, an Attribute, some calculation based on a combination of some or all of the previous options or use the most applicable Skill to the Combat.

Just a reminder, Skills and Attributes are generally rated like this in Fudge:

The Basic Components

Combat is defined by the fact you have more than one party in direct conflict with each other. Combat containing more than one party breaks down into at least two sides but can be more.

There are two types of attacks to consider. An Opposed Attack is one where the party being attacked can resist. For example, someone swinging a fist at another person would be an opposed attack because the person being attacked can block and/or even attack back. An opposed attack does not mean that the defender can or must attack back, but potentially they may. An opposed attacks work in a very similar way to how opposed actions do.

An Unopposed Attack is one where the party being attacked cannot resist or fight back. For example, shooting at someone is an unopposed attack: in a semi-realistic game, a human (unless enhanced by supernatural or technological means) cannot defend them-selves from a bullet.

Both Unopposed and Opposed Attacks will have set difficulties and use modifiers as per making normal actions in Fudge.

Protection and Armaments

Parties involved in combat can also increase their attack and defence by using Armaments and Protection. In physical combat these roughly break down as armour and weapons, but that’s a weak description because they can be used to cover a much wider range of possibilities. For example, an Unopposed Attack can be made more difficult by creating Protection in advance such as wearing armour.

Only one Armament or Protection can be taken into account for any one attack or defence resolution. The player must choose which one applies for that roll if more than one option available. The benefits of multiple Protections or Armaments are not cumulative and by default the highest one counts. It is also permissible to use the same “thing†for both Armament and Protection, for example, many weapons give values for Armament and Protection. Also, some Protections only work against some Armaments or attacks, so choosing them can be critical.

In general, Protection and Armaments should be interrupted broadly. If a player thinks that something should give her some advantage in combat, it should. These rules are here to model the vast array of possibilities that players can take advantage of: from weapons and environment conditions to knowledge and beauty. In the right context, even a character’s Faults can be used for Armaments and/or Protection.

There are two types of Armaments and Protections. The first type, Improvers, simply improves a characters existing Skill to attack or defend. A Protection Improver can often work without the use of any Skill (such as armour, cover, protective action from another party, etc.). But many Armament Improvers require some degree of Skill to first make use of. The second type, Enablers, enables the character to attack or gives some sort of defence. Without it they may not be able to attack or defend at all. Many enablers are also improvers. There may also be other restrictions too: Physical weapons are often bound by range for example. If you have a Knight using a sword attempting to attack an Assassin armed with a knife, the Knight is making an Unopposed Attack because the sword enables him to do so. However, the sword’s advantage is range. If the Assassin gets the initiative (or uses a Combat Manoeuvre) she could close the range and make the sword useless but enable her to have an Unopposed Attack but the Knight’s armour will provide protection against the attack (improver) but not actually enable a defence.

As per the use of weapons in normal Fudge, Armaments and Protection are rated from 0 to +3 and higher. A rating of 0 may mean it provides no numeric advantage but there are other advantages to using Armaments and Protection as above. The value of Armaments and Protections can also fluctuate in combat. In general you have static ratings and you have decreasing ratings. Static rated Armaments and Protections maintain their rating as long as they are being used. This is the standard for melee-based weapons. However this can often mean the Armament or Protection can be dropped or lost in whole, like dropping a sword. Armaments with decreasing ratings will decrease in some value each time they do a certain amount of hit-points of damage. Likewise, Protection with decreasing ratings will decrease in value for some value of hit-points of damage they stop, like a shield or a blocking weapon.

Other parties in a combat can provide Protection to a character. For example, one party could do continuous cover-fire so that another party can reach better cover (better Protection) from a hidden sniper. The rating of the Protection is, generally, equal to the Degree of Success. The same is not true for Armaments. If an ally attempts to “aid†in an attack by providing an Armament, they are essentially a second attacker.

Combat Manoeuvres

Skills can provide Combat Manoeuvres. These are special actions or effects that your character can perform because they have learned or practiced them as part of learning/using that Skill. They can improve attacks, gain initiative, provide protection, etc. and can even break the rules (a bit).

Manoeuvres can be used to distinguish one Skill from another Skill used in the same type of Combat. For example two Martial Art skills could provide different Manoeuvres. Boxing may give powerful combos for Manoeuvres while Judo may give Manoeuvres to grapple and throw an opponent. Non-physical combat also makes use of Manoeuvres from making sophisticated play on words for social combat to debate techniques in arguments. Manoeuvres can also help to highlight the specialised benefits of any particular Skill. For example, an Assassin Martial Art might have “Surprise Stun†or “Surprise Killâ€. These two manoeuvres both require the assassin to have the element of surprise but if successful do twice or more damage and ignore many types of Protection, the fun is getting close enough to use them! No other Skill will have such an “instant kill†kind of manoeuvre. Manoeuvres, of course, can be used at any time but they are most useful during Personal Combat.

Basic attacks and defensive moves can be considered implicit manoeuvres for a Skill; once you have a particular Skill at any level you can do (or attempt) the basic attack and defence for that Skill though you have to decide what it means to attack or defend with that Skill.

The number of Manoeuvres a character knows for any particular Skill depends on the rating of the Skill. A character must have at least Fair in the Skill before they can learn or train a Manoeuvre.