I thought this was super interesting and I didn’t want to derail the other thread too much, so…at first my basic response to this was that the analogy was wrong, that the fundamental unit of IF is not the object but the ‘chunk’, that unit of text returned to the player after they perform an action (maybe there’s a better term?), and as a result the conclusions Paul drew from that analogy were misguided.
But on second thought I’m wondering if it goes a little deeper than that. You could look at the object tree literally as the objects in the game and how they relate to one another by containment, but is it more fruitful to consider the ‘object tree’ as another term for the model world? I think that may be a more idiomatic way it’s used. And text chunks are the player’s perception of the model world, right?
Going back to the analogy with cinema – in the early days of IF I think its developers (Infocom, etc.) were unapologetic about rejecting normal literary conventions. Contrast this with early cinema which took much of its formal inspiration from theater. If early cinema directors had been like Infocom implementors, they would have taken their inspiration not from theater, but from I don’t know what, abstract music maybe.
Anyway, the point is that with the renewed emphasis on story and narrative in contemporary work, there also seems to be a renewed inheritance of the formal conventions of literary work too. But I feel like this is like one step forward, two steps back. If we continue with the analogy to film (and you could draw this analogy across many other new media), IF will eventually adopt its own typical formal conventions that have less to do with its surface appearance as a literary work.
In this case, the object tree is at the heart of the matter, and so is the chunk.
Now what I’m not sure about but I think might be the case is that you could even say that the chunks are not just presentation of the object tree to the player, but are objects themselves. Think about this in relation to what Nick Montfort is doing with Curveship for example.
A next step might not just be to reconsider the object tree with respect to objects, their relations (containment, etc.), but to deal with chunks as objects. What properties do they have and how can you change them to communicate the work to the player?
The text chunk (meaning any self-contained descriptive or narrative message) could be the main superclass in a class-based IF system, above even a basic “thing” or “object” class. So, objects would be a kind of chunk, and so would lines of dialog, timers that print messages at specific times, etc.
Emilian Kowalewski has already used this basic philosophy with his Node-X CYOA system, which I have looked at and experimented with. I never heard of Curveship before, but it looks intriguing.
I like these two ways of breaking down IF design. But what’s interesting is that, in current systems, the model world and the output chunk aren’t particularly connected.
Chunks can be associated with objects in code (although this is less true in I7 than in I6), but the connection is shallow. To the extent that text chunks become varied and interesting, it’s because of ad-hoc logic in the chunks, which can reference any game state. And to the extent that the model world is interesting (customized changes in behavior, new relations between objects), it’s not reflected in the output chunks. (An object can have a description property, but the containment of one object by another has no description property.)
I used to consider the basic unit of expression in IF to be the player choice, i.e. everything that happened between one player choice and the next; which maps roughly (much more so than a modelled object, anyway) onto the concept expressed here as a ‘chunk’. However, I have changed my mind about this. The span between player choice is a unit but its a hybrid unit. It’s not the smallest-editable-but-still-meaningful piece the way a shot is in film, and it also covers too many media the way a shot doesn’t in film. It covers even flipping channels on a TV remote, if you think about it (a consequence of relying exclusively on player input as a delimiter of meaning). More importantly it doesn’t distinguish at all between CYOA and IF, and that is very counterintuitive to me. They are not like comedy and drama, or like documentary and music videos — all forms of cinema that share the same basic unit of meaning. Those are content distinctions whereas CYOA and IF are different in a much more formal way. I think the difference between those two forms goes very deep, so I do think now that the object tree is a better candidate for there being a basic unit of meaning in parsed IF; it’s the only discrete unit of meaning that is exclusive to IF. And it includes the concept of player choice, because without the choice of how to explore the object tree, it’s not an object tree – it’s just a sequence of text.
But you could definitely make a strong argument the other way (for ‘the chunk’) and I can definitely see that point of view. One could even allege that which model the designer feels more affinity can really affect the gameplay. People who think shot sequence is really important play a lot with shot sequence. People who think cinematography is really key to a good film play around a lot with light and colour, etc.
But I’m not sure I entirely get what you’re driving at. Anything could be framed as an object, but usually there is only a point to doing so because it provides hooks for regularised functionality. A string variable is already a chunk with regularised functionality (strings are actually usually represented internally in modern programming languages as objects anyway for exactly that reason). So we already have that, what would further objectifying bits of text get us, outside of the modelled world? I can’t think of something but it would be interesting if there were something but I’m not sure what you have in mind.
I don’t think player choice has much to do with the fundamental unit of meaning in IF. My opinion is that the most basic unit is the text description, because that’s what conveys all of the information about both story and puzzles to the player. Choice, or interactivity, comes into play only to the limited extent that the player can control when, which, how often, and if the units of description are displayed.
I think an object of the model world is composed of its various descriptions. An extension of the object tree might show the description “chunks” as being “children” contained within the object. For instance, an object representing a static scenery tree might “contain” two chunks – the long description displayed when the player examines the object, the short description displayed after the room description (which is a chunk belonging to the room object). An object that the player can pick up and move, such as our brass lantern, might also have two chunks – the long description and an inventory listing description. Maybe a special listing description would be another chunk. The generic “You can also see x, y, and z here” message is also a chunk, probably belonging to the meta room class.
All narrative messages carrying the story should be considered chunk units, although I’m not certain on their object relationships. It would probably depend on the circumstances; dialog lines could be “contained” within an NPC object, or a meta-object representing that NPC’s dialog.
Finally, although I believe that a unit of text is a more fundamental unit of meaning than the objects themselves, I agree that that the objects of the model world are the basic units of the individual game, as opposed to IF generally.
After I posted on this thread last night, I pondered the question of the fundamental unit of meaning in IF some more, and I realized that we have essentially come up with three distinct but not at all mutually-exclusive theories, which I’ll call here the Object Theory, the Chunk Theory, and the Description Theory.
According to the Object Theory, an IF game is simulated fictional world built on relationships between components of that world, which may or may not correspond to actual spatial relationships.
According to the Chunk Theory, an IF game is a program that produces specific chunks of text in response to a human user’s choices. These chunks of text describe how the user’s choice has or has not affected the state of the program.
According to the Description Theory, an IF game is an organized system of interrelated descriptions.
These different theories have different advantages for discussing different aspects of IF. For instance, it is true that an object is greater than the sum of its descriptions in the sense of what the game is communicating the player. That is, the player doesn’t think of the object as a few associated pieces of text, but rather imagines a real, physical object in his mind. Therefore, the Object Theory is definitely the best for discussing IF as an art or literary form. It is of great use to critics and reviewers, though authors must of course think in terms of the object tree as well. Also, this is theory that all visual maps that were ever created about any specific IF game is based on.
The Chunk Theory’s chief strength is that it actually describes the player’s experience as he or she encounters the text of an IF game. It is the only one of three theories that is directly concerned with interactivity. More than the other two theories, the Chunk Theory deals with IF as a kind of computer game. Because an author needs to be aware as much as possible of the “chunks” that the player may encounter, this theory is of great use to authors as well as to beta testers.
The Description Theory has similarities to both the Object and Chunk Theories. Like the Chunk Theory, it is based on units of text rather than on the model world. However, since units of description form objects (according to this theory), it sort of builds a meta-object tree, with the objects being formed by their descriptions. Therefore, it is related to the Object Theory. I think this theory is less useful than the other two in a practical sense. It is not concerned with the whole value of any component of an IF game, just as strict science is not concerned with the inherent value of a human, but rather describes the human organism in terms of its component parts. However, I think this theory has great potential for authors of IF languages and development systems to think of ways to organize the author’s written text to create a functional IF game.
I think you’ve slipped your definition of “chunk” from “any self-contained descriptive or narrative message” (as you introduced it) to something more like “everything that happened between one player choice and the next” (which Laroquod mentioned). Which?
Also:
Sure…
No, that doesn’t follow at all. An object-level description of a game does a poor job of representing the story as the player sees it.
When I’m discussing IF as an art form, I talk about game events and what choices the player is thinking about. Those have no direct representation in the program.
Yes. After my initial definition of “chunk”, I realized what I was thinking was not quite the same idea as what George introduced the thread with. As far as I can tell, his definition was more of all the text that is produced by a player’s command:
Therefore, I figured that my model of discussing IF was different from George’s, so I decided to call it the “Description Theory” in my next post. This “Description Theory” is not based on the “chunk” (as defined by George) at all, but on individual descriptions as the most basic unit of meaning.
Hmmm… The reason I was thinking that the “Object Theory” was the preferable model for discussing IF as an artform was that I thought the object tree is the only concrete way that the author of the IF game can express his artistic meaning. Basically, I’m agreeing with Laroquod in that the objects, and the relationships between objects, carry all the meaning of both the puzzles and the story. I agree that “chunks” and descriptions are both smaller units of meaning, but the objects in the model world – whether or not they are literal or abstract – are greater than the sum of their descriptions. The player reads various descriptions to learn about an object, but the human player forms a concrete literary or symbolic picture in his or her mind. Therefore, I feel that the object contains more symbolic meaning than the sum of all its descriptions.
However, because the player only knows about the objects based on the pieces of text that he or she has read (“descriptions”), I believe that the description is indeed a more fundamental unit of meaning than the object. (Note that this is presupposing an entirely text-only IF game. Adding pictures to the theory would complicate matters.) I was thinking that neither descriptions nor chunks are complete expressions of one unique part of the author’s vision, but I may be wrong about that. Obviously, descriptions and chunks have literary meaning, because they are prose, after all.
It’s hard for me to see your description theory as something very different from the object theory. Granted, you have a different emphasis. (It sounds to me in your later descriptions like you are talking about objects but just elevating the object property to prominence. Which to me, is not much difference. I could even agree with you. For example, here is an object tree…
The Kitchen
--> a chair
--> a table
--> a bowl
--> a spoon
--> a cupboard
--> cereal
So, I would say these are the units of meaning – the nodes of this tree and their interrelationships. It sounds like your theory just seeks to extend the specificity to properties of the nodes on this tree, i.e. just extend your view one branch further…
The Kitchen
- the description of the kitchen
--> a chair
- the initial appearance of the chair
- the description of the chair
--> a table
- etc.
--> a bowl
--> a spoon
--> a cupboard
--> cereal
I can’t say you are wrong, but I can’t say it matters that much as to me the key thing is that objects and their interrelations (which are designed by setting properties on those objects) are how meaning is achieved. If the next theorist came to you and said, ‘But no, it is not a text property that is the basic unit of meaning – it is one single sentence in that text property, since sentences can be changed individually.’ Would that seem like much of a difference, either? Possibly not. And you could go on splitting hairs unto the word and the letter.
But smallest isn’t the only factor here – for me the main factor is where is the particularly IF-flavoured way to giving some text meaning, where specifically in that structure is this trick achieved? Where does Eisenstein achieve his montage trick? It’s in the cut. Sure he could rearrange things within every shot and having moving shots that change their subject and so on, and achieve meaning THAT way, but the question isn’t could you achieve meaning that way (of course you could), for me the question is, where does an excellent film achieve its meaning – where is the potency, where is the rich, fertile expressive territory?
In cinema that territory is all in the cut: it provides so many ways of ascibing a meaning to an image, that other methods are dwarfed by the sheer weight of combinative territory provided by a cut.
So the reason I see the object and its relations with other objects (i.e. ‘the tree’) as the basic unit is that it is THE field where the combinatory explosion of possible meanings happens, so it’s the menu from which IF authors choose not just what to mean, but HOW to mean.
If you want to say that the property on an object is the key factor and not the behaviour of the whole object, well I can pretty much agree with that, thinking it’s just another way to say essentially the same thing. Objectifying text is the whole ball game, here.
I could write an IF game that has only one property on one object (beyond the standard properties). And it could mean something. But even if it were excellent, it would be so due to intentional self-restriction, the way a film with no cuts in it can be excellent precisely because it sets for itself the challenge of abjuring the basic unit of meaning of the medium.
So I’m going to stick with my object thing but in my view, your theory and my theory are essentially allied against other theories in which the primacy of relations between objects in the modelled world is not considered, and IF is view more as just a way of shuffling and dealing responses to player input, with the responses being like cards that are dealt (more like a subflavour of CYOA). There are people who seem to see it this way, judging by their game design as well as what they say. I don’t prefer their visions, but hey I’m glad they’re around.
I think this is key. I don’t think you can get very far in a typical IF game without internalising the object tree in your own mind. It doesn’t seem playable to me without being aware that it is object-oriented and these bits of text are interrelated, nor should it be, IMO, but there are those who think the point is just to mimick a piece of fiction, with choices, and the perfect IF would free the player from even thinking about how things are modelled but I don’t agree - I think hyperawareness of how things are modelled would be better, done artistically.
Through the object tree, yes, but also through the rules that determine which descriptions attatched to which objects are displayed in response to input by the player. That’s where the “chunks” come in. You make a very good defense of the object tree and of the necessity of acknowledging the relationships between objects in IF, and I’ve been pretty much convinced. However, I think it’s still useful to think of IF in terms of responses to player choice, as well, even if that most simple definition does not exclude CYOAs. After all, the way the game reacts to the player’s choice to display more prose is both determined by the object tree and is the only way that the player can discover it. Is it better to talk about IF in terms of its model world or its element of player choice/interactivity? That’s a question of quality that probably can’t be answered objectively.
My entire premise has been that the only way that the player discovers the behavior of objects in text-based IF is by reading the text description properties that the objects posses during the course of the game. Therefore, everything that a player can know about the object tree (and arguably about the entire game as a whole) is based on descriptions (or, more technically, individual units of normally descriptive prose, with occasional narrative prose in some units). If I disagree with you here, it’s probably only a matter of emphasis. You say “objectifying text,” but I contend that the whole purpose of IF is to “textify” objects! Which came first, the chicken or the egg?
However, I admit that your last post has convinced me that the object is a better reference as a unique unit of meaning in IF than the description, because units of description are by no means unique to IF. Let’s take the example of a leaf object in a hypothetical IF game. The long description that a player saw when she examined it might equally be found in a field guidebook for identifying trees. When the player read it, she imagined a leaf, but that conveyed no story about the leaf to her, nor did it present any problems which the leaf might be an element in solving (puzzles). However, taken with the initial description of the leaf attached to the branch of the tree in the appropriate room, the short description of the leaf after it fell to the ground, a description of the leaf when the PC carried it and the player took inventory, a description specifying how the leaf rested on a platform, and an alternate long description for when the leaf became damaged, a concrete literary image of a fictional leaf emerges in the context of a story about the leaf or a problem in which the leaf was a component. The fictional leaf is more “real” than the general leaf in the guidebook, even though they shared one of the same descriptions.
I agree that responses to player choice are important – we’re just having a sort of hair-splitting debate about what’s of prime importance. 87
I might point out that Inform 7 might be clouding the issue here, somewhat. What i7 calls a RULE is actually just an executable property (i.e. function, routine, method, insert your favourite object-oriented language here), that is attached to… an object! So I just see this stuff as all of a piece. Inform 7 compiles down to i6 syntax, so everything that happens, actions, rules, whatever, is just executing some typically object-oriented code, behind the scenes, in which nothing exists that isn’t attached to a particular object, or to a kind (i.e. ‘class’) of object, which is itself an object.
I don’t perceive any significant difference between printing out text properties on objects and running routines attached to objects. The latter is just a more complex case of the former.
So holding ACTIONS to be supreme seems to me to be saying, it’s not objects, but it’s what objects do. But that is the same difference to me, because I wasn’t talking about frozen objects that don’t do anything – I was talking about what they do as well; I was talking about the relations between objects: that includes what they have been instructed to do to other objects.
Point well taken — you’re right, the perspective is reversible. But there is a machine in IF that automatically sequences text. A film or a novel has no automatic machine (though there is a manual production process, all the work is ‘pre-rendered’ if you will, whereas IF does its text ‘rendering’ on the fly). So I just feel it’s very important to acknowledge this difference. And also not to be afraid of objects as if somehow the art of writing text is above the art of placing objects into useful fictional relationships, since I don’t really think it is, personally. I’m not saying that this is what you think; I’m just saying that I reject that view and that feeds into my reasons for defining things the way I do, as well…
Yeah I agree with your reasoning here. I just see all those things you describe as properties/functions on, or related to, the leaf object. Without that object these properties and functions would not be attached to anything, indeed there would be no reason for them to exist, so that’s why even though I agree with the way you see a lot of this stuff, I still manage to come to a different conclusion.
It’s been a great discussion though, hasn’t it? Made me reconsider some stuff…
This is not true. An I7 rule compiles to an I6 function, but it is not associated with any particular object. They live in rulebooks, but rulebooks are not I6 objects (nor are they objects in the world-model sense). You’re trying to force a structure into I7 that it explicitly doesn’t have.
Rules written for object-based rulebooks are associated with objects, sure. Rules written for action-based rulebooks are associated with action descriptions. And so on.
Alright. I admit I sussed out the internals wrong. But… isn’t an action just an object by another name? As in, a titled text-related data structure which exists for the purpose of being interconnected with other titled text-related data structures? The separation of text into discrete, interrelated data structures is what I’m trying to get at. I don’t know of a better word for that than object-orientation.
The two TADS systems are a better base for your theory re: “everything is an object”. TADS also has a master plan of sorts, that once you intuit it, authoring is much easier. (It’s because TADS was built, but Inform was grown.)
I’ve found this thread to be horrifying and fascinating in about equal measure. My WIP makes use of what I guess you guys would call a “because” tree, rather than a containment tree. I.e., the kind of tree the I7 author hand-codes when using Aaron Reed’s extension Intelligent Hinting, the kind of tree that Nate Cull’s Planner (a.k.a. Reactive Agent Planner in other authoring tools) builds on each turn an NPC needs figure something out, etc.
I wouldn’t restrict my own POV to a containment tree alone, though — that would exclude all sorts of stuff even from a classical O-O IF system, and make mine not a very workable theory. Your ‘because’ tree sounds pretty interesting and I wouldn’t want my focus on the objectness of it all to be interpreted as some kind of opposition to a cause-and-effect based system. Personally I just see those as smarter varieties of object, but you could probably look at the whole thing inverted and define an object as a dumber case of the cause-and-effect type of data structure.
BTW what’s the relationship between a ‘because’ tree and a choice tree? They sound similar to me. (A choice tree would somewhat resemble the skein but without any particular focus on typed commands – instead the discrete different paths that the player can take would be traced out, and actions that could be taken that don’t have any significant future effects would be igored.)
I can think of software architecture in many more ways than presented in this thread, which is why I’m a bit horrified to see tree-of-objects deified so. OTOH, you’re also talking about the meaning of a work, in which case I’m kinda fascinated seeing a structure from Computer Science play a role in semantics/philosophy/wonderment. I don’t have much to add to the latter – ask me what a program means and I’ll tell you what it does – but I can at least engage when it comes to guessing at what kinds of works will result from particular purposeful architectures. So…:
The latter is an example of the former. To expound: a CYOA is a choice tree. Per zarf and others, the story/plot of parser I-F ultimately boils down to a CYOA as well, the parser just adding some ancillary exploration. Scene 2b happens because choice #2 in scene 1 was chosen. Scene 1 is the root node of the story’s whole tree.
And now to bore you for twenty minutes.
In a RAP/Planner -like AI, you may have a (very small) tree:
GO THROUGH DOOR (which is currently locked)
GET KEY
UNLOCK DOOR
So ask, “why is the character getting this key?” Find the GET KEY node and the answer is its parent node: “Because he wants to go through the door.” Ask, “How is he going to go through that locked door?” Find the GO THRU DOOR node and return all its children nodes: “By getting its key, and then unlocking the door.” So there’s a because tree used in an AI.
Similar for Aaron’s Intelligent Hinting extension. “How is the character going to WIN GAME?” And so on. So there’s a because tree used in a hinting system.
Right there you’ve got enough to give your player WHY and HOW commands, and get sensible (if brief) answers back without the content-creation problem of writing lots and lots of prose. WHY and HOW are directions in a Because tree.
Now take the locked door example and pretend it’s a shifty-looking NPC who’s trying to do that, rather than our PC. Asking a second, trustworthy NPC WHY and HOW puts our IF into a very different place than “trivial physicality”, to use Em’s phrase up-thread. It’s character-to-character dialogue, about the motivations and methodology of a third, not-currently-present character. That’s the stuff fiction is made of.
This is a really interesting thread. I’ll give a slightly different take, although I think I agree with Ron’s approach. Going with how this stuff is discussed in the wider game community, I can say that it often comes down to this question: How does a player experience the story/game?
I personally wouldn’t – and don’t – worry about the implementation model: objects, rules, and so forth. That’s a behind the scenes thing that users generally don’t – and shouldn’t – care about. (In the same way that I don’t care if Amazon runs on a J2EE-with-Oracle or a .NET-with-SQLServer framework when I’m buying a book.)
Okay: so – how does a player experience the game?
They experience it via a series of images. In much of the gaming community, the “image” is the basic unit. Yes, for textual IF, these images are textual rather than visual – but if the writing is good, they build up a visual image. That’s what the player is ultimately responding to. The player then – via the medium – has to break down that image into its component parts in order to make sense of the experience. They start to look at what’s in a given room via a provided description. But whether that’s an object or not is hardly something players/readers care about. Yes, they utilize a set of descriptive text to get that information but it’s a means to an end. Graphical IF uses a series of static or moving images as well as (sometimes) spoken text to convey that same information. It’s the image that both have in common, in terms of what they are trying to provide.
Storytelling is about providing experiences and then allowing someone to make sense of those experiences. That’s still true in the arena of stories told within games.
Taking a side road for a second, in the software testing world, a test is anything that leads to a specific observable result that is a consequence of a series of actions. It’s the end result combined with the actions that lead to it that ultimately matter. (Because you might different actions that can lead to the same result, or similar actions that lead to a very different result. The “image” as a whole is what matters and what makes each test — each experience, if you will — different.) That observable result is the final “image” you get presented with. A tester could break things down to each action (click this button, fill in this field, select this item from the list), but the test as a whole has meaning only in terms of the final observed output: the final image and what it conveys.
Likewise, cinema focuses on the “units” of the shot by not just considering the content, but the way in which the content would be shown. You can vary a shot’s perspective, lighting, location, or other qualities to achieve certain effects (i.e., observed outputs). Once you have that image, you can then have the viewer focus on specific elements of it: the actor in the scene, the specifics of the background, the music playing as the scene goes on, etc. But it all ultimately adds up to a series of images.
So what’s the “image as unit?” It’s the reason for why the player/reader/viewer is engaging with the story at that moment. It’s what they are experiencing at that moment. The storyteller, of course, has to craft the story to provide a possible experience. What this means is that every observed output is a (relatively) clear because to a (relatively) clear why. I think this may be somewhat along the lines of what Ron is talking about regarding the notion of a “because tree.”
I think when you look at things at that level, from an authoring perspective (which is the intent), you get beyond concerns of object trees or mapping relations (which is the implementation). And your readers/players/viewers care more about the intent than the implementation. Interestingly, for the programmers in the crowd and since a few tool specifics have come up, this is the very same notion that exists behind domain modeling and domain-specific languages in the programming industry as a whole. I say interesting here because Inform 7 clearly tries to be a DSL but, I would argue, without the necessary domain-driven design behind it. I’m hoping eventually it evolves its intent along with its implementation.
I’m greatly simplifying a lot of ideas here but I hope I’ve at least conveyed the basics of my thinking.
I get where you’re coming from, Jeff, and it’s not that I disagree that those things are important. Audiences are often unaware about the cut in filmmaking as I’m sure you know, but it has an effect on them nonetheless and audience unawareness didn’t stop critics from labelling the cut as the important unit of meaning. I guess I just what I was musing about as trying to identify what plays that central role whether the audience/reader/player is specifically aware of it or not.
At the same time, the image as unit theory that you put forth is compelling, just as compelling as it is for film, but in what way is it different from film? If what you’re saying is that there is no difference in the basic unit of meaning across media, then I can get behind that to a certain extent (there is a narrative thread that runs throughout all things, no doubt about it). But again, I was aiming at something a little more expressive of how a medium constructs meaning from moment to moment, at a more basic level, if that makes any sense.
I know that you are deep into the mechanics of how programming languages work. I checked out your Inform 7 guide and found it a bit above my head. I’ve just always used programming languages, for play and then for pay. I didn’t take any formal computer science beyond first year university, as I was an Arts major so I guess I do come at things more from that perspective.
Yeah that’s pretty much what I’ve been thinking of it as – there is an interweaving pattern of possible choices; which means, a pattern of consequences; and it’s a form of design, because anything that be patterned can be designed. The greater an awareness we have of that pattern, while designing a game, the better. The skein seems a really interesting experiment in that regard but it’s still too fine-grained. I’m thinking more, big-picture patterns.
Pretty interesting stuff and falls into a pretty strong tradition (if I’m not mistaken) of trying to make the model world more soluble for more intelligent questions about it. It sounds like a cool advance along that path, and I’d love to see what sorts of games it would make easier to code.
I don’t say this at all. It’s technically true, in the same sense that a movie ultimately boils down to spots of light and shadow. When you’ve boiled things down to a choice tree, you’ve boiled too far.
An object-level description of a game does a poor job of representing the story as the player sees it.