if (!isNative()){return false;}: De-People-ing Native Peoples in Sid Meier’s Colonization

In a previous post I asked if the game Colonization was offensive enough. That post explored my own experience playing the game as a way to think through what the game means and what it says. As a result of that post, Rebecca Mir, an M.A. candidate at Bard Graduate Center, worked up a rather extensive paper exploring some of those issues in further depth. In preparation for a book chapter on the game that Rebecca and I are working on we thought we would take the opportunity to blog through and invite a broader discussion of some of the ideas that we hope to engage with in that chapter. This will likely be the first in a series of posts which we co-write. In this post we explore what happens when you make Native peoples playable in the game.

Making Indigenous Playable Characters: Setting bPlayable to 1
When you play Colonization you do not have the option of playing as indigenous peoples of the Americas. You’re meant to be the European colonizer; you go over and start colonizing. With that said, it turns out that it is actually relatively easy to change that. Even after a slight modification to make them playable, however, the Natives aren’t really playable in the same sense as the Europeans.

As Androrc the Orc explains on Civ Fanatics:

It is very easy to make natives playable (you just have to change the “bPlayable” field in CIV4CivilizationInfos.xml to 1), but the gameplay is uninteresting… almost no buildings, little options for play, etc… That having been said, things could be done to improve them, perhaps to the point of making playing them be interesting, but a way for them to sell their goods, among other issues, would have to be thought out.

For the sake of comparison, below are two images, one of the city screen from a European power and one of the city screen when you turn on bPlayable and play as a native.

A Functional Colonial City
A Functional Colonial City
A Non-Functional Native Ghost City

The image of Tenochtitlan comes from Robert Surcouf who quite eloquently captures the sentiment of the situation in his comment, “There is not much in Tenochtilan, but it belongs … to me. To us at least, the absence, the ghost town in the Native city speaks explicitly to the limitations placed on native peoples in the game. To make Natives playable in a way equal to that of the European powers in the game, we need to more deeply explore what rules Colonization has used to define what Native peoples can and cannot do.

if (!isNative()){return false;}:Removing People-ness through exceptions
if (!isNative()) appears in CvPlayer.cpp, one of the core game’s files, 23 times. When it is put in the context of if (!isNative()){return false;} the logic of the sentiment reads like a sentence. If a given people “isNative” then the game should “return false,” that is, the system should negate a given rule set in place for all of the other peoples who have not explicitly been marked as “isNative”. What matters here is that the isNative label is used to turn off the abilities and characteristics of what it means to be a people.  Edit See the comments below. The struck through sentences are, in fact, exactly backward. Disregarding those sentences, the idea behind them remains, isNative is how the game assigns new properties or removes characteristics from the Natives. I’m not going to cut up and rewrite the whole post now but I wanted to make sure this was corrected for any new readers before getting too far into the post. I also struck out the ! in the first sentence. isNative appears 23 times in the file seven of those times as part of !isNative End Edit

Throughout this CvPlayer file there are a range of statements that provide peoples in the game with particular abilities (determined elsewhere in the games code). What is interesting about this particular way of setting up and building Colonization is that Native are largely explicitly created by the negation of rules that grant particular characteristics to the colonial powers. From the perspective of the games source code there are normal peoples (colonial powers) who come with a range of abilities and characteristics and then a set of exceptions that strip many of those abilities away from peoples who are flagged as “isNative”.  Here are a few examples of how you can override these issues.

Natives were created by consciously turning off individual characteristics of standard peoples in Civilization IV. That is to say, Native peoples are not a different kind of entity in the game; they are quite literally another kind of people. We’re not really sure what exactly to make of this, but here are a few preliminary thoughts.

The game resists making natives playable, but it exposes its logic in the process
We can read the model of the game from our experience but we can also open up the files and start looking at exactly how the game’s model works, and explore exactly how those rules are enacted. This is just a first peak under the hood; we would by no means suggest that we fully grasp how things work here. With that said, when we open things up and poke around we can quickly save changes, like turning bPlayable to 1, and start up the game to see the results of those changes in the game world. The Natives are only one digit away from being playable, and if we make that change, we can go back into the live game and see what happens when they become playable. This kind of code tweaking has a corollary in the idea of deforming texts to better grasp and appreciate their meaning. In modding and editing the source of the game, in deforming its source code, we come to learn more about how the game models the world. While it is easy to make a switch, and turn bPlayable to 1, the game resists our ability to make Natives playable in the robust sense. In the process of tinkering with the code, the limitations placed on Natives are exposed. To this extent, we think it is clear that poking into the code helps us develop a much richer understanding of exactly what differences exist in the experience of playing the game.

