acg's mkblog

back to blog homepage

how not to fake your level of abstraction

turgid ramblings

some background: I’ve been interested in developing a semi-formal theory on authenticity in games for some time now, but I hardly ever pursue it directly. it comes in waves. last week, a wave hit me while I was watching some video ethnography. the videographer and several subjects were gathered around a stove in an extremely small enclosure. suddenly I was overtaken by an aesthetic feeling of presence, particularly because of the unclear-if-intentional found-footagey nature of the content.

I experienced a sort of quale, I suppose. nothing much was really going on: minimal conversation, fire-stoking, lazy cigarette smoke. but perhaps in contrast to this, I was struck by the intuition that this scene was not trivially simulatable (or modelable). examining this intuition led to some further development of what I believe to be a more authentic way of representing artifacts in games; a more authentic method of game design.

so, I’m working in the creative sim / sandbox genre, right? abstraction is something that designers in my space deal with a lot, whether consciously or unconsciously. ultimately our goal is to interpret some kind of physical and/or social system via modeling. (note: it doesn’t have to be an extant or even “real” system, but don’t get me started on that…)

the systems we model are typically complex systems; they are very difficult to model due to various properties shared by all complex systems. and so, as game designers, we abstract. this enables us to interpret these systems subjectively–a chiefly artistic and/or political requirement–and satisfies a very practical desire to minimize scope.

abstraction principally involves taking several things and reducing them to one thing. this implicitly creates a hierarchy. for example: galatea, nidhogg, and thirty flights of loving are all games. in this case, “game” is an abstraction of those three entities, creating a “subsumptive hierarchy”: nidhogg is a type of game; the concept of a game subsumes nidhogg (as well as the others). this is just one of many ways to apply abstraction; alternatives include the mechanistic approach (a pendulum is composed of a mass and a cord), and the attributive approach (the sky and the ocean are both blue).

abstraction is mostly intuitive. humans are very good at it–it may be one of the most powerful contributors to the fitness of homo sapiens–but that doesn’t mean we’re good at doing it correctly.

see, the thing is, not all abstractions are created equal. one way of looking at abstraction is through the lens of compression. the idea is that you cherry-pick some concepts, remove their differences (thus eliminating detail), and come up with a name for what’s left. but be careful: what you keep and what you remove matters. and at the end of the day, you can never get back what you’ve lost.

the more you compress, the higher the level of your simulation. this is called “choosing your level of abstraction”, and the level of abstraction you select has serious implications for what you’ll be able to pull off in your game, as well as your representational responsibilities.

first of all, some details are worth more than others. all systems have the capacity for emergence, but the further you abstract, the more difficult it becomes to capture it (e.g. consider abstraction in the extreme case). try not to remove details key to the kind of emergence you are attempting to engender. also, what’s core to your game? what about the physical model is relevant and/or interesting to you? these are the details you need to keep–everything else can go in the trash.

v v v

second of all, remember that abstraction (by definition) creates an ambiguity in specification: a loss of detail. once that detail is gone, you can’t get it back–not without lowering your level of abstraction.

however, many game designers valiantly try and fill in the details anyway… at the cost of authenticity.

here’s an example: you’re making a game about human society (like me). you decide you don’t want to model facial expressions, gestures & gesticulations, body language, etc. so you decide to abstract all of that stuff into a more general concept, say, “communication”. great. agents pass messages to one another–how they do it isn’t specified exactly, you’ve just explicitly implemented a catchall “communicate” verb. meanwhile, your experience is still emergent, sufficiently complex, and didn’t take a million years to build. awesome.

unfortunately, now you have nothing to represent your agents with. because they have no facial expressions, they have no face. because they have no body language, they have no body. because they don’t gesticulate, they have no limbs. oh no! what are you going to do?

if you’re a Naughty Designer, you’ll call up your artist friend (or rustle up your artist self) (or fax your art department) and throw together a rig. a few bones and a couple animations later, and you’re off to the races! one fully-rigged and animated Human, ready to complement your high-level message-passing algorithm. but there’s a big problem with this. what you are doing–fundamentally–is faking your level of abstraction.