Is there extra functional significance of this code?
One of the tenants of critical code studies is that there is often extra functional significance to code. It would seem like code written to model indigenous peoples within a game already critiqued for its offensive nature would be a likely candidate for extra functional significance. On one hand, the fact that indigenous peoples are so close to playable, literally one character away from being playable, is intriguing. Once we flip that switch, the game exposes exactly how limited the Natives are.

What should we make of the fact that much of what defines Native peoples in Colonization is enacted through the negation of abilities granted to the colonial powers in the game? There is no way around it; at the level of the scripts the game systematically and explicitly removes things like civic development from Native civilizations. We can actually see the sections of the code that strip away particular features of what it means to be a robust people in the game. In this sense we could say that we can see the colonialism of the game represented in the colonialism of the code. With that said, it is clear that this is a relatively efficient way to write code for the game’s peoples. The Natives are not the result of special creation. In effect, the scripts speak them into existence at the level of code as a defunct, stripped, and inhibited version of their oppressors. To what extent do we think it matters exactly how the rules of colonialism are enacted in the scripts? Until the guidance from some discussions in the Civ Modder community prompted us to look under the “hood” of the game we did not know exactly how things like peoples were modeled in the game. We could argue that this is simply an efficient way to enact the experience of the game, one that is largely borrowed from the earlier Colonization games, and one that is actually fundamentally different in the Spain and Inca expansion pack for Civilization V.