v v v

see, when you performed your abstraction, you removed a level (or several levels) of detail. you can’t then go back and fill in that empty space with fake details. that’s replacing a system with content! this is heresy. more precisely: you are substituting a multiplicity of specifications with a single specification, held constant. so whenever the player looks at your game, they won’t see your glorious abstraction, they’ll just see the one, lame entity you threw in to represent everything below your level of abstraction. the representation is tokenistic–and this shatters authenticity.

“okay” (you say). “but what if I hire a hundred artists, and we make a thousand rigged characters?”

actually, that kind of works. but it’s principally flawed. allow me to explain. I suspect that this problem scales nonlinearly with system complexity, as well as with degree of abstraction. we know from above that a lone specification is bad (i.e. if one is sufficient, then there is nothing to abstract). but how many specifications do we actually need to achieve full coverage? the answer is a function of the system, your level of abstraction, your desired level of fidelity, and probably also the brain’s natural limit on how much complexity it can handle at once. for very simple systems, this number might be small. but we shouldn’t bank on it.

that being said, if your level of abstraction is pretty low, and the system is pretty simple, and maybe if you have some kind of advanced fakery that involves “procedurally generating” multiple components at a fixed level of granularity that combine in various ways–it can work. and I’m not being sarcastic; I really do think that “making more content” is a viable strategy–just a dangerous one. the rock is a failure to make your game engaging to players, and the hard place is infinite billable artist hours.

as an aside: one of the reasons why writing–and to a lesser extent film–works is because its content growth rate (per complexity, abstraction) is small relative to interactive media.

back to the drawing board. what about, instead of calling your artist friend, you decide to reignite the lofi style of the past. ASCII is the way to go: just represent your humans with @. it’s culturally acceptable; more importantly, it matches your level of abstraction. players don’t expect symbols to wave their “arms”. problem solved, right?

definitely better. but there are some issues. the first one is that it’s probably harder to read. after all, if you’re making a game about humans, players expect to see something resembling a human and not an email address. more importantly, your representation still includes specific detail! it’s just that, instead of specifying detail relevant to your model, you’ve specified detail relevant to some other model. in this bizarre lexical universe you’ve constructed where all things look like characters in the latin alphabet, you’ve arbitrarily decided that everyone (or everyone of some type) is represented by an @ symbol. what a zinger! you’ve substituted one detailed representation for another one, just on a radically alternative substrate. this must be contemporary art. unfortunately, while players may be fooled for awhile, it ultimately suffers from the same problems as above.

finally, there are also hybrid approaches, like meeples, where you abstract a bit, but also specify a bit. what we really need is a way of wrangling specification. so what can we do?

v v v

my (tentative) proposed solution is what I call “shrouding”. basically, instead of replacing compressed details with a limited set of representatives, or with a specified representation at a similar level of abstraction, you just… cover them up. the idea is to use a representation that superficially looks kind of human (in this example), but prioritizes evocation over realization. for example: instead of injecting specific, artificial detail (e.g. animations) into combat sequences, you could place “brawl clouds” over the top of your characters.

v v v

another way of describing this is via the concept of an “open” representation, versus a “closed” one. closed representations, like the ones we have described so far, force the player to accept one specification of the abstraction. but open (shrouded) representations leave the specification open to interpretation. this relies on the player to do some creative work, yes, but in a constructively constrained environment. instead of forcing the player against the grain to do negative work on a closed representation, enable them to effortlessly fashion detail themselves with an open one.

if you will allow me to speculate further: this is one of the reasons why writing can be so effective. text shrouds implicitly (negative space), and the reader engages in a normative creative process during which they assemble a functional image in the mind. the challenge in visual work is that we must be explicit when adapting abstractions to authentic representations.

this would seem to follow the principle that I have seen described as “letting the player fill in the gaps”. and yes–that is almost literally what we are doing here. however, it’s important not to overuse and abuse this concept. “let the player fill in the gaps” is the ultimate self-justifying buzzphrase. but that’s a story for another day


back to blog homepage