What can we say about games that invite us to change them?
Elsewhere Trevor has suggested that the modifiable nature of games like these prompt a challenge for exactly what we can say about them. How exactly does one comment on a text that comes with instructions for how you could go about rewriting it? In this case, as we step in to modifying the game it becomes clear that despite our best wishes to modify Colonization to play as a Native American culture, the intentions behind the model of society in the code itself resists our actions. Sure you can make the Natives playable, but once you do, you are faced with a range of rules that make that play problematic. If we dig further and over-write those rules we discover that the game sort cannot be won unless we can trade goods with a king in Europe. In any event, we think we can say that the models in the game’s code, while rewritable, inevitably carry with them some extensive inertia. It would take a substantial amount of  work to overcome the inertia set in motion by the way that the game’s designers modeled the world. This inertia, powered by rules for winning the game and the exceptions placed on Natives in the code, resists our desire for a revisionist experience of Colonization in which Natives are robust playable people. Attempting to mod the game only further communicates the authorial intentions and implications that result from its design.


  1. “When it is put in the context of if (!isNative()){return false;} the logic of the sentiment reads like a sentence. If a given people “isNative” then the game should “return false,””

    Nope. It does the exact opposite; the ! means not, so if people aren’t natives, we return false.

    1. Author

      Thanks for the comment. That is sloppy on my part and I apologize. Now, while that one is backwards it doesn’t change the bigger point of the analysis. The result of how isNative is used is that a range of capabilities available to other players is turned off, and you can see those by switching bPlayable to 1 for the natives. So, while it is an embarrassing misreading in the particular instance I don’t think it changes any of the substantive points in my post. Thanks for taking the time to point this error out.

  2. Actually reading “(!isNative()){return false;}” in English comes out as “If this is NOT a native, return false”, with an implied “If this IS a native, then there’s still more code to run specifically for them”.

    You’ve read the code completely back to front. There are MORE capabilities for the natives than for the player in this instance (can’t say if other parts do remove functionality, having not read the code, but this is definitely doing more work for the natives than for the player).

    1. Author

      Right. It was a poor choice for an example. This bit is exactly backwards. What it does illustrate is how the code differentiates between the natives and the colonials and adds and removes capabilities from them as it goes.

      Aside from the particular example, isNative is the means by which the game turns off all of the range of capabilities that the colonial forces have available to them. You can see this by switching the Natives to playable and seeing exactly what they can and can’t do.

      1. That the code differentiates, and how, isn’t significant. I’ve worked on codebases that had isFemale() and isSriLanka() and isNetworked(). The existence of these methods doesn’t indicate that females or Sri Lankans or network clients are being treated as non-people.

        Would it really be a more compassionate and less “colonial” codebase if I used a component model to add functionality to my races, rather than an if statement to handle the one special case?

        The actual code that is called only for natives or only for non-natives is what you should be focusing on.

  3. This article is baffling. You are reading broader political intent into game design, while game design is inherently broad abstraction.

    “Colonialism of the code” is the most awkward thing I’ve read in a while. You seem to at once criticize, and then immediately concede that you are making a silly point. It’s constantly one step forward and one step back and you end up nowhere.

    A painful read as a programmer, and provokes more head-scratching and facial contortions than afterthought.

  4. Any game that differentiated between ‘native’ and something else would have code with similar functionality. If it is possible to make a game that differentiates between natives and non-natives that is not offensive, then the existence of an “isNative()” is totally irrelevant.

    I can see how code can have extra-functional significance (not “extra functional significance,” which is something completely different). The choice of “native” as a description certainly has significance, but its significance is that it is _not_ an offensive choice (very different from the “FeministWhore” variable on the page you linked).

  5. “What separates a Goomba from a Mario Brother? Looking deep into the code, we see that a Goomba is simply a Mario Brother whose actions are limited by developer fiat. Why should a Goomba not be able to jump? Why must a Goomba insist on walking straight ahead until it collides with an obstacle, besides that the developers of the game insisted it must be so? In fact, if we change the player character to a Goomba, take a look at the title screen. As you can see, it continues to read “Super Mario Brothers”. What sort of authorial implications can we derive from the fact that this is so, besides the most obvious, that a Goomba is deemed unworthy by the imperialist developers of possessing a title screen of its own, that a Goomba is not even on the same level as a Mario Brother?”

    1. ^ This, Exactly. You’re reading WAAAAAY too much into this. The fact is, while Civ models itself on real civilization, it is very much a video game, designed at being a fun interactive experience. It is not a simulation. It constantly abandons realism to make a simpler, more fun GAME.

      You could just as easily write an article analyzing the political undertones to how many points a country gives you in Risk.

    2. Well, the obvious answer is that the Goombas have been deemed to be of lesser interest, for whatever reason. Players are meant to identify with the Mario Brothers to the point where they feel comfortable doing anything they please to the Goombas. Even if it means killing them.

      This doesn’t make the developers imperialist, but it is interesting and problematic, considering the fact that there are many Goomba tribes that have fascinating and long-lived cultures. They weren’t literate for a long time, so that’s part of the problem. We just don’t know as much about them and their tribal histories.

      I just want to be very clear: we didn’t write that the developers are racist. However, it is interestig that

      1. Oops!

        However, it is interesting that people made that cognitive jump. And Goombas are not a historically marginalized group that actually exists in real life. So the comparison is good for understanding why Colonization is so controversial and why Mario Bros is not.

  6. Perhaps the native peoples are limited in this way because they were supposed to be playable in an expansion that was never finished?

    1. Author

      We didn’t really get into this, but the new Version of Colonization is actually written as an extensive Mod ontop of Civ 4. So, most likely, the reason things are set up as they are is that the game is a set of modifications on top of the existing game.

  7. Reiterating what everyone above me posted, you’re reading way too much into it. At times, it’s almost like you’re trying to make the code seem more controversial than it is, either to get more views, or simply out of ignorance. Ignorance by itself isn’t necessarily bad, but it definitely is when you say something potentially inflammatory based off of uninformed assumptions.

    The devs weren’t being deliberately racist, and it’s not indicative of some deep-seated, unconscious prejudice. Code is functional. While it is also an outlet of creativity and there are a variety of ways to achieve the same ends, there is no inherent racial bias in how something is programmed. The goal is to make it work, then make it work efficiently. There is simply no room for racial bias in the process simply because syntax is so strict. To create any sort of racial bias in code would require some very deliberate efforts. (See below =3)

    The isNative() function is there to distinguish one bit of code from another and handle it according to the specifications and requirements of the program. It is not meant to serve some racial agenda by separating one group of people from another and placing limitations on them to make them seem inferior. If you intend to blame someone for making potentially offensive specifications, the code isn’t to blame.

    There’s no such thing as prejudiced code, and unless there’s something like the following, it’s safe to safe to say it’s not deliberately racist either:

    /*racial slur*/
    class Second {bool isRacialSlur() {return true;} … };
    int racial_slur;

    Of course, there are definitely more subtle approaches to racist code, but they’re far too long… and wouldn’t be funny without any programming knowledge. Even that ‘second class’ joke is pushing it.

    1. Naufrago, thanks for your comment. I want to make one thing clear before I proceed: we aren’t saying the developers are racist. We even speculate in the post that this was just an efficient way of writing code.

      Moving on from that (and putting aside our ! mistake for the moment), you said that code is written to be functional. Many players in the mod community were frustrated that they couldn’t play the Natives and tried to change that. It’s the developer’s decision to make the Natives unplayable that I find problematic, and this is shown in the code. Because as you said, the code is meant to be functional.

      We aren’t saying that coders are responsible for the decisions that the rest of a game dev team might make that are questionable (like making Natives unplayable). Heck, we even said we weren’t sure what all of this meant.

      However, I find it helpful and interesting that so many people got defensive about our prodding (plodding, haha?) around in the code. One Rock Paper Shotgun commenter wrote that we “had no right.” Because historians aren’t meant to look at how an artifact works? Or because maybe programmers and game developers don’t want their work to be analyzed? Or misinterpreted? Which is, of course, a possibility if coders and historians don’t collaborate a little.

      I very much appreciate your bit of racist code. I would be interested in what other interpretations programmers would have if they had written this article. If you, for example, assume that the code *does* have extra-functional significance, how would you interpret it?

      Going back to our mistake, I’m glad the coding community has pointed this out. As Trevor stated at the beginning of this post, we are working on a book chapter and wanted to work through our ideas in a series of posts. We are glad for the corrections and the discussion that our mistake generated. It was not intentional.

      So I urge anyone frustrated with our post to judge it based on what it is: a blog post on an academic blog, written by a Historian and a Material Culture specialist, as a part of a series in preparation for a bigger project. Of course we are reading into the game. Games are important cultural artifacts. And they will be closely scrutinized in the future. And that’s a great thing; no integral part of human existence should be free from such scrutiny.

      Again, thank you for your thoughtful comment. I hope mine has cleared up some issues.

      1. Hey Mark, I absolutely agree. I like John P. Meier’s distinction between the real Jesus and the historical Jesus: we cannot know the real Jesus (unless one day we can hop into a time machine), but we can try to reconstruct some aspect about the historical Jesus based on priotbilbay. Also, Bill Arnal’s Symbolic Jesus does a good job exposing motives on all sides of the debate, though I disagree with his conclusion that the historical Jesus research does not matter for history or for faith.

  8. the concept that something like “critical code studies” actually exists is same part fascinating and bewildering for me.

    the primary reason for a bPlayable variable for a game faction which is clearly not intended to be playable from the game rules is for testing purposes. At some point the programmer needs to try out if the restricted rule set for the indigenous faction is working as intended so that the A.I. who will control their behavior later in the game will not start building battleships or similar.

  9. I find it interesting that the same people who came here as well as RPS to criticize the authors for “reading too much” into the code failed in actually reading the article with any care for detail or nuance.

    Perhaps you would do well to “read too much” into something yourself. The overcompensation may lead you closer to the bulls-eye.

  10. It should probably be mentioned that the developers, by the constraint of game design, never intended the native factions to be playable, and never assigned them equal status to the four colonizing forces. Criticism for this design decision is unfair, as the authors seem to be asking for a change in design merely to satisfy our politics. Perhaps the authors would be better playing Europa Universalis, where every faction is playable, and mere survival is a mark of achievement?

    Also, I would like to note that in beginning and middle stages of Colonization, native factions are meant to be respected and sometimes feared. A declaration of war from a nearby native faction can utterly destroy a carefully planned logistical machine; one that the authors were so bored in constructing.

    1. I think the interesting aspect of your first statement is the idea of ‘game constraints’- obviously, the designers could have ‘coded’ the presence and playability of natives, but they simply chose not to do this for either design, budget, or other reasons. Also, the idea that the Natives were not seen as ‘equal’ to the Colonizing powers also speaks highly to the inherent cultural narratives at work in constructing these ‘simulations’ of the past. The idea the authors of the post advocate, that the natives are rendered by their absence of characteristics and not by their additive qualities, also plays into an enduring and still prevalent cultural narrative many in North America share with regards to Native populations. This is not to say that people, or the coders discussed above, harbor ‘racist’ tendencies- rather, cultural narratives hold deep sway on the formation of our worldview and while these influences are difficult to uncover, they nonetheless are powerful factors governing our lives today.

      For example, you mention the possibility that a native faction can wipe out an early civilization through their aggression, yet the game does not allow native people any possibility for ‘civic development’ (as noted above), thus one could see this as playing to the prevalent narrative that Natives were ‘Noble Savages’ that while fearsome and aggressive could also be ‘pristine’ in their innocence from modernity. Of couse, this is not true at all, yet it would not be a far fetched assertion to say the game code mimics this prevalent and erroneous narrative. I highly suggest reading ‘Indians in Unexpected Places’ by Philip Deloria, as the essays in his work discuss this topic in depth.

      Now you may feel that code isn’t capable of holding these cultural narratives in its syntax- but many other cultural scholars have shown that far more mundane objects than code carry significant cultural weight and implications. So I would at least entertain the possibility the authors have something to criticize.

  11. Thanks for a terrific article Trevor and Rebecca, and congratulations for stirring up so many people to respond. You almost stirred me to craft a separate PtP posting on this topic, but I wanted to respond more informally and keep the credit/focus where it is due on your thought provoking article.

    I want to share a couple of thoughts that might lead to greater understanding/bridging of the disagreements in the posts.

    – It is the perhaps the single most important feature of scholarly criticism, as teachers well know and students often rue, to slow people down when they examine a work, and get them to dissect and disentangle it. I suggested this in my long ago PtP post “The Unexamined Game is Not Worth Playing?” which I’ll just quote here: “to be a lifelong learner/ educated human being/ seeker of truth/ philosopher (pick your preferred term) is predicated on the drive to explore and examine, to question and challenge all components of the human experience. To live life without doing so is certainly possible, but the hallmark of the critical approach to anything is to slow down, examine and question. When we do, we engage in meaningful intellectual activity that will, in the long run certainly and often enough in the short run, broaden our capacity to analyze, our ability to understand, in short our intellectual selves.” So Trevor and Rebecca’s investigation is highly justified on these grounds

    – I fully understand, having had this conversation with many, including game designers, that it can be unsettling to have what was made for entertainment be subjected to this kind of historical/cultural/social analysis. There can be a fear that such an analysis means a criticism of the designer, a proposal that the designer is harboring hidden intentions. The authors of this post have more than reasonably made clear that they are not criticizing the designer. I’d like to go a step further. I have come to appreciate and sympathize with the point that, to many game designers and coders, the practical programming concerns are paramount when they did their work. I appreciate that it can seem disconcerting or silly that we poke at the work of game designers in ways they never intended. At the same time, there is no question in my mind that when a game fits the standards of a portrayal of a historical past it is perfectly valid to ask what it suggests about the past and whether that is accurate, and why it is designed that way. Sometimes the answer is for expediency’s sake and it is important to recognize that coding a simulation is by nature an act of quantification that will result in certain ways of representing reality that may not mean anything in particular on the designer’s. So it may well be in the case of Colonization that since the game requires quantifiable powers, bonues, etc. to function, it was expedient to quantify native cultures this way. One could conceive for example a game quanitifying the skills, abilities, and goals of native cultures and the colonizers being coded as non-natives, lacking the essential abilities. part (a cigar is just a cigar). Other times design choices simply must reflect a basic sense of how the designers perceive the world works. There is no doubt in my mind that when the original SimCity had the raising of taxes increase unhappiness, the designer was incorporating a basic assumption about how the world works – or perhaps intentionally caricaturing that view. There is no doubt that when Total War designers make units flee when their morale is too low that the designers are assuming that morale played a significant role in battle and that armies did not just fight to the death.It’s so important to note, however, that we all do this; we teachers, especially, present the past in ways shaped by our assumptions countless times each day – it’s just that our work is not able to be subjected to the scrutiny that a popular game is. One last thought on this. I can’t remember who said this (I wonder if it was JH Arnold in his great little book on history) but it was something to the effect of “practicing history means subjecting documents/texts/art/artifacts etc. to questions that they were never designed to answer.” Speeches, letters etc. are not writing mostly to inform historians and certainly not to inform high school students (in my case), but as historians we use all interesting available and helpful evidence and models. Games count.

    – Finally, and again this is why I think this article/approach has such merit as an effort: It is educationally (writ-large) valid and useful to ask how a game represents reality and why it does. This does not require nor should it involve blame (and again, I am quite clear that designers are not being blamed in this article, rather design choices are being explored). Designer assumptions, catering ingrained cultural conceptions, computer hardware affordances, financial and corporate constraints and in my mind, quantification bias (which I’m working on teasing out in some of my other writing). All of these can be at play. When we are studying such an important mas media understanding how any and all of these factors shape our visions of the past is valuable.
    Thanks for the article!

    1. I have the impression that there is a misunderstanding between the commenters who are confused by this article and those who approve it.

      As a game programmer for me it is important to differentiate between the source code and the actual rules of the game, ergo the game design. I think Trevors previous article handled the game rules and resulting dynamics very well.

      So why this article ?

      As a programmer i read the essence of this article primary like this : “Why are the restrictions of the Native American factions hardcoded in c++ and not easy changeable in the XML files ?”

      Because of the very limited rule set, that the Native American factions can use, and because the complete lack of winning conditions, i assume it was to much effort or not they don’t want to spam the xml configuration files.

      What interests me, did somebody programmed a mod with a complete new rule-set for the Native American factions so it is actually interesting to play those ?

      1. Author

        I think my short answer to why this post in addition to the other post is that I think it is really cool that we can pop open the hood in a game like this, that has substantial amounts of uncompiled code in it, and see some of how the game actually makes the rules we experience happen. We do a lot of hedging in this post in terms of what kinds of things we can or should be able to say with this potential set of additional information. I am still interested in exploring and thinking through what it is we can actually say as a result of exploring this additional layer of information.

        To your last question, yes, there is a mod of Colonization where natives are playable. It just happens to take place in the future. See this thread http://forums.civfanatics.com/showthread.php?t=349050 for info on that mod and see this thread for discussion of some of the hoops they had to jump through. http://forums.civfanatics.com/showthread.php?t=447895

  12. Hi Trevor. As with many of the comments from technically-oriented folks, I have to say that I have a somewhat hesitant reaction to your work here. On one hand, I am delighted that a humanities scholar has chosen to engage with some code. On the other hand, I’m not sure that we’ve learned anything from the approach you’ve taken.

    I’ll back up for a moment and say that I really enjoyed the earlier post you referenced, where you examine Colonization as a game, from the point of view of the user. Computer games certainly embody and perpetuate all sort of cultural elements, and we absolutely should be looking at them critically. But when you get to the source code, what is it that you hope to learn? In fact you ask this question directly:

    “What should we make of the fact that much of what defines Native peoples in Colonization is enacted through the negation of abilities granted to the colonial powers in the game?”

    My answer would be, very little. This appears to me to be an artifact of the process by which the game was constructed. In my view, this is not where the action is. My contention is this: once the game designer decides that “natives” will have limited capability, the code that implements that design is of limited interest.

    Let’s consider for a moment how one might write the code for this game. Natives and Colonizers have similar properties; both move in turns, consume resources, have specific “units” in specific locations, etc. So it makes sense from an engineering point of view for these two abstractions to share code, if possible. Colonizers have additional capability. We could either define Colonizers as extended natives, or define Natives as reduced colonizers, or actually we could have almost arbitrarily complex different relationships that others have alluded to above (e.g. “mix-ins.”) The programmer chose one particular route. Is there significance in this point? I argue that the answer is “probably not.” It probably just seemed like the shortest route from here to there, given that the game design already called for particular behaviours.

    An analogy from another field might be as follows: let’s look at spark plugs. They’re awfully phallic. Is it coincidence that the initiator of action in a combustion engine is so clearly male, or is this a result of the patriarchal culture in which the engine designer is embedded? What I actually think happened is this: to save material and preserve the interior geometry of the cylinder (necessary for fuel efficiency) the opening into which the plug fits should be narrow. But the metal of the cylinder must be relatively strong, meaning thick, and also we wish to keep the electrical cabling away from the hot engine, which drives the design toward a long, thin object. In the end, I find it much more plausible that spark plugs are shaped the way they are for banal, but very real, engineering reasons.

    You touch on this by noting “it is clear that this is a relatively efficient way to write code for the game’s peoples.” Exactly. In fact I think this completely undermines the extra-functional significance you are looking for.

    I am also unclear to me what alternate conclusions your investigation could have come to if the game was implemented differently. As you note, “There is no way around it; at the level of the scripts the game systematically and explicitly removes things like civic development from Native civilizations.” Perhaps you could have found, instead, that Europeans are encoded as “super” natives, with added capabilities (via subclassing or other software design mechanisms.) But would we really come to a different conclusion in that case? We could instead write: “There is no way around it; at the level of the scripts the game systematically and explicitly grants things like civic development to Colonizing civilizations.” Is this a logically different statement? The resulting game would be identical, from the player’s point of view.

    After critiquing the game design proper, it seems to me that the only additional thing we might hope learn from this kind of close reading of how the code is constructed is something about the mental state of the programmer. Maybe the programmer really did think of Natives as some sort of restricted Colonizer. Or maybe it just worked out to be easiest to engineer it that way, or perhaps it’s a historical accident involving early versions of the code and an evolving game design. Or maybe it just made testing easier, as another commented has suggested. Such considerations can also accounts for the bPlayable flag. We simply cannot know, without additional knowledge of the processes by which the programmer made these choices.

    In short, while I applaud your attempt to learn from the code, I do not think you are looking quite in the right place. Analyses of what code “means” must necessarily be heavily based on the constraints placed on the programmer during the act of coding — constraints that come both from pre-specified designs, and from various engineering realities. When considering such constraints, I don’t find any particular extra-functional significance here. In my view, the programmer did something very straightforward, and the cultural critique needs to be directed instead to the game designer.

    1. Jonathan this is a very well written summary of all the thoughts i had with this article. well done.

    2. Author

      Thanks for the comments. The primary purpose of this post was to try and explore what it is that we can learn from and understand about the game by looking at the parts of its code we have access to. I would agree that the way a games code is written is an artifact of the processes by which the game is constructed. With that said, I think those artifacts are really fascinating. If you are looking for a better example of the kinds of things you can discover when you are reading through a games code I would suggest Mark’s post about reading the comments in the JFK reloaded game.

      As for your spark plugs example, something looking like a tube makes it phallic, so yes, there are all kinds of things out there that have a phallic shape. It is one of only a handful of shapes for things to show up in. This is totally different than writing code that systematically removes capabilities from people in your game called “Natives.” I think there is a ton of potential value to understanding the details of how the game actually enacts this kind of thing.

      With this said, I think it is fair to say that we didn’t learn a ton about what it is like to play the game from this particular exercise. The post was less a “here is what we learn from doing this” than a “here is the kinds of things we could go and look at.” If someone wants to, you can actually go through and get in to many of the details about exactly how Colonization represents people and peoples. What is particularly cool about the fact that this game was written as a mod on top of Civilization is that a lot of it is python and XML files that you can open, read through, and tweak. In the process we can learn a ton about the nuances of how the game actually produces the experience we get when we play this. So, this post is more of a peak under the lid of the game than a full exploration of what we find inside.

      In short, I think there is a tremendous opportunity here to explore and further understand exactly how a given game works when you can tinker with it.

Leave a Reply to gobaers Cancel reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.