Those few academics who have tried to define “game” have offered up everything from Roger Caillois’ “activity which is…voluntary…uncertain, unproductive, governed by rules, make-believe” to Johan Huizinga’s “free activity…outside ‘ordinary’ life…” to Jesper Juul’s more contemporary and precise take: “A game is a rule-based formal system with a variable and quantifiable outcome, where different outcomes are assigned different values, the player exerts effort in order to influence the outcome, the player feels attached to the outcome, and the consequences of the activity are optional and negotiable.”¹

This blog wants to discuss video games as formal systems, and how they grant players a freedom that is at the same time bounded.

But first, what is a formal system? A formal system is a closed structure composed of explicit symbols and rules: the symbols themselves carry no meaning; meaning comes from the relationships between symbols and from the rules that govern their operations. Mathematics, logic, and programming languages are all examples of formal systems. In this sense, games are formal systems too, as they have explicit elements (chess pieces, word tiles, characters), rules that govern how these elements interact, and boundaries between legal and illegal states. A formal system is closed and self-consistent; but what makes a game a game rather than mathematics is that semantics enter its formal structure: players bring goals, emotions, and interpretations into the system, layering meaning onto the syntax of the rules.

Freedom and rules form a classic antinomy: the rules of a game constrain what a player can do, yet they are also the precondition of the player’s creativity; a developer designs a system, but the system produces behaviours that exceed the designer’s intentions; a player experiences genuine freedom, yet that freedom unfolds within a carefully delimited space. These contradictions are not design problems to be solved — they are intrinsic to games as formal systems.

However, to make these contradictions precise, we first need to distinguish several concepts that are often used interchangeably.

2 Rules, Mechanics, and Experience in Games

2.1 Rules in Video Games

As we already know, in the practice of game development, developers define game behaviour by setting rules at different levels for different actions. For example, the following code defines an _on_body_entered(body) function for a coin, so that the player scores a point upon touching it:

func _on_body_entered(body):
    game_manager.add_point()
    print("+1 coin")
    queue_free()

Most basic game rules are quite intuitive and conventional: “touching a monster deals damage,” “taking damage reduces health”, while different games may have their own distinct settings, such as the stamina consumption during running and climbing in The Legend of Zelda: Breath of the Wild. Generally, good game design (as in most Nintendo games) tries not to require players to spend too long understanding the rules, instead embedding the rules into intuition, so that players can quickly find their footing, reach the next positive feedback loop, or freely explore the boundaries of the rules.

There are also harder-core games like TIS-100 and A=B, where the rules may not be especially complex, but players may need to read through a manual before they can begin, and deepen their understanding of the rules as difficulty increases. Such games are undeniably off-putting at first, but there are always players who find greater satisfaction in them, because the complexity of the rules is itself part of the challenge.

2.2 From Rules and Mechanics to Experience

In everyday discussions of games, “rules” and “mechanics” are often used interchangeably, but they refer to different things.

Rules are the content of a game’s formal system: explicitly statable constraints in declarative form. WALL IS STOP, “bishops move diagonally”, “health reaching zero means death”… these are all rules. Rules define which states in the system are legal and which transitions are permitted.

Mechanics are the realisation of rules at the level of experience: the units of action a player can actually perform, and the system responses these actions trigger. Pushing a box, moving a chess piece, jumping, building… these are mechanics. Mechanics are the interface through which players enter the formal system, translating abstract rules into concrete interactive behaviour. Players tend to discuss mechanics more than specific rules, because it is through interaction that different game experiences are produced.

If we treat experience as a system in its own right, then the experience system can be understood as the whole produced when a player interacts with rules through mechanics — encompassing the generation of strategy and emotion (frustration, epiphany), as well as all the expectations and interpretations the player brings into the game. If the formal system is closed and self-consistent, the experience system is semi-open: the player’s subjectivity interacts with the rule system through mechanics, producing meanings that the rules themselves could not have anticipated.

The relationship between rules, mechanics, and experience is one of nesting: rules constitute the structure of the formal system, mechanics are the player’s way of entering that structure, and the experience system is the whole that emerges when the two meet.

3 Baba Is You: A Game Played by Changing Its Rules

Baba Is You is a puzzle game made by Arvi Teikari. Like other sokoban-style games, the player controls a character on screen, pushing blocks to accomplish a task and then advancing to the next level. But Baba Is You differs fundamentally from most sokoban games (and most puzzle games): its puzzles are not about “finding a solution within given rules,” but about “creating a solution by changing the rules.” In other words, it brings what is normally hidden in the game’s underlying layer entirely to the surface, making rules themselves into game objects.

The game’s mechanics are quite simple. The map is scattered with word tiles (some already arranged, some loose): BABA, IS, YOU, WALL, STOP, FLAG, WIN… When combined, these tiles form the rules currently in effect: BABA IS YOU means the player controls Baba’s movement; FLAG IS WIN means touching the flag wins the level; WALL IS STOP means walls cannot be traversed. Players can push these tiles and rearrange them, thereby rewriting the rules themselves. Some tiles are intentionally placed at the edges of the map to prevent them from being moved — though players can sometimes make limited changes by pushing AND to the end of a phrase.

In practice: you can push WALL in front of IS WIN, making walls the win condition; or make WALL IS YOU, turning yourself into a vast shifting mass of wall. If you dismantle BABA IS YOU — or any phrase containing IS YOU — you lose your object of control. This is not a conventional “failure”: the player, having lost the rule that constitutes them as themselves, enters a strange state of subjectlessness. And of course, you can simultaneously maintain BABA IS YOU while forming BABA IS WIN, then walk toward yourself to complete the level. The design has a distinctive conceptual self-reflexivity: the game uses its own rules to discuss the nature of rules.

In more technical terms, the rule engine of Baba Is You is structurally analogous to a formal system. Its grammar can be expressed roughly in BNF notation as follows:

<rule> ::= <subject> <verb> <predicate>

<subject> ::= <noun>
		   | <noun> AND <noun>

<verb> ::= IS | HAS | MAKE

<predicate> ::= <noun>             -- IS，HAS，MAKE
             | <property>          -- IS
             | <noun> AND <noun>   -- IS，HAS
             | <property> AND <property>  -- IS

<noun> ::= BABA | WALL | FLAG | ROCK | WATER | LAVA
               | SKULL | KEY | DOOR | TEXT | LEVEL | ...

<property> ::= YOU | WIN | STOP | PUSH | SINK | DEFEAT
		    | HOT | MELT | OPEN | SHUT | FLOAT | MOVE
		    | SAFE | WEAK | DONE | ...

Word tiles are the symbol set; the legal combinations of tiles constitute the formation rules; the initial tile arrangement of each level is the axiom set; and when a player pushes tiles to rearrange them, they are effectively modifying the axiom set at runtime. But what makes this a game rather than a mathematical system is that its formal structure carries meaning that exceeds the rules: WIN signifies a state of value to the player; YOU signifies subjectivity and a sense of control. Each player’s unique experience of the game arises at this point of contact.

Starting from Baba Is You and games like it, we can discuss a slightly larger question: what exactly is a game’s formal system, and what is the relationship between game rules and player freedom? And when we bring the developer into the picture, how should we understand this complicated relationship?

4 Rules Are the Condition of Freedom

A common intuition, in life as in games, is that more rules mean less freedom. The rules of a game constrain what a player can do, and are therefore a restriction on freedom. But this intuition runs into immediate difficulty when confronted with actual gameplay experience. Chess has a set of strict rules: each piece’s movement is precisely specified. Yet it is precisely this strictness that makes the strategic depth of a chess game possible. If pieces could move arbitrarily, chess would no longer be chess – just pieces shuffled on a board, neither challenging nor creative.

This holds for many video games too. Take Baba Is You: the number of word tiles is finite, the logic of their combinations is finite, and the layouts of many levels are fixed. Yet it is precisely under these strict constraints that players are forced to break out of conventional thinking. So no longer searching for a path within the rules, but examining the structure of the rules themselves, looking for fissures and possibilities for recombination. Some solutions are not the paths the designer “reserved”; they are possibilities the player discovers within the combinatorial space of the rules, and sometimes possibilities the designer never anticipated.

This brings to mind Marx’s description of the “species-being” (Gattungswesen) of humanity, in the Economic and Philosophic Manuscripts of 1844. Marx argued that human labour differs from animal instinct in that humans can “produce according to the standard of every species,” applying an “inherent standard” to their objects. ² In other words, creative human labour is not merely adaptation to given conditions, it is the active opening-up of possibility. What game players do reflects exactly this kind of creative labour. In actual gameplay, the rules are not a cage; they are a set of “inherent standards,” a language through which players think and create. Rules make the very concept of creation possible; without rules, there is no structure to be broken through, recombined, or exploited, and therefore no genuine player freedom.

Constraint is the condition of freedom, as a paradox, has its technical counterpart in the domain of formal systems. Chomsky’s theory of generative grammar holds that the creativity of human language derives from the capacity of finite rules to generate infinite sentences. ³ Any native speaker can understand and produce sentences they have never heard before, precisely because language has a finite set of generative rules at its base.

To illustrate the same isomorphism in games: a finite set of rules can theoretically generate a near-infinite space of possible play. One of the clearest examples may be Go. My favourite example in video games is Minecraft, which offers players an explorable open world that generates progressively but within certain algorithmic constraints, as they move through it. Each new seed-generated world, or each step forward into unexplored territory in an existing world, can deliver a genuinely new experience.

5 Patterns: The Product of Experience and Play

If rules are explicit and stated, then patterns are implicit and discovered. In actual gameplay, what players first encounter are rules and mechanics, but gradually they begin to identify the patterns beneath the rules: the implicit regularities and recognisable structures that emerge from the interaction of rules and mechanics. Good game design often builds a rhythm around this process: players identify a pattern, use it, and then encounter a moment that breaks it.

Crucially, patterns are finite, and they can be exhausted. A formal system can theoretically generate near-infinite combinations of rules, but the meaning a player experiences does not scale linearly with the number of combinations. Given ten thousand combinations, if there are only three underlying patterns, a player will not genuinely find all ten thousand novel or interesting. Meaning is exhausted long before the possibility space is.

My own experience is that once I have identified the core patterns of a game, it becomes difficult to sustain interest in it — even when there is plenty of content left, or even when the developer continues to update. The games that get played repeatedly tend to be those designed to delay pattern exhaustion: large multiplayer online games maintain openness through the unpredictability of human opponents; Animal Crossing and Stardew Valley sustain engagement through temporal rhythms and emotional attachment; Minecraft uses algorithmically generated open worlds to keep players facing probabilistic surprises, slowing the pace at which patterns become familiar; and classic Minesweeper, whose patterns and tricks are not hard to learn, but it keeps players returning through the timed challenge.

Baba Is You also takes an interesting approach to the problem of pattern exhaustion: it tried to make the patterns of one level rarely transfer directly to the next. Moreover, Arvi Teikari introduces new word tiles in each chapter, and not just adding content, but expanding the vocabulary of the formal system, adding elements that can generate new patterns.

However, no matter it is Minecraft’s random generation or Baba Is You’s chapter-by-chapter expansion, or other attempts from many different video games, their ultimately strategies are all for delaying pattern exhaustion, but cannot truly break the rule itself.

6 Freedom, or “Designed Freedom”

When we bring the developer into view, the picture described above becomes considerably more complex.

When a player rewrites rules in Baba Is You, they often feel a strong sense of surprise — Yayy I changed the way this world works! But this “rewriting” takes place within a deeper framework of meta-rules. You can push the tiles because the rule BABA IS YOU allows you to push tiles; you can form WALL IS WIN because WIN is in the game’s vocabulary and is moveable on the map. Players can never write a word outside the vocabulary, never invent a rule type that does not already exist in the system.

Furthermore, the layout of each level determines which tiles appear, where they appear, and whether they are within the player’s reach. This means that in designing each level, the designer has already, to some degree, pre-set and repeatedly tested the “space of possible solutions.” What feels like free exploration is exploration within a possibility space whose boundaries have been carefully drawn. Many game designers go further, deliberately designing the experience of “spontaneous discovery” as a reward mechanism. In It Takes Two, for instance, players can sometimes find a path off the main route, and following it may lead to a bonus level or an Easter egg. It is sometimes hard to say which outcome is more satisfying, or more deflating: discovering a path that leads to a small Easter egg, versus one that leads nowhere. The former is a genuine surprise, but the latter, in a certain sense, challenges the authority of the developer: this was probably not the experience they designed for you to have.

What this means is that designed freedom is not only structured, it is also bounded. The formal system may theoretically generate a vast number of combinations, but the number of patterns a player can extract from them is finite. When patterns are exhausted, the “size” of the possibility space becomes irrelevant. What remains is the mechanical execution of rules, with no new meaning emerging. The real boundary of player freedom, then, is not the number of rules – it is the number of patterns.

In Althusser’s terms, the game’s formal system “interpellates” the player ⁴ — it summons them into a particular subject position (“you are a creator who can change the rules”), and that subject position is itself designed. The freedom and sense of creativity the player experiences from within it are genuine, but they are also pre-established by the system.

This is not to say that such experience is false. But the proposition is confirmed: freedom is designed freedom, and this freedom has an inherent limit. And this fact should change how we understand it.

7 System Overflow: Bugs and Unintended Gameplay

Emergence, the intrinsic tendency of formal systems to produce behaviour at the system level that no single rule could independently predict, complicates the picture once again. When developing a game using object-oriented programming (OOP), the developer’s thinking tends to be linear and modular: define a class, specify its properties and methods, then define the next class. Each rule is designed in isolation, under control. For example:

# Play animations
if is_on_floor():
    if direction == 0:
        animated_sprite_2d.play("idle")
    else:
        animated_sprite_2d.play("run")
else:
    animated_sprite_2d.play("jumping")

But when the game runs, all these rules take effect simultaneously, interacting with one another; meanwhile the player’s behaviour is nonlinear and unpredictable. Situations arise that no single rule could have anticipated, requiring the developer to go back and revise. In this sense, a bug is not merely a code error: it is the moment at which the system’s complexity exceeds the designer’s anticipatory control — an overflow of the formal system itself.

This overflow does not only manifest as bugs. More interesting are the instances of “unintended gameplay” that players discover: players of The Legend of Zelda: Tears of the Kingdom and Minecraft regularly exploit the physics engine in ways the developers almost certainly never imagined, sometimes even discovering new patterns beyond those the developer pre-set; players of Baba Is You may also find solutions to a level entirely outside what the designer envisioned.

This is what makes formal systems genuinely fascinating: they create a space of possibility larger than any single designer. The developer is a meta-legislator, but once the meta-law is enacted, it produces effects that exceed the legislator’s intentions. The developer might believe they are designing a closed system, but the system’s emergent capacity makes it an open field.

7.1 Is Overflow Genuine Resistance?

Though this may look like entering a spiral of infinite scepticism: are the unintended plays players discover genuine resistance to the developer’s authority, or are they also, in some sense, already designed?

In many games, especially open-world games, developers deliberately design the experience of “accidental discovery”: what seems like a secret the player found themselves is in fact a carefully placed surprise (the Koroks in The Legend of Zelda: Breath of the Wild are an example). The satisfaction players feel from discovery is real, but that satisfaction is itself manufactured. In another kind of case, some games incorporate players’ “creative plays” into subsequent updates, formalising them as game mechanics, and thus what was once an overflow is absorbed back into the system. For example, ConcernedApe, upon discovering that Stardew Valley players were using a glitch to obtain items, chose not to patch it, but instead added a playful in-game response.

Gramsci’s concept of “hegemony” is relevant here: a dominant culture permits a degree of resistance precisely in order to secure deeper consent. ⁵ When game developers allow or even celebrate the discovery of unintended gameplay, it may be more like a sophisticated design strategy: letting players feel a sense of agency, thereby drawing them deeper into the game.

But I don’t think this analysis is a conclusion. It is a contradiction that needs to be held open. Even if the “accidental discovery” is designed, the cognitive process the player undergoes at the moment of finding it — the genuine reasoning and creativity performed within the combinatorial space of the rules — does not thereby become false. The authenticity of experience and the producedness of experience are not mutually exclusive.

This is also why Baba Is You’s system is quite interesting to me: it places the fact that “rules can be manipulated” plainly on the table. The player knows they are manipulating rules, and the designer knows the player knows. This transparency makes the game a good medium for thinking about formal systems themselves.

8 Conclusion: The Formal System as a Dialectical Field

A game’s formal system is a dialectical field. Player’s freedom does not operated at a single level. Rules define the possibility space at the formal level; mechanics are the player’s way of entering that space; patterns are the units of meaning the player extracts through interaction; and experience is the whole that emerges when the player’s semantics meet the syntax of the formal system. This field contains several contradictions that cannot be simply resolved:

• Rules constrain freedom, yet are simultaneously its condition;
• Players create within the system, but their creation takes place within a possibility space that has been designed;
• Systems produce emergent behaviours that exceed the designer’s intentions, but that emergence may itself be part of the design.

These contradictions are not problems to be solved, but intrinsic to games as formal systems. And this blog does not aim to provide an answer that resolves them, but to refuse satisfaction before the contradictions are resolved, just as dialectics does not resolve contradiction but moves toward it, bringing its nature into sharper relief.

When a player, after long preparation and battle, finally defeats the Ender Dragon and begins reading the End Poem; or finally solves a carefully defined puzzle and walks (as Baba, or as Wall) toward whichever object represents victory: do you feel only joy, or also a faint disorientation? As if the game had been waiting here all along for you to arrive at this so-called ending, whatever path you took to get there. As a player, was the goal you have been pursuing all this time something you genuinely wanted? Or something the designer/developer wanted you to want?

That disorientation, I think, is the most honest gift the formal system has to offer.

There are pragmatic reasons to seek them out: most are small in size, run on low-spec hardware, and cost little or nothing (since many are only playable via emulator). But the more compelling reason is the craft itself: rich worlds and clever design that remain astonishing to this day, and the occasional pleasant jolt of recognising, in some game you love right now, exactly where it came from.

The games industry changes at a relentless pace, and so do the ways games are made. As AI lowers the barriers to game development, I find myself worrying, as both a player and a gamedev enthusiast, that shovelware will only become more rampant. So now it feels like a good moment to look back at games that were built with genuine care – and to find in them something worth carrying forward.

1 Retro Gaming Resources

If you just want a quick taste, the simplest option is to play directly in your browser on one of these sites:

• RetroGames.cz
• ClassicReload.com
• Classic Macintosh Game Demos

That said, most players who are slightly more serious will prefer playing locally, because you can save your progress at any time, play offline, and generally get better input response. Here are some places to download games:

• My Abandonware – Download Old Video Games
• Mac Source Ports: Games for Apple Silicon and Intel Macs
• bobeff/open-source-games: A list of open source games

2 GOG

For players who want to download and play locally, GOG.com is, without question, the best platform today for the preservation and purchase of good old games (they even run a dedicated GOG Preservation Program). It carries many titles that never made it to Steam, and its greatest strength is that all games sold there are DRM-free: you can play offline without having to log in every time, unlike Steam.

That said, the same game can vary in subtle ways between the two platforms: GOG versions tend to have less achievement systems, for instance, so it’s worth comparing prices, platform support, and review sections before buying. Tools like GOG Database and SteamDB are handy for this.

Compared to the Steam client, GOG GALAXY is more flexible in that it lets you browse and download your library across other platforms too. I actually find the open-source, free Heroic Games Launcher more capable and easier to use. GOG Galaxy, for what it’s worth, had a persistent bug on macOS where the app would refuse to quit properly. They only fixed in the relatively recent 2.0 update, which is rather hard to believe…

2.1 Emulators (that I’ve used)

For games that no longer have any official purchase channel and no pre-compiled port available, you’ll need to download ROMs and use emulators. Here are some useful links:

• Download game ROMs: Emulator Games
• Starter guides for many devices: Retro Game Corps

2.1.1 A Note on macOS and Windows

I’ve long had a grievance with the idea that Macs are “not for gaming.” The display quality, the speakers, the performance, the battery life of macs – all of it should, at minimum, serve anyone whose tastes run to modern video games on it. But the unfortunate reality is that many games simply haven’t been ported to macOS. For retro games, though, macOS fares reasonably fine: quite a few of the emulators above support Mac, and there are dedicated resources like Mac Source Ports, plus tools like Porting Kit for converting certain GOG and Steam games into macOS-compatible formats. However, since macOS no longer supports 32-bit software a long time ago, there are still a number of (not necessarily old) games that cannot be played.

On Windows, most retro games can be played directly or easily found in versions that other players have already converted. For anything else, RetroArch remains an excellent catch-all.

3 Classic Macintosh Games

Early macOS had no such reputation for being “bad for gaming.” In fact, we can still experience many of those cool old Mac games today through Macintosh emulators (or real old Macs, if you have one).

Getting Started (WIP) – Macintosh Repository is an excellent all-in-one introduction to the scene. My personal emulator of choice is Mini vMac, simply because I adore the 2bit minimalism of Macintosh System 7. Once you’re up and running, Macintosh Garden is a nice place for classic Mac games and software.

One of my current favourite games is Déjà Vu, which cleverly uses the Mac’s native Finder interface as part of the game itself (there’s something wonderfully meta about it!). Other standouts from the same era include Shufflepuck Café, SimCity, Glider, and Battle Chess, each remarkable in its own way.

4 Nintendo

As one of the defining forces in the games industry, Nintendo was producing design strokes of near-genius very early on – Super Mario Bros., the Legend of Zelda series, and a series of inventive hardware.

The best place to explore Nintendo’s history is the Nintendo Museum, and Nintendo’s own website also has a overview at Nintendo History | Hardware. I’m pretty sure there are lots of YouTubers who have made videos about this too.

4.1 Nintendo Switch

Since iOS loosened its restrictions on emulator apps, you can now download a lot of GBA emulators directly from the App Store. But probably the simplest and best way to experience GBA and Famicom games in their most authentic form is through Classic games – Nintendo Switch Online, if you don’t own any old consoles. With a Switch Online membership, you get access to a curated selection of games – mostly in Japanese and English, but even just playing them leaves you in quiet admiration of the design. There’s also an Expansion Pack for the more dedicated.

For me, there’s one particularly welcome feature: these games all support save states and rewind, so less experienced players can still experience as much of the game as possible.

4.2 3DS

Unfortunately, Nintendo Classics hasn’t yet included 3DS titles (probably because the 3DS doesn’t quite feel old enough to qualify). Your options are to use an emulator or to buy a second-hand 3DS. For emulator, Azahar is the currently active one, though I haven’t tried it personally; second-hand 3DS come in a range of models, though most are still priced somewhat higher than I’d hoped. After a long search on the second-hand market, I eventually found one – the screen is slightly yellowed, battery life is poor, certain games trigger crash bugs, and SD card read speeds are painfully slow, but it works (and worth the price).

The 3DS game library is super impressive, and many titles make wonderful use of it’s unique hardware: dual screens (top and bottom), glasses-free 3D, a camera and microphone, a circle pad, a stylus. By today’s standards the performance and fidelity are decidedly vintage, but put it all together and the experience still feels inventive and fresh. You’ll find yourself marvelling repeatedly at the ingenuity of the people who designed both the games and the hardware. In my opinion, the 3DS is one platform where buying a physical unit rather than using an emulator really does feel like the right call.

4.2.1 Modding, Installing Games, and System Setup

OasisAkari’s blog has an detailed walkthrough (in Chinese): 3DS Modding – Getting Started

4.2.2 Download 3DS Games

• Chinese-translated releases:
  • 3DS Chinese Game List | Shi Pengliang’s Blog
  • 爱 3DS
  • 3DS Full Chinese Game Collection CIA (Official + Fan Translations) (275 titles) – Switch520
• English releases:
  • hShop
  • 3DS ROM & CIA – 3DS Decrypted Game Download

4.3 Game & Watch

Somewhat less well-known, Game & Watch was a series of handheld devices Nintendo produced in the 1980s and 90s, as part digital clock, part simple game machine. One could reasonably call them a distant ancestor of the Nintendo Sound Clock Alarmo™. In 2020, Nintendo released two limited-edition products: Game & Watch: Super Mario Bros. and Game & Watch: The Legend of Zelda, each containing a functional clock, the original Game & Watch minigames, and ports of several Famicom and Game Boy Mario and Zelda titles. Charming things.

Play online:

• RetroFab by Itizso
• lcdgame.js – LCD game simulators

There are also many fan-made HTML Game & Watch games on itch.io and similar platforms, such as Cuphead: Game And Watch Edition and LCD, Please (the latter is made by Lucas Pope, one of my favourite indie game developers).

5 Conclusion

Looking back, writing this post turned out to be its own kind of rabbit hole. Somewhere in the middle of organising these resources, I ended up replaying a few rounds of Simcity on Mini vMac.

I also realised there’s a particular quality I love about the retro gaming community: players who carefully document everything about a game on wikis and forums – modding guides, fan translations, hardware compatibility lists – not for any obvious reason, but simply because they don’t want those things to disappear, and help others to enjoy them. That instinct feels as worth preserving as the games themselves.

So perhaps this is less a guide than an invitation. If some half-remembered game from childhood suddenly comes back to you on a random weekend – this is a place to start looking for it ;)

• Hakyll — Haskell static site generator (library, not framework)
• Pandoc — document compiler, now used as a library dependency inside the site build
• A small Pandoc AST transform for Obsidian-style callouts and sidenotes
• A small companion executable: Formatter.hs

2 Why Hakyll

I tried Hugo, Quartz, Next.js, and a working Python/Pandoc/Jinja2 pipeline to build my blog website before this. They all did the job and were good in their own ways, but somehow I’m just not satisfied. The problem was that working with them rarely felt like designing — mostly it was modifying other people’s configs and hoping the result was close enough to what I actually wanted.

I’ve been learning Functional Programming for a while, and I thought it would be a good idea to use it to build my own blog: it allows you to describe a solution rather than commanding a sequence of steps. Top-down design, pattern matching, no hidden state, no side effects you didn’t ask for, and so on.

For example, site.hs is the build system. There’s no hidden convention underneath it. Every route, every compiler, every dependency is explicit code I wrote and can read back. The other reason is types. When I wire up a compiler pipeline, GHC tells me immediately if the pieces don’t fit. Refactoring a route is less scary when the type errors are caught before I check the output in a browser. I don’t know enough Haskell to do anything fancy. For now, site.hs is mostly combinators from the Hakyll API glued together. But that’s already enough for me.

Essentially, it’s not about which tool or which language I’m using, but how I’m using it to convey my thoughts and design my own logic of blogging.

3 site.hs

Based on the template provided by Hakyll, I added a few more features:

• Draft system: Posts can have draft: true in frontmatter. isPublished checks for this and filters drafts out of all listings. The compiled HTML is still accessible by direct URL tho, which is useful for previewing before publishing.

• Chronological dates from metadata: Hakyll’s default date system requires a specific filename convention (YYYY-MM-DD-title.md). I didn’t want to be locked into that, so my implementation tries metadata keys in order (date, then created), and uses modified as a tie-breaker. To ensure stability across machines, sorting is strictly metadata-driven: all posts are required to have at least one date field in the frontmatter, and the build will fail if both are missing.

• safeCompiler: Wraps a compiler in catchError so a single broken post doesn’t abort the entire build. Instead, the failed page renders a styled error div with the error message. Useful during drafting when a post might have broken syntax or malformed LaTeX.

4 Pandoc pipeline

Originally, the compiler called Pandoc as an external process via unixFilter:

getResourceBody >>= withItemBody (unixFilter "pandoc" args)

The args I passed to Pandoc were:

--from markdown+mark+wikilinks_title_after_pipe-yaml_metadata_block
--to html
--lua-filter filters/obsidian-callouts.lua
--number-sections
--mathjax

That version worked fine for quite a while, and it matched the way I already used Pandoc elsewhere, especially in Obsidian. But it build depended on a separately installed pandoc binary, which made the build contract less explicit than I wanted. It also meant that version drift could affect the output in ways cabal itself did not really know about.

So I eventually rewrote this part. Now the site uses Pandoc through Hakyll’s library integration instead of shelling out to the executable. In Site.Utils, the compiler now does three things in sequence:

1. Read markdown into a Pandoc AST with custom reader options.
2. Transform the AST in Haskell.
3. Write it back to HTML with custom writer options.

It’s more complicated than the old way, I had to add explicit pandoc, pandoc-types, and text dependencies to the cabal file. But in return, the site build no longer depends on a external pandoc executable to render posts.

4.1 Replacing Lua filters

In Obsidian, I use obsidian-pandoc to export my notes to PDF files through \(\LaTeX\) (See HuangxinDong/Eisvogel-for-Obsidian for more). It supports custom lua filters, so I use it to add some custom filters to my markdown files.

The legacy setup used filters/obsidian-callouts.lua to turn Obsidian-style blockquotes like this:

> [!note] title
> some text

> [!sidenote]
> some text

into styled callouts and sidenotes.

While refactoring the Pandoc Pipeline, I realised I was not really using the more complicated parts like folded callouts or type aliases, so I decided to move the transformation into Haskell without turning it into a huge rewrite.

As part of the refactoring, I added a Site.Pandoc.Callouts module that walks the Pandoc AST and rewrites matching BlockQuotes into the HTML structure used by the site. Unknown callout types are left alone and rendered as ordinary blockquotes, which felt like a nicer failure mode than trying to be too clever.

I moved obsidian-callouts.lua to the assets/files folder to keep it as a reference, but the website itself no longer depends on that filter during the build.

5 Formatter.hs

I write most of my notes and articles in Obsidian, although they can be rendered normally in most markdown viewers, some of them does not work in Pandoc. For example, if there’s no blank line before a heading, Pandoc will render it as a normal text. Inspired by Prettier, I though it would be convient to have a tool that automatically formats the markdown files. I know prettier can also format markdown files, but it’s a nice practice to write it in Haskell, and custom it to my needs.

Formatter.hs is a separate executable in the same cabal file. It finds all .md and .markdown files in the project directory, and applies a set of typography fixes in-place before the Hakyll build runs:

• CJK/Latin spacing: inserts a space between Chinese characters and Latin

  text/digits (e.g. 中文和English -> 中文和 English), but skips inline code spans.

• Heading formatting: ensures ##title becomes ## title meanwhile ignore #title since sometimes it can also be a #tag (and I don’t really use H1 a lot in my notes anyway).

• Blank line insertion around headings and list blocks.

• Ignore frontmatter in the start of the file, and ignore files with formatter: false in frontmatter.

To run the formatter:

cabal run formatter
cabal run formatter -- --dry-run # print diff without writing

During the development of the formatter, I realised there’re much more edge cases than I thought. The dry-run mode turned out to be really useful because the formatter can be a bit aggressive, and it’s always a good idea to check the diff before applying the changes, before I can 100% trust my code.

6 Data Integration: Douban Archive

I wanted to have a place to keep track of the books I’ve read and movies I’ve watched, without relying on a third-party service. Since I’ve been using Douban for years, I decided to import my data from there.

The implementation is split into a few parts:

• Ingestion: Using Hakyll’s preprocess, the site-building process loads CSV exports from assets/douban/.
• Douban.Records: A Haskell module that handles the heavy lifting of CSV parsing (dealing with BOM, multi-line fields, and weird encoding quirks). It normalises the data into a common DoubanRecord format.
• Dynamic Routing: Instead of creating a markdown file for every category, site.hs uses createRecordStatusPages to programmatically generate pages for Books, Movies, Music, and Games, including separate “Read/Watched/etc.” and “Wishlist” views.

This keeps my “Records” section automatically updated whenever I drop a new CSV export into the folder and rebuild the site.

7 What’s next

• Tags are implemented but the tag pages are unstyled.
• --number-sections should probably be opt-in per post, not global. -> it can be controlled by frontmatter now.
• It should probably become more deliberate per post, rather than just “on by default unless disabled”.
• The series/ concept is half-baked — I’m still not sure how to use it.
• css is still pretty basic: no support for dark mode, no responsive design, etc.
• Integrate reading/watching/listening/gaming records.
• Add a search function.
• Add a comment area. -> I added a comment section using giscus.
• Write more posts rather than just playing with the blog!

The source code of this blog is available on GitHub. Feel free to check it out if you’re interested or have any suggestions!

1. I couldn’t accept a single word from the grey hint, tab would accept the whole suggestion.
2. After typing a prefix like npm run and pressing ↓ through history matches, hitting ↓ at the bottom just got stuck. But I want it to go back to a clean line.

1 The original setup

I had both zsh-autocomplete and zsh-autosuggestions installed at the same time, and didn’t notice they conflict. zsh-autocomplete is quite heavy to me and takes over ZLE widget registration at load time, quietly breaking things that rely on the standard completion machinery. So I decided to remove it and rely solely on zsh-autosuggestions. This fixed several ghost issues I hadn’t noticed before.

But the more interesting problem was the key bindings.

2 The ^I trap

I had this line in my config:

bindkey '^I' autosuggest-accept  # ^I is Tab

Binding it to autosuggest-accept meant Tab would accept the entire suggestion instead of triggering completion. It seems reasonable on its face, but also caused a side effect: in macOS Terminal, → shares some input handling with Tab in certain contexts, so when I set bindkey '^[[C' forward-word, pressing → was silently triggering autosuggest-accept (whole line) rather than just moving the cursor one word to the right.

The solution is to remove the ^I binding. I finally decided to use → to accept the entire suggestion instead, and use option + → to accept one word at a time, just as how I usually move cursor in other IDEs (sometimes I do use vim though, but not that often).

Btw, to confirm what any key actually sends, use cat -v and press the key, then Ctrl+C to abort.

3 Accepting one word at a time

zsh-autosuggestions doesn’t have a built-in “accept one word” widget. Instead, it has a widget called ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS. Any widget listed there will, when executed, absorb the corresponding portion of the suggestion into the real buffer.

Meanwhile, forward-word moves the cursor one word to the right. So by adding it to the list, bind → to it, and pressing → will pull one word out of the suggestion each time. And that’s exactly what I always wanted.

Note that two things matter here:

• The variable must be set before sourcing the plugin. It’s read once at initialisation. Setting it afterwards has no effect.
• The binding must be set after oh-my-zsh.sh is sourced. Oh My Zsh will overwrite bindings set before it loads. Anything you want to stick should be placed at the bottom of .zshrc

4 History substring search

zsh-history-substring-search filters history by whatever you have already typed. For example, type npm run, press ↑, and you cycle only through commands that start with npm run. With nothing typed, it behaves like normal history navigation.

source $(brew --prefix)/share/zsh-history-substring-search/zsh-history-substring-search.zsh
HISTORY_SUBSTRING_SEARCH_ENSURE_UNIQUE=1

bindkey '^[[A' history-substring-search-up
bindkey '^[[B' history-substring-search-down
bindkey '^P'   history-substring-search-up    # fallback for tmux / SSH
bindkey '^N'   history-substring-search-down

The remaining problem was the stuck-at-bottom behaviour. When you reach the most recent match and press ↓ again, the plugin sets HISTORY_SUBSTRING_SEARCH_RESULT to an empty string. That’s the signal to clear the line:

_history_substring_search_down_then_clear() {
  if [[ $HISTORY_SUBSTRING_SEARCH_RESULT == '' ]]; then
    zle .kill-whole-line
  else
    zle history-substring-search-down
  fi
}
zle -N _history_substring_search_down_then_clear
bindkey '^[[B' _history_substring_search_down_then_clear

5 Plugin source order

All three plugins must be sourced in this order:

zsh-syntax-highlighting
zsh-autosuggestions
zsh-history-substring-search

zsh-syntax-highlighting wraps every registered ZLE widget at load time to apply colouring. If zsh-autosuggestions loads first, the widgets it creates won’t be wrapped, and highlighting breaks for those interactions. Source highlighting first, and it captures everything that comes after.

6 fzf

One addition worth mentioning: I currently use fzf to replace the default Ctrl+R history search with a full-screen fuzzy finder. Install it with brew install fzf, then add this to .zshrc:

eval "$(fzf --zsh)"

This also enables Ctrl+T (fuzzy file picker, inserts path into command line) and Alt+C (fuzzy cd).

7 Final config

Feel free to check my final zshrc!

作为一位来自大陆北方的网友，在 CS 学习之余想到 自由软件运动、开源软件运动 与共产主义之间的关系似乎是一件相当自然而然的事，但是这几种理念各自本身究竟各自代表什么，各有怎样的出发点和现实效果，我一直没有深入思考过；即使愿意探讨，也常常觉得缺乏切口，因为一面是技术领域的还在不断变更的潮流，一面是源流深远且每个脉络都已经可以分支成学科的主义，而我对他们的想法和理解都更多来自于感知而非理论。

不过一个大约的、基础的感想是，Open-source software movement 听名字感觉像是一个有点“左”的运动，实际上核心却是注重协作方式和效率，而几乎是刻意地不强调潜在的政治性或者道德性，Free software movement 更多给人以一种 moral duty 的感觉，但是其 political 程度又不足以和 communism 有太多联系，或者因为根本就来自不同的出发点和目的，只是/但是在形式上（甚至情感上）给参与者分享一种近似的体验。

今天刷到一篇 blog 自由軟體運動算不算是一種共產主義？¹，想起来之前的想法，觉得几个概念总结起来很有意思，视角也相对比较全面（尽管难免有其倾向性）。里面也引用了一些值得参考的文章：

Microsoft 前執行長史蒂芬·巴爾默說過，Linux 就是共產主義，見 MS’ Ballmer: Linux is communism。應該是出於商業競爭的批評，而非以政治意識形態下去討論，畢竟自由軟體基金會曾經掀起一波又一波反 Windows 的社會運動，然後又有企業級的 Linux 出現，作為 Windows 的有力競爭對手。現在 20 年過去了，Microsoft 開始擁抱 Linux 技術了，搞出 WSL 並與 Canonical 合作，將 Ubuntu 整合進來，不再完全排斥 Linux 系統。但依然有人質疑，他們只是想要藉此吞併 Linux 達成商業目的。

知乎文章 共产主义=开源？开源软件的开发模式揭示了社会主义的生产组织方式 的作者認為自由軟體運動就是促進共產主義的方法。但他批判自由軟體運動缺乏列寧式的政治領導意識，且沒有集中領導提昇生產力，使得運動駐定會失敗……按照作者的想法，我們應該組織無產階級先鋒隊，砸爛一切 Apple 與 Microsoft 專賣店裡面的產品嗎？

Reddit 文章 The failure of the free software movement 則認為自由軟體運動失敗了，他稱自由軟體運動為「布爾喬亞式的烏托邦幻想」，因為軟體都由個人駭客開發，沒有科學化的集中管理，生產力低落。且個人電腦的普及，也是資產階級在玩的東西，不集中管理的話會造成生產上的浪費。

編程隨想則是用更激進的方式反駁人們對自由軟體的誤解。他在 澄清“自由软件、开源软件”相关概念及许可证的误解 一文中引用了海耶克的觀點，即共產主義就是自由的終結。

順帶補充一點，自由軟體由許多駭客分頭開發，共同組成的社群生態，倒比較像安那其主義。這篇 Software and Anarchy 的論文能闡述這一點。如果套用到當今 Web 3 掀起的去中心化潮流，這確實促進了安那其主義的發展，這個新興概念叫做「資訊無政府主義」。這肯定是追求政府集中權力的共產黨人所不樂見的。如果軟體被迫公有，且只有這一種選擇，那肯定不是自由軟體運動所追求的目標，也會反過來成為壓迫所有人的新興力量。

此外作者也提出了一些很有意思的观点：简单来说，GPL 的“自由”来自于自愿契约，而非国家公有，同时作者保留了一部分的权利，因此在更“法律”的角度讲，“自由”并非源自产权的消解，而是源自著作权人主动以合同的方式限制自身权利的使用方式。

读罢以上难免感慨——正如历史，意识形态与社会运动在话语之间也变成了任人抱养的小男孩。但对我的问题，真正要厘清的，无非是这几个运动、思潮乃至主义之间哪里相似、哪里不同。而回到最初的问题：所以，自由软件运动有政治性吗？其实无论发起人 Stallman 个人的观点如何，一个运动能够引发如引文所述的来自各个立场的种种讨论，本身已经足够证明其政治性与政治性的影响力，更不必说“自由”以及与之相关的许可和协议作为一种契约也触碰了知识产权制度和技术资源的社会分配问题，而这些都是典型的政治议题。

那么，如何分析自由软件运动的政治性，以及其与共产主义的关系？首先从来源上，其政治性不来自阶级斗争，而是基于不断迭代的技术体系基础（例如 Git）、许可协议和技术体系，这也引出自由软件运动最与众不同也是最重要的一点——由计算机技术驱动，以及对其技术的绝对强调（“Talk is cheap. Show me the code.”）。其规范不是来自任何国家/企业/权威，而来自于技术体系自身的规则和范式。也就是说，代码取代其他自上而下的规范，作为技术性的先验结构界定了种种行为的合法性。

基于这样的结构，自由/开源软件也实现了一种类似于“生产关系/生产力”的自我再生产逻辑，而且在生产资料和劳动成果的公共性、生产者的社会关系上都十分相近。但不同之一是，共产主义语境中的“再生产”主要包括物质生产的再生产和社会关系的再生产，而自由/开源软件更像是一种代码和社群结构的自我再生产，而这的最本质的区别在于后者拒绝将自身纳入权力机构的话语体系，而采用许可证（法律）的形式决定生产成果的有限制的公共性。因此尽管产生了形式上的相似，自由软件在事实上仍然更接近于资本主义的“体系”下的一种由法律规范的公共领域——或者更学术地说，recursive public（Kelty 2008）²。

除此之外，我认为二者之间最大的区别在于资源的 accessible 和再分配问题。相比资产国有+社会主义再分配，知识、信息、软件这些资源本身不具备“数量有限、必须分配”的物质性特征。对数字资源来说，复制的成本远低于生产，也根本不存在分配的问题；更特别的，对于代码，其自身不仅具有可复制性、可修改性，还有很强的可衍生性，由这样的技术基础，产生的结构其实更类似于无中心自治体。近几年流行的社交平台 Mastodon，我想应该也是类似的理念。

自由软件运动也让我想起 Guerilla Open Access Manifesto，一篇更带有个人情绪色彩的宣言。相比“open-source”，“open access”可能更接近“free software”的动机。而贡献者的动机恰好也是最初让我开始考虑此运动和共产主义之间关联的起点，因为很多人都对于知识和软件共享持有一种相对更理想主义的信念或态度。这种从朴素的共享的伦理出发的行动逻辑，与共产主义中强调的以共同体为目的的劳动等价值具有某种结构性的相似。不过这种理想主义不依赖宏大叙事也与政治刻意保持距离，更接近于通过技术、协议与协作，在整个无中心的网络中自然生长出来的公共价值，而这样的价值在今天面对不论是姓资还是姓社的主义面前都有种珍贵的自由感。

总结而言，在我看来，自由软件运动以技术与法律为工具，重新组织了信息社会中的权力分配方式。其政治意义不在于它是否“共产主义”，而在于它是否提供了另一种理解公共性、生产力、协作网络与资源再生产方式的可能性。不过，在人工智能技术尚且处于发展“混乱期”、监管技术和相关法律都尚未完善的今天，公开乃至私有的代码仓库被批量抓取用于训练 AI 模型，同时人们也借助诸如 AI agent 对话或者直接生成代码，乃至完全由 AI 自主决策和执行，新的创意和更多垃圾都在更快地被实现。这对当前还未确定的协作模式提出了新的挑战：更多的（非专业的）生产者得以参与其中，AI 自身不仅成为生产者的一员，甚至成为生产主力。开发效率被更进一步地大幅提高，代码的质量、安全性和法律合规性也面临着新的挑战，但更重要的问题是，这种新的范式是否会催生出新的政治经济模式？

Obsidian stores notes as local markdown files — lightweight, portable, and fully under your control. You can organise, back up, and sync them in any way you like.

But any markdown editor can do that. What sets Obsidian apart is its refined note-taking experience and bidirectional linking, which turns isolated notes into a connected knowledge graph. On top of that, it offers a rich plugin ecosystem that covers everything from automation to the smallest quality-of-life tweaks, with css customisation, vim keybindings, and queryable note databases.

Below are some of the plugins and settings I use:

1 Plugins

• Advanced Tables
• Calendar: a nice and simple calendar widget, suitable for daily notes.
• Clear Unused Images: clear the images that are not used in note files anymore.
• Commander: it can add commands everywhere in the Obsidian UI, I don’t really use it a lot but still find it useful.
• Contribution Graph: it can generate interactive heatmap for your notes, but I don’t use it anymore as I prefer to sync my notes to GitHub and view the contribution graph on it.
• Dataview: you can create a database from your obsidian vault, but Obsidian has its own database system now.
• Enhanced editing: bulk edit for obsidian
• GDScript Syntax Highlighting: It adds GDScript syntax highlighting.
• Git: add Git and other features in Obsidian. It’s the best!
• ibook: the built-in solution to export iBook notes can be painful, and this plugin is a good alternative to export mac ibook annotations/hightlights to markdown.
• Kanban: it does the job, but I’m not a big fan of any kanban.
• Latex Suite: it makes typesetting LaTeX faster, and saves me time on memorizing some LaTeX commands.
• Lazy Plugin Loader: it makes obsidian startup faster by loading some plugins with a delay.
• Linter: it lints your markdown files.
• Local GPT: I really like the concept of ollama + personal vault of notes, but the performance is not good enough.
• Mindmap NextGen: Create mind maps.
• QuickAdd: it’s seems like a good plugin but I don’t think I can make use of it.
• Pandoc Plugin: I use this plus customised template to export my notes to PDF through LaTeX.
• Smart Connections: I like the idea but… I guess I just want to keep obsidian as a note-taking & thinking zone, and I prefer to think and connect my notes with less help from AI.
• Tag Wrangler: bulk edit for tags.
• Templater: it allows you to insert variables into your templates.
• Terminal: it integrates terminal to obsidian, which is quite helpful for many tasks that involve running commands.
• TaskGenius: it used to be a simple task progress bar, but now it’s some kind of comprehensive task management plugin. I prefer the old version tbh.
• TODO | Text-based GTD: it generates a GTD task list from your notes, but I don’t use it that often (though I should).
• Word Splitting for Simplified Chinese in Edit Mode and Vim Mode: quite useful for Chinese word splitting.

2 CSS

These are some of the css snippets I use in obsidian:

• Change comment rendering style (%%)
• Faded emoji in task
• Heading indicators
• sidenote auto adjust

3 Fonts

• UI Font:
  • SF Pro
  • Gentium Book Plus
• Body Font:
  • Source Serif 4
  • Source Han Serif CN VF
  • Gentium Plus
• Code Font:
  • Source Code Pro

With bony hands I hold my partner

On soulless feet we cross the floor

The music stops as if to answer

An empty knocking at the door

It seems his skin was sweet as mango

When last I held him to my breast

But now we dance this grim fandango

And will four years before we rest.

几天前和 w 闲聊，聊起文学作品的电影改编，比如莎士比亚和简·奥斯汀。她说以后或许可以写一篇叫 Born adapted 的论文（效仿 Born translated），研究作者在创作作品的时候是否已经有意识使作品更适合被影视化，或者也可以联系电影史研究写作的时候哪些作家受到了什么电影的影响。那几天我恰好刚开始玩 《冥界狂想曲（重制版）》（Grim Fandango Remastered），于是不假思索地回复她说感觉那样会有点不太好写，因为更常见的影响链或许应该是 文学 -> 电影 -> 电子游戏，特别是在题材和一些具体表现形式上，例如叙事视角与场景转换，尽管每个具体作品创作时受到的影响肯定是更错综复杂的。在之后的几天里，每当启动这个游戏，我就总开始赞叹于这部游戏独特的风格和浓郁的电影感，而上一部让我感觉特别有电影感的游戏还是深受黑泽明电影影响的《黄泉之路》（Trek to Yomi）。

一、在传统冒险游戏与互动电影之间

I’m gonna let it shine, let it shine, let it shine, let it shine!

从第一幕 cutscene 开始，Grim Fandango 就已经通过电影般的镜头语言向人展现出自身超越一般 AVG 的、作为互动电影的巨大魅力——利用连续几个瞄准死神走近着的影子的分镜，即将被玩家操控的主角 Manuel Calavera（一般被叫做“Manny”，而 Calavera 在西班牙语中其实正是头骨，常见于墨西哥亡灵节）身穿斗篷举着镰刀在阴影中露出脸，却用公事公办的销售语气对茫然的新来到 Land of Dead 的新鲜客户推销起将要进行的四年灵魂旅行的旅行套餐。简单几句话，不仅让不熟悉亡灵节文化背景的玩家大略了解了游戏背景，也奠定了整体的冷幽默与黑色基调。很快，玩家也将发现 Manny 看似高端的这份死神职业只不过类似于 community service 的还债工作，不仅会因为业绩被老板斥责，他的斗篷下脚底还偷偷踩了高跷以增加身高，手拿的镰刀竟然也是相当现代化的便携折叠款。至此，传统意义上的恐怖死神印象彻底被消解，正如（在我这个中国玩家看来）亡灵节也以其轻松和团聚的气息、鲜明的装饰、食物和鲜花一定程度上消解了人对于死亡的恐惧。

很快，借由不明原因的销售业绩严重下滑，Manny 逐渐发现了上司 Hector LeMans 与同事 Domino Hurley 似乎有所密谋，并开始以个人的力量与之对抗，而第一步只是简单的——抢客户。玩弄小花招提前搞到客户信息、带着大块头的天真小弟一路飞车、接到品行无瑕理应得到高端 Number Nine 列车旅行资格的美女优质客户、发现随之而来的重大阴谋并决心寻求某种公正，Grim Fandango 在开始就迅速集齐了黑色电影的绝大多数必备元素（由于在题材上也涉及了资本主义、腐败、工会与革命，因此也有点红色），在叙事的内容与表现方式上都显得更加具有“电影感”。不仅如此，LucasArts 也为 Grim Fandango 配备了高水平的 Soundtrack 和细节丰富的高质量配音，给玩家提供了良好的沉浸感。

虽然在形式和题材上 Grim Fandango 都相当“电影化”，它仍然逃不开作为冒险游戏的本质，而它在冒险和谜题设计上多少有些争议，原因相当简单：有些解谜方式设置得有点太离谱，不少情况如果不看指南玩家很难猜到正确的方式（具体还是不剧透了）。不过本来就是架空世界观的有点幽默风格的游戏，其实想想解谜比较离谱倒也可以理解。操作上也有点抽象，甚至专门有个成就名叫“The Right Way – Play the whole game with tank controls. Tim demanded this achievement.” 虽然实际上可以在设置里开启 tank controls 然后之后正常使用鼠标点击游玩游戏，但总之就是这些时刻（外加一些少量的 bug）让你意识到它已经真的是一款超级老的游戏（比我还大几岁）了，对它的这些时代原因导致的缺点要宽容一点点，对它整体的跨越年代的震撼体验要额外赞扬。

抛开略微有点折磨人但也很有趣的谜题设计，Grim Fandango 在叙事上其实相当优秀，以电影的节奏在起承转合之间讲好了一个关于死亡与新生、腐败与革命、爱与恨的故事，而多数谜题其实都严格地为剧情服务，只是有点脑洞大开。除此之外，游戏中也有相当多鲜活立体的出场角色，比如主角的好朋友，不需要被任何人拯救的 Glottis；比如在海底一直绕圈走的唱着歌一路步行抵达终点的 Chepito；比如在临终时刻还在绝望地寻找爱（“Tell me Manny, would I have had a chance?”）的 Lola。每个人都以独特的属于他们自己的方式走向了最后的终点。

二、想象性的共产主义死神镰刀

¡Viva La Revolución!

尽管相关方面的讨论似乎不多，但是与常见的犯罪侦探或英雄救美题材的黑色电影不同，Grim Fandango 的主线剧情是相当明确和明显的早期社会主义革命剧情：发现并对抗权力资本腐败、参加地下革命组织（在游戏中组织名叫 Lost Souls’ Alliance，其首领 Salvador Limones 感觉长得有点像切·格瓦拉……）、夺回被剥夺的普通人的车票（权利）、夺回被掌权者占据和蒙骗的（无辜而美丽的）女性、带领普通人坐上属于他们的列车以通向灵魂最后的终点。在这个亡灵社会缩影中，即使最初的设定是根据死者生前的品行来评估并通往终点，一种传统观念里期冀的因果报应，但在 Manny 上司的操控下死者仍然被阶级和财富分层，这也是剧情的核心矛盾。尽管其中也包含“英雄救美”的传统要素，但游戏中 Manny 对 Meche 几乎并没有太多情感的表达，只是反复强调是自己的错导致 Meche 无法正常坐上通往终点的、她生前品行良好的生活使她应得的豪华列车，他的等待和寻找都更多是为了自我赎罪，而不是追求感情。

这样的剧情设计和意识形态的影响在游戏中的女性角色形象中体现得相当明显：作为剧情中的女主角之一和被 Mario 追寻拯救的 Princess Peach，Meche 也完美符合一般的革命文学的被拯救女性的特征：纯洁而品行端正、作为死人显然也没办法有太多与原生家庭的纠葛、在完全无辜的情况下被权力资本夺走了属于自己的车票和命运，在被蒙骗和重新认清事实后，她无缝衔接地加入了为地下组织服务的阵容中；扮演上司的秘书但其实一开始就成为地下党的接线员 Eva 则是“妇女能顶半边天”类形象的案例，她拒绝了所有性缘关系，以完全投身于革命事业；聪明却善妒的、容易爱上错误的男人的 Lola 尽管贡献了关键的一张照片，却仍然难逃灭亡的命运；周旋在几个资本家和革命组织领袖之间的 Olivia 则是一款经典的“蛇蝎女人”形象，一个自由派机会主义者，人们不可抵挡地被她魅惑然后背叛，但自身最后也总要迎来某个机械降神的悲惨结局。

不过值得注意的另一点是，Olivia 同时也是一家小酒吧 The Blue Casket 的 Owner，平时向顾客售卖的呃呃其实是脏水（这次是真·刷锅水），而里面的顾客也只是一群虚伪的、空谈的、伪装的社会主义者，会给念同一首诗的不同人以极端差别的回应，会因为你是你而鄙视你但因为你认识某个大人物而崇拜你。这里的社会主义只是作为 aesthetics and niches 而存在。在游戏中，玩家扮演的 Manny 也可以上台念诗，而游戏提供的念诗方式因为本身的对话点击形式而格外有趣——对于每一行诗，游戏随机提供给你一些破碎的诗意的片段，而玩家可以随便把他们组合起来就变成一首诗，多少有点对无病呻吟艺术作品的嘲讽感。不管是 Olivia、她的顾客们还是酒吧里的诗，整体都显然代表着一种虚无主义的立场。另一个有趣的地方是，Olivia 本人创作的诗句（也就是本文开篇引用的段落）“But now we dance this grim fandango /And will four years before we rest.”是整个游戏唯一一次对“Grim Fandango”的点题。

与空谈的顾客们相对，在 The Blue Casket 外不远处就有一群罢工的工蜂（不要太明显的比喻），他们是没有原始生产资料的生产者，在既有的体系下连工会费都无法缴纳。他们有愤怒但没有表达的话语系统，因此只需要给他们一本红色书籍就可以掀起变革。虽然玩家其实并不会知道工蜂引导的变革最终结果会是什么，但是游戏中最有趣的成就之一就是“ME, ME, ME-ME-ME!”，玩家需要操控 Manny 跟工蜂一起喊口号，如果喊得不齐还会被指责，简直特别幽默——在尚未争取到权力的时候对整齐和协调的强制性要求就已经出现了（截止写作，只有 4.9%的玩家达成了此成就）。

不论如何，Grim Fandango 并不是一款严肃地讨论相关题材的游戏，而只是以一种相对积极的态度把有共产主义色彩的思想融入到了主要剧情中，整体上仍然是黑色电影风格的。和其他很多架空世界观的作品一样，Grim Fandango 里的共产主义也是想象性的。如果说游戏对于死神的可折叠镰刀意象的消解相当成功（玩家很快就只是把镰刀当作工具、当作武器，而容易忘记它收割灵魂的原始功能），那么对共产主义镰刀的刻画更经典而刻板，但多少带一点嘲讽意味。在这方面多少会有点让人想起来极乐迪斯科——它教你渴望改变世界、让你开始试图寻找某种方法，甚至游戏制作者本人的情感认同可能也更偏近于康米主义，但游戏里的自称康米主义者多数都是一些乱七八糟的人……是的，它也告诉你康米主义是注定失败的主义。

三、死亡，与再次死亡

I was born free. Nobody GAVE me no ticket, so nobody can TAKE it away.

说到死亡，我最近经常会想起马尔克斯在《梦中的欢快葬礼和十二个异乡故事》里的那篇序，他将其解释为自己身份认同感的觉醒：

有一天，我梦见参加自己的葬礼，走在一群朋友中间，大家穿着肃穆的黑衣，气氛却像过节般热烈。所有人都因为相聚而感到快乐。而我则比任何人都快乐，因为死亡给了我这个同拉丁美洲的朋友们欢聚一堂的好机会，他们都是我最老最亲同时也阔别最久的朋友。葬礼结束，人们开始散去，我想陪他们一同离开。但其中一个朋友的话却如当头棒喝，让我意识到，对我来说，节日已经结束。“你是唯一不能走的人。”他说。直到这时我才明白，死亡就是再也不能跟朋友们在一起。¹

这似乎是一种很经典的很拉丁美洲的想法（请忽略我口不择言的形容词），即死亡是关于记忆与遗忘的，死亡似乎不是肉体的死去，而是你要永远离开你亲近的人，直到有一天被他们遗忘。这很容易让人想起那句《寻梦环游记》里的经典台词“Death is not the end of life, forgetting is.（死亡并非生命的终点，遗忘才是）”

而 Grim Fandango 用另一种方式讨论死亡与第二次的死亡。如前所述，游戏第一幕 Manny 就已经告诉顾客，他之所以做这份工作是要“还债”，但用更好听的方式也可以说成是“自我救赎”。在遇见 Meche 并无意间揭开一场巨大的骗局之后，他不再仅限于自我救赎，而开始试图挽救其他无辜的普通人，要帮这些人最终可以抵达终点。这里的终点到底是什么，终点之后又会是什么？Manny 也没有答案。在结尾 Meche 困惑地问他“Are we going to be together?” 他对 Meche 说：“You know, sweetheart, if there’s one thing I’ve learned, it’s this: nobody knows what’s gonna happen at the end of the line, so you might as well enjoy the trip.” 然后他们很烂俗而夸张地、却又实在是释然而快乐地拉上列车窗帘接吻，然后随着列车一起驶入未知。

不管有怎样的外壳，Grim Fandango 仍然是一个关于死亡的故事，而这也是它的魅力的根本来源之一，因为人们永远会对死亡和阐释死亡的一千零一种方式无限好奇。在《寻梦环游记》中，万寿菊是亡灵世界里唯一有生命的植物，是引领亡者的花朵。而在 Grim Fandango 中，骷髅们躯体的死亡会伴随着花朵的产生，因此美丽的鲜花对他们来说却意味着痛苦的生命之毁灭、腐败和消亡。尽管每个人其实都已经死过一次，但第一次死时多数人都有点茫然，所以大概还要花四年时间来适应、来自我救赎、来最终解脱。而不管是作为亡者的引领还是亡者再一次消亡的产物，鲜花总仍然意味着生命和生命力，因此骷髅身躯的死亡产生鲜花也其实意味着死亡带来新生。

因此，Grim Fandango 不是那种惯常的关于死亡与遗忘的故事，你的第二次死亡并不一定是所爱之人的遗忘，而是关于你与自己的和解：关于如何自我救赎、如何现实地面对死亡——你的躯体会切切实实地被分解，成为土壤成为空气成为花朵，或者成为别的我们尚且不知道的某种事物——但在此之前，你尚且仍有机会做点什么。

简而言之，我选择的标准基本上是试图兼具高效实用和款式经典简单，并尽量选择耐用但并不因此价格超出所值过多的产品，而这种选择标准显然也可以不仅限于电子产品。我想这样的选择标准有助于我过上一种尽量简单的、低物欲的、可以随时拿起背包离开去任何其他地方的生活，而这是我一直都想获得的。

写下这些，突然想起很久之前读过的《达摩流浪者》里面的一段话：

“……我一直在读惠特曼。你知道他怎么说？‘奴隶们欢呼吧，让外国的暴君心惊胆战’。他的意思是这才是一位吟游诗人，一位旧日沙漠荒路上疯癫的禅僧诗人应有的态度，你看他说的整个东西就是一个满是背包漫游者的世界，达摩流浪者们拒绝屈从普遍的人生需求。这些需求要求人们消费产品，因此不得不通过工作换来消费的特权，消费那些他们其实并不想要的垃圾，像冰箱、电视机、汽车（至少那些浮华的新车）、某种发油、除臭剂，还有那些常见的垃圾，你买来后一礼拜内就丢进垃圾箱里的东西。所有人被囚禁在一个由工作、生产、消费、工作、生产、消费组成的牢笼里。我看到一场伟大的背包革命正在展开，成千上万甚至上百万美国年轻人背着背包四处漫游，爬到山上祈祷，让孩子们笑，让老人们开心；让年轻的姑娘快乐，让年老的姑娘更快乐。所有那些尝试写诗的禅疯子没来由地恰好出现在他们的脑海里。他们通过好心行善与怪诞不经的行为，给所有人，给所有的生灵带来永恒自由的愿景。这就是我喜欢高保和史密斯的地方，你们两个家伙是东海岸来的，我原以为那地方已经死了。”¹

就是这个意思。

初步配置参考：

• OCD’s Guide to Setting up Mac
• Introduction · macOS Setup Guide

Useful Links:

• macOS defaults list
• Free Macintosh Software!

1 macOS 实用快捷键

Mac 键盘快捷键

可以用 cheatsheet 软件来快速了解每个软件的快捷键，但是有些软件的似乎不太全……

• 最小化窗口：command+m
• 最大化窗口：双击应用顶部（再次双击可以恢复之前的大小）
  • 按住option ⌥将鼠标移动到绿色按钮处即可看到最大化+标识，可以将窗口调整到适应屏幕最大，双击应用顶部也可达到同样效果。
• 全屏化窗口：control+command+f
• 关闭窗口：command+w
• 关闭当前软件：command+q
• 强制退出软件：
• 隐藏窗口：command+h（很少用）
• 切换应用:
  • command+tab，但是特别难用，只能点开已经打开的软件，最小化了的都打不开
• 锁屏：control+command+q
• 在当前 App 的多个窗口间切换：command+重音符 (\)`
• 强制退出应用程序
  • 普通直接关闭窗口和退出程序是command+q
  • command+option+esc
  • 如果这个也没有用可以直接长按电源键关机重启

1.1 我的自定义快捷键

新建 txt 文件：control+option+n

1.1.1 快捷键分屏

在 Windows 上直接通过将窗口拖动到屏幕边缘，或使用 Win 键 + ←→↑↓就可以快速实现分屏操作。在 macOS 可以进行一些简单的系统设置来弥补这个缺陷： 在“设置”中检索“快捷键”，选择“键盘”下面的“键盘快捷键”，点开选择“APP 快捷键”，分别添加“缩放”、“将窗口移到屏幕左侧”、“将窗口移到屏幕右侧”，并选择相应快捷键。

我目前用的快捷键组合分别是：option+↑、option+←、option+→。这个设置和少量 app 会有快捷键冲突（特别是缩放那个按键），多数好像都可以。

rectangle app 的快捷键组合是 control+option+←→↑↓，以及control+option+-和control+option+=来缩放，优点是有上下分屏缺点是没有动画，不如原生的好看。

更新: macOS15 之后已经内置了类似的分屏操作。

1.1.2 触发角快捷键

在系统检索即可调整，目前左下角是调度中心右下角是桌面。

2 实用工具

2.1 软件下载安装管理

主要用 Homebrew 或者从官网下载，偶尔用 App Store。

为了安装 Game Porting Toolkit，也安装了 x86_64 version of Homebrew（/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"）。

2.1.1 切换 Homebrew 环境变量

• 使用 Apple Silicon 版本的 Homebrew：

  export PATH=/opt/homebrew/bin:$PATH

• 使用 Intel 版本的 Homebrew：

  export PATH=/usr/local/bin:$PATH

2.1.1.1 设置brew环境自动切换

cat << 'EOF' >> ~/.zshrc
if [ "$(arch)" = "arm64" ]; then
    eval "$(/opt/homebrew/bin/brew shellenv)"
else
    eval "$(/usr/local/bin/brew shellenv)"
fi
EOF
source ~/.zshrc

后续只需要在终端先执行arch -x86_64 zsh，就能自动切换到x86，不执行这段命令就会默认用arm版本。

2.2 Office 和 LaTeX

Office：在学校的正版化平台下载了 Microsoft Office，同时也看推荐下载了 LibreOffice 和 Only Office 备用。尝试使用发现后者虽然界面和微软的几件套很像，但是似乎打开其他人的 docx 文件还是可能会出错，所以卸载了。

\(\LaTeX\) 编辑器：在线用 Overleaf，本地使用 MacTex，编辑器先尝试了 Texifier，之后改用 VSCode + LaTeX Workshop，不过一般来说 Latex Workshop 最好额外修改一些设置，可以检索搜到不少相关教程。

2.3 浏览器

平时一般用 Safari+Google Chrome，偶尔用 tor 和 Safari 内置的 DuckDuckGo。之前看到很多人在推荐 Arc，感觉虽然很好看但有点没有 get 到好用之处在哪里，所以试了一下就卸载了。

2.3.1 Safari 插件

• AdBlocker: 屏蔽广告，免费版已经够用
• Hush: 屏蔽 cookie 弹窗
• URL Linker: 方便地在右键菜单复制 markdown 格式的当前网页链接
• Userscripts: An open-source userscript manager for Safari, 可以使用油猴脚本
• Obsidian Web Clipper: obsidian 官方制作的抓取网页内容的插件

2.3.2 Chrome 插件

• 油猴（Tampermonkey or Violentmonkey）：不必多说
• Zotero: 看文献必备
• Copy Markdown Link: 方便地复制 markdown 格式的网页链接
• Hypothesis: 可以用来标注一些网页内容，支持添加注释和跳转，很好用强烈安利（Safari 其实也支持用但不是以插件形式）
• Obsidian Web Clipper: obsidian 新出的抓取网页内容的插件
• SteamDB: 查看游戏历史价格，偶尔可以用来临时工入库
• Webrecorder ArchiveWeb.page: 可以把网页内容下载保存下来
• 豆伴：豆瓣账号备份工具，已经很久没有更新，目前（2024-01-13）书影音都无法爬取，只能备份游戏、豆列等
• Bionic Reading: 通过加粗单词前一两个字母的方式帮助实现量子速读（误）
• 尝试过一些 Chrome 插件商店里的番茄钟软件，感觉都一般

2.4 时间追踪与任务管理

目前正在尝试使用 ActivityWatch，一款开源免费的时间追踪软件。同时也使用 Toggl（用来做任务、日程管理和设备同步）。 不过自从 macOS 某次更新大幅优化了系统自带的 App & Website Activity，我就很少再查看 ActivityWatch 了。

更新：不再用 toggl，改用 Session 当番茄钟专注软件

每日的任务管理主要在 Obsidian，同时用 reminder 搭配reminders-menubar来记录即时任务，特别好用强烈推荐！因为我脑子里总是会突然各种灵光一闪，可以先都紧急记在这里以后再做。

2.5 媒体播放器

搜了一下主流选择有：

• Elmedia Player
• IINA
• mpv.io
• VLC
• Infuse 7
• nPlayer
• Fig Player (Renamed from PotPlayer X to Fig Player since version 1.1.0) - Oka Apps

我目前选 IINA 播放本地视频，Infuse 用来连 emby（不常用）。

2.5.1 音乐

Apple Music + Spotify，YouTube Music 只是偶尔会用。

🤔发现 Apple Music 可以在播放歌曲时按下 Option 键，然后点按播放控制中的“妙选随机播放”按钮（说起来总觉得 Apple Music 的算法更得我心）。

2.6 笔记

平时几乎所有笔记、日记都会用 Obsidian，看论文用 zotero +各种插件，偶尔也用 VSCode、备忘录和 Goodnotes 乱写。

浏览网页时用 Hypothesis 插件进行注释：支持 Markdown 和跳转，同时可以导入 Obsidian，很好用！ 现在要么一键导入到 obsidian 要么就直接在 obsidian 记笔记了，很少用 hypothesis，因为导出的 markdown 效果并没有很好。

有点想学：

• How I draw figures for my mathematical lecture notes using Inkscape | Gilles Castel
• neovim

2.7 阅读

• 图书 app：多设备通过 iCloud 同步，highlight 和记笔记方便，阅读时间有记录+可以每日打卡；
• 微信读书：epub 支持良好，记笔记和导出笔记都很方便，阅读时间有记录，缺点是书架有上线，而且很多之前能读的书籍已经被下架；
• Zotero：文献，引用方便，支持 Markdown 和跳转，缺点是占用内存太大，但笔记可以通过插件导出到 Obsidian；
• 格式转换：Calibre（各种电子书格式）、简悦（网页转 Markdown）、Pandoc
• 稍后阅读：Omnivore（支持各种设备同步、导出到 Obsidian，还支持高亮、笔记和 RSS）
  • 不过说起来我发现自己并没有养成稍后阅读的习惯……如果不立刻解决以后肯定会忘记！
• RSS：最近很少用

2.8 卸载和清理

• OnyX
• 如果是 App Store 下载的软件，可以长按后点击左上角❎卸载软件
• 如果是 homebrew 安装的软件，可以用 brew uninstall 卸载
• 其他可以用 AppCleaner 或者 PrettyClean，后者也可以用于系统清理
• 如果想清理近似的或重复的图片，可以用 PhotoSweeper

2.9 其他

• asciinema: 录制终端 session 的小工具
• Easydict: 很好用的开源免费划词翻译
• Maccy: 很好用的开源免费剪贴板管理
• MonitorControl: 很好用的开源免费调节外接显示器亮度的工具

3 系统设置与自带软件

3.1 电源管理

3.1.1 battery

更新：bclm 已经不再支持最新 macOS 系统 keyNotFound(code: "CHWA")

遂改用 actuallymentor/battery: CLI/GUI for managing the battery charging status for Apple silicon (M1, M2, M3) Macs

3.1.2 BCLM

一开始尝试了AlDente，但是它功能太花里胡哨而且收费，遂卸载之。之后安装了 BCLM

brew tap zackelia/formulae
brew install bclm

实际设置最大充电：

sudo bclm write 80
bclm read

（最大问题就是只能设置为 80 或 100，不过也够用了反正）

设置持久化：（关闭就是改成 unpersisit）

sudo bclm persist

3.2 输入法

由于偶尔会输入 ipa，所以额外下载了 rime 的鼠须管。需要在“设置”-“键盘”-“文字输入”-“输入法”的左下角通过➕号添加。也可以通过它很方便地配置其他输入法。

3.3 美化

• 平时在 Finder 很常用图标视图，所以从macosicons.com下载了很多实用的文件夹图标，复制之后点击相应的文件夹右键“显示简介”，选中左上角文件夹图标粘贴即可；
• 在不开启台前调度的时候用HazeOver，可以更方便地专注当前窗口，而且如果通过了 GitHub 的学生认证可以在GitHub Student Developer Pack里免费领取；
• 我的 MacBook 是屏幕上方有 notch 的机型，虽然并不觉得很碍眼但有时候会挡住 menu bar 的一些图标，所以用开源免费的Ice 来管理

4 效率与文件管理

4.1 窗口管理

一篇文章让你透彻认识 Mac 应用切换和窗口切换的逻辑

平时我就只是使用普通的视图，但如果想快速地切换应用的话我会临时开启台前调度模式。

4.2 文件管理

有看到一些 Finder 的插件或者其他很高端的文件管理软件，但我觉得 Finder 已经很好用，特别是检索起来特别快（之前用 win 的文件管理还不得不额外装一个 everything 来专门检索），而且标签系统也很好用。

用 brew 安装了 tree，可以递归目录列表命令，生成文件深度缩进列表。 用法：

tree -L 1

4.3 文件传输

苹果设备之间直接隔空投送就可以，和非苹果设备为一般用 Resilio Sync 来共享文件，好用且安全。由于我的鼠标还支持 Logitech Flow 功能，所以也可以直接在两台都配对了同一个鼠标的电脑直接复制粘贴。

如果是要给其他人发送文件，总觉得让人额外下载一个软件太过麻烦，而且也不是所有人都有每个网盘的账号/网盘仍然有剩余空间，而且网盘的审查和限速也很恶心，所以我平时用 Transfer.zip 来分享文件。如果是临时传输，可以在不关闭网页的情况下传任意大小的文件；也可以选择注册账号传输，会有 11 GB 的免费空间，传后即删的情况下这个空间绰绰有余，接受者无需注册账号直接点击链接下载即可，而且国内好像没有墙。总之很好用强烈安利！同类型的网站搜一下还有很多，例如 FilePizza，不过大多只支持临时传输。

以上所有这些只因为我不想再用 QQ、微信或者网盘传输文件……

4.4 硬盘空间管理

除了设置里自带的硬盘空间管理之外，也可以用 DaisyDisk 或者开源免费的 GrandPerspective 来更详细地可视化和管理（之前在 Windows 我会用个人使用免费的 WizTree，优点是速度特别快）。

5 Bug、水土不服与解决

5.1 程序坞与托盘

在 win 中，不是所有正在运行的程序都显示在下方程序坞里面，而是可以只显示在托盘里。我一般只让程序坞显示自己最常用的几个软件和当前正在运行的软件。

而 Mac 中仅有少数正在运行的软件可以不显示在程序坞里，难免让人觉得眼花缭乱……

更新：已经自适应。

5.2 FaceTime 声音问题

发现在 FaceTime 通话的时候如果打开别的播放声音的软件，Mac 会自动降低那些软件的声音，而且我没有找到可以调节的选项。之前用 Windows 系统电脑的时候我一般会用 EarTrumpet 来调整不同应用的音量，在 Mac 目前没有找到特别合适的开源软件，暂时用 SoundSource 来控制音量。不过发现 SoundSource 虽然可以调节，但是在开启 FaceTime 通话之后对方的声音会有重（chÓng）音，感觉可能是声道设置的问题，暂时没找到解决方案。

5.3 修复 steam 游戏图标

macOS 下修复 Steam 游戏图标

不同游戏修复方法可能不一样，能改的都改一遍就行。不过最好的办法其实是下载游戏的时候不要创建快捷方式，因为不然卸载的时候还要手动删……

5.4 在 macOS 上快速新建 txt 文本文件

• 已解决，参见上文快捷键部分。
• 也可以改变思路，看到很多人说会先打开编辑软件再考虑保存问题（但我懒得改）
  • 解决保存文件时隐藏路径不显示：可以直接Command + Shift + G，然后复制粘贴相应路径
• 也可以用touch命令，形如touch ~/Desktop/newfile.txt

5.5 Mac 输入法如何打出 command 和 option 等符号

fn，点右上角放大之后在自定符号里面增加“技术符号”即可。

5.6 键盘屏幕清理

说是键盘很容易油什么的，感觉就擦吧无所谓了。屏幕我直接用相机的清理套装的喷雾喷在眼镜布上擦。

5.7 游戏

macOS 游戏兼容性查询：

• MacGamingDB | Apple Silicon Mac Games – Compatibility & Benchmarks
• M1 compatible games master list - Gaming on M1 Apple silicon Macs and MacBooks, bugs, fixes, compatiblity and troubleshooting guides - AppleGamingWiki

感觉 steam、GOG、itch 和 Epic 的 macOS 版本都依托答辩……所以现在用Heroic Games Launcher来替代 GOG 和 Epic。

5.7.1 Good Old Games

提供 Good Old Games 的不仅有 GOG，My Abandonware等网站也提供不少老游戏的下载资源。除此以外，也有少数经典游戏已经有了开源重制版，例如 OpenRA、OpenRCT2、OpenTTD 等。

DOS 游戏可以用 DOSBox-X 或者 Boxer 模拟器运行，一些多年以前的主机端游戏的 ROMs 可以用 OpenEmu 模拟器运行。

5.7.2 Wine and Whisky

Whisky is a modern Wine wrapper for macOS built with SwiftUI

新建容器、选择容器配置（Windows 版本）之后就可以使用。可以通过 winetricks 命令安装一些基础应用程序、dlls、设置和字体（cjkfonts、corefonts）什么的。之后双击点击 exe 程序就已经可以运行，也可以点击右下角“运行…”来运行特定程序。

5.7.3 CrossOver

Run Microsoft Windows software on Mac and Linux | CodeWeavers

折腾完一通后的心情——算了还是玩 ns 吧！

• GDScript Tutorial：How to program in Godot - GDScript Tutorial - YouTube
• GDScript Tutorial with 中文字幕：Brackeys- How to program in Godobilibili
• Docs
  • 学习用 GDScript 编程 — Godot Engine (4.x) 简体中文文档
  • GDScript 参考 — Godot Engine (4.x) 简体中文文档
• Others:
  • Godot
  • Godot 4 Recipes

1 Syntax

1.0.1 Modifying nodes

$ is short for get_node()

@export var my_node: Sprite2D
@onready var weapon = $Player/Weapon

func _ready(): # called by engine
	$Label.text = "Hello, world!"

1.0.2 Input

输入示例 — Godot Engine (4.x) 简体中文文档

func _input()
	if event.is_action_pressed("my_action"):
		jump()

1.0.3 Variables

var health = 100 # dynamic typing
var health: int = 100 # static typing, this variable wiil always stay an integer
var health := 100 # inferred typing

@export var health := 100 # allow us to set it using the inspector

const GRAVITY = -9.81 # use CONSTANT_CASE

func _ready():
	heatlth += 10
	heatlth -= 10
	heatlth *= 10
	heatlth /= 10
	print("Health: "+ str(health))

注意 scope（作用域）

1.0.4 If statements

if x != y or y >= z:
	pass
elif y != z:
	pass
else:
	print("haha")

1.0.5 Data types

• bool
• int
• float
• string
• Vector2: stores two floats, x and y
• Vector3: stores three floats, x y z

var position = Vector3(1,2,3)
position.x += 2

1.0.6 Functions

func add(num1: int, num2: int) -> int:
	var result = num1 + num2
	return result

1.0.7 Random numbers

随机数生成

• randf() gives a random number between 0 and 1
• randf_range(from, to): gives a random floating-point number number between from and to
• rand_irange(int1, int2): gives a random integer number between int1 and int2

You can also set a fixed random seed instead using seed()

1.0.8 shuffle bag

我们希望随机挑选水果. 然而, 每次选择水果时依靠随机数生成会导致分布不那么 均匀 . 如果玩家足够幸运（或不幸）, 他们可能会连续三次或更多次得到相同的水果.

你可以使用 shuffle bag 模式来实现。它的工作原理是在选择数组后从数组中删除一个元素。多次选择之后，数组会被清空。当这种情况发生时，就将数组重新初始化为默认值。

var _fruits = ["apple", "orange", "pear", "banana"]

# A copy of the fruits array so we can restore the original value into `fruits`.

var _fruits_full = []


func _ready():
	randomize()
	_fruits_full = _fruits.duplicate() # deep copy
	_fruits.shuffle()

	for i in 100:
		print(get_fruit())


func get_fruit():
	if _fruits.is_empty():

		# Fill the fruits array again and shuffle it.

		_fruits = _fruits_full.duplicate()
		_fruits.shuffle()

	# Get a random fruit, since we shuffled the array,
	# and remove it from the `_fruits` array.

	var random_fruit = _fruits.pop_front()

	# Prints "apple", "orange", "pear", or "banana" every time the code runs.

	return random_fruit

1.0.9 Arrays

var array = []
var items: Array[String] = ["Knife", "Potion"]
items.append("Sword")
items[1] = "Damaged Knife"

1.0.10 Loops

# for loop

for item in items:
	print(item)

# while loop

while true: # DO NOT CREATE INFINIT LOOP!
	learn()

1.0.11 Dictionaries

key value pairs

var my_dict = {}
var employees = {
	"Jim": {"Salary":85, "Gender": "Male"},
	"Pam": {"Salary":80, "Gender": "Female"},,
}
players["Dwight"] = {"Salary":87, "Gender": "Male"}
print(employees["Jim"])

for employee in employees:
	print(employee + "'s salary:" + str(employees[employee]["Salary"] ))

1.0.12 Enums

枚举的成员是常量，所以大写

enum Suits { HEART,CLUB,DIAMOND,SPADE }
var card1 = Suit.CLUB
@export var card_suit: Suits

func _ready():
	if card1 == Suit.CLUB
		print("Club A")

最好将枚举的每个项写在单独的一行

enum Element {
	EARTH,
	WATER,
	AIR,
	FIRE,
}

1.0.13 Match statements

GDScript-match

func _ready():
	match Suits:
		Suits.HEART:
			print("Heart")
		Suits.CLUB:
			print("Club")
		_:
			print("Which suit is this card?")

1.0.14 Signals

最好用过去时态来命名信号。

func _on_button_pressed():
	pass

signal leveled_up(msg)

var xp := 0
for i in 8:
	xp += 5
	if xp >= 20:
		leveled_up.emit("DING!")

func _ready():
	leveled_up.connect(_on_leveled_up) # connect without inspector
	leveled_up.disconnect(_on_leveled_up)
	
func _on_leveled_up(msg):
	print(msg)

1.0.15 Setter and getter

GDScript-setter and getter set(value) 是变量的 setter 方法，用来控制变量被赋值时的行为。

var health := 100
	set(value):
		health = clamp(value, 0, 100)

其中 clamp(value, 0, 100) 将传入的 value 限制在 0 到 100 的范围内。

类似于 set 方法，get 方法用来控制变量在被读取时的行为，更常用于转换值：

var chance := 100
var chance_pct: int:
	get:
		return chance * 100
	set(value):
		chance = float(value)/100

1.0.16 Classes

https://www.bilibili.com/video/BV1mH4y1g7e5?t=3072.9 Godot 所有内置节点都是类

class_name Charactor

extends Node

1.0.17 Inner classes

var chest := Equipment.new()
var legs := Equipment.new()

func _ready():
	chest.armor = 20

# Inner class

class Equipment:
	var armor := 10
	var weight := 5

1.0.18 Composition

bitlytic How you can easily make your code simpler in Godot 4

1.1 Practices

1.1.1 Call down, signal up

Node communication 在层次结构中，节点可以调用位于其下方的节点上的函数，但反之则不然。

1.1.2 Memory management

GDScript-memory-management

1.1.3 Style

GDScript 编写风格指南

代码顺序：

01. @tool
02. class_name
03. extends
04. # docstring

05. signals
06. enums
07. constants
08. @export variables
09. public variables
10. private variables
11. @onready variables

12. optional built-in virtual _init method
13. optional built-in virtual _enter_tree() method
14. built-in virtual _ready method
15. remaining built-in virtual methods
16. public methods
17. private methods
18. subclasses

大学什么也不是，就是个毫无特征的中产阶级的培养学校，它最完美的体现就在校园外围近郊住宅区那一排排富庶的房子，客厅里摆着电视，每个人都在同一时间看同样的东西想同一件事，而同时这世上的贾菲们在旷野上潜行，听着那狂野的呼喊之声去寻找星空中的狂喜，寻找在这没有面孔、平淡无奇、饱食终日的文明起源处那些黑暗神异的秘辛。

时值初春。我坐在电脑前，感受昨天熬夜导致的心脏处产生的一种疲惫感与兴奋感，或者说是死亡感。在这种时刻我会幻想自己是敲击键盘的六七十年代落魄小说家，穷困潦倒地蜗居在堆满书的住处，困窘如《倒数时刻》中的乔纳森·拉森，以及其他任何自认为怀才不遇的倒霉天才或自大狂。带着这种过时的、孤僻的、带点美国梦式的幻想佯狂地胡想与乱写，我想到那个把纸粘在一起来不间断打字的凯鲁亚克。今天大约是他诞辰一百年左右。我没想到居然已经一百年过去了。

刚上高中的时候我读了那本白色封面的《在路上》，上海译文出版社 2014 年的版本。我是借了一位并不多么熟悉的朋友的书来读，读完时（在一个逃避性的晚自习，我记得我当时坐在二楼的窗边）封面已经有点弄脏了，我用纸巾沾上一点水把书擦干净后才敢还给她。我想，这样一本刺激性的、醉酒般的、纷繁疯狂的书，真不该用这种颜色。我是说，我以为整个纷繁疯狂的好戏即将开场。我经常以为整个纷繁疯狂的好戏即将开场，我甚至把这句话随机地写在明信片上给了一位大一新生，因为我真的坚信如此。

刺激我向前走的永远是随便哪条泥泞小路都蕴含的无限可能性，是莫名其妙包蕴一切神经质的怪诞宇宙观，只有百分之一可能性也可以用意念轰然打开的百万富豪集装箱。在这种随机想起杰克·凯鲁亚克的不该再次熬夜的夜晚，那种车轮永远不停歇着向前的所谓向远方发展的冲动仍然一刻不停地令人快乐，尽管谁都知道前路一无所有。哈克贝利·费恩如果继续沿河流一路波涛汹涌地前行，也将永无止境地进入没有尽头的大西洋。一直向前走，一直向前走，为了不用想过去而拼命向前看。我们变得更繁荣，我们变得更憔悴。

共同身处变革下潜藏的异化、不安与永远不满，我想这大概算中国和当时美国的一次交会。讽刺的是，在凯鲁亚克那本在中国未被奉为文青经典的《达摩流浪者》里，他正写了一群在东方哲学指导下寻求精神突围的人、一群旧日沙漠荒路上继续前行的“垮掉版”禅僧——“他们这样的家伙为穿起长袍成了一个真正的东方人而兴奋”，他写下“反正东西方总会交会。想想东方和西方最终交会了，那会给世界带来一场怎样的革命。那时候，我们这样的人能把事情做起来。想想全世界几百万人背着背包，踏步走在乡间的深处，搭顺风车旅行，把消息带给每一个人。”

我想，现在大概没怎么人会这么想了。我们这里听说是分成爱国党与恨国党两派。

但我该如何形容读到这个被称为垮掉派鼻祖的看似纯粹美式的公路旅行者梦呓般书写一本充满禅意的书以献给寒山，而产生的巨大共鸣？被我们一概视为迷信或中老年的禅学在流浪汉与攀登者那里死灰复燃。一座山犹如一位佛，大山全然不知地活着，而爬山只需随山起舞。佛法大意遇到惠特曼的诗歌与背包革命，消费社会的人们拒绝囚禁在工作、生产、消费之牢笼而成为背包漫游者，高喊，读诗，上路。“你难道没有意识到生活全部就是一场梦吗！”“万物皆空但都觉醒！”

一切都在土崩瓦解，而不管是六十年前还是现在这一切大概都被认为不合时宜、落后，是恣意妄为。谁都不把我们当一回事，我们应该有自知之明。但当一切美好的前景展现在你面前，各种未预见到的事件让你大为惊奇，使你由于能活着见到它们而感到庆幸时，何必去想那种扫兴的事情呢？

该怎么结尾？现在所有人都已经醒来，我已经没有资格做深夜幻想者。耳机里凯鲁亚克的声音盖不住吹风机的声音，穿衣服的声音，装饰物金属的声音，电动牙刷的声音。我记得凯鲁亚克所有结尾都是以另一种方式的结束来宣告终结，比如今夜金星一定低垂，黑夜黯淡所有河流山峰海岸，除了衰老以外谁都不知道谁的遭遇；比如在大山中呼唤寒山，在晨雾中呼唤寒山，而后转过身，往下踏上返回这个世界的山路。

一切重头再来一次，该怎么结尾，该怎么结尾，该怎么结尾？窗外由夜色成为寒冷的白色的春日，奇奇瓦里所有的沙粒都是空，人们有过各种各样的梦想，在可悲的血肉躯壳里活了许多辈子，而我坚信一场纷繁复杂的好戏即将开场。

本雅明认为，“即使在最完美的艺术复制品中也会缺少一种活的生命力：艺术品的即时即地性，即它在问世地点的独一无二性。”该理论被大范围应用于电影与文学理论批评。¹借此观点，我们或许可以在以《我的世界》为代表的“沙盒”“开放世界”类型电子游戏中得出新的发现。

一、游戏研究（极简要）回瞰

  “游戏”的概念在古典主义时期的哲学、心理学、教育学等领域中就已经出现，早期关于游戏的讨论大多从艺术哲学切入。时至今日，电子游戏的审美研究已由“电子游戏是否是艺术”的争论，进入到“电子游戏是什么类型的艺术”的探讨，其研究进路大致可被分为三个维度：在文学理论上，以戏剧理论、叙述学以及大文学理论视野对电子游戏进行审美探讨；通过与叙述学的论争，创立游戏学，把电子游戏当作一个独立的审美领域进行研究；从艺术哲学角度，以多种理论视域考察电子游戏的艺术性，并以电子游戏为中介思考传统哲学、美学在数字化时代所面临的挑战。²

  大体上讲，目前对于电子游戏的研究多是以其他学科的研究为基础，探究“电子游戏中的某某学”。例如从文学理论对电子游戏进行审美观照的角度，研究者将试图利用既成的文学术语与理论资源把电子游戏纳入现有的审美话语体系之中。在这种出发点下，游戏制作者往往被类比为“文学创作者”，并以这样的身份被进行“作者主体性”的探讨，而游戏“建模”“编程”过程作为关键的技术性环节却往往被忽视。这也意味着游戏此时仅仅作为“作品”或“产品”被阅读、探索、游玩和思考。游戏是如何被构建的，以及构建而成的游戏成品如何在玩家的游玩中有意无意显露自己“被构建”的身份、试图仿真中的种种不真实感和漏洞，这成为被遗漏的问题。

  《我的世界》（Minecraft，简称 MC）是一款游戏开发商 Mojang Studios 开发的沙盒游戏，以其开放性和创造性而闻名。它也是最经典的沙盒游戏与开放世界游戏之一，因“建筑”、“生存”的游戏标签、可以在游戏中进行的无数创造性实验、模组系统（Mod）乃至于游戏末尾的“终末之诗”受到关注。而该游戏对现实世界有限的模拟性、显而易见的漏洞往往被忽视，或被认为仅仅是技术性的缺憾而已。因此，本文将尝试借助对于《我的世界》游戏过程中的“漏洞”游戏体验的分析对其进行不同层面的探索。

二、《我的世界》的“机械创造”、漏洞与仿真性

  如前所述，《我的世界》是一款沙盒式建造游戏。玩家可以在游戏中的三维空间里创造和破坏林林总总的方块，甚至在多人服务器与单人世界中体验不同的游戏模式，打造精妙绝伦的建筑物，创造物和艺术品。在最经典的生存模式中，游戏着重于让玩家去探索、交互、并且改变一个由一立方米大小的方块动态生成的地图。

  对于许多玩家来说，《我的世界》值得反复游玩的魅力正在于这个像素方块世界地图的“无限可探索性”：在《我的世界》中创建新世界需要使用“种子”，而种子是用作世界生成算法起点的整数。首次进入世界时，玩家周围的区块会立即生成；随着玩家的移动，新的区块会根据需要逐渐生成。通过调节渲染距离，玩家可以决定载入内存的区块数量。不同于《荒野大镖客》、《侠盗猎车手》、《塞尔达传说》系列等规定了世界具体样貌的“开放世界”游戏，玩家在《我的世界》中可以探索一个随着其移动而在一定算法规则限制内逐渐生成的随机开放世界。在游戏中，即使是一块近在眼前的矿石，其背后矿石的数量多少也会随着玩家手中“镐”的“时运”附魔而改变。这种随机带来的丰富体验与独一无二的游玩特性是其他开放世界游戏难以提供的。

  在最初有关“游戏是艺术吗”的争论中，Roger Ebert 通过“电子游戏本质上需要玩家选择，这与严肃电影和文学的策略相反，后者需要作家控制” 的观点，试图通过否定作者性以证明游戏并非艺术。这种论调在后现代主义“作者已死”的文学批评中显然不攻自破，但“玩家——电子游戏——游戏制作者”之间的关系仍然引人深思。而在《我的世界》中，玩家所游玩的地图看似是一个完整的而稳定的世界，实际上只是创作者设定的贴图、代码、指令在“机器”的再加工下随机产物。玩家仍然可以从具体的生物、方块形态中窥见创作者的“意图”，但既然方块与生物的生成与分布是随机的，因此在一定程度上来说，他们并不在游戏制作人的控制之下。对于这种在指令运行下随机生成的世界，与其说“作者”是游戏制作人，不如说是游戏制作人与“机械创造”的共同产物，并且这种生产过程只在玩家在游戏世界中进行四处探索时出现。这也正暗合了本雅明有关游戏艺术问世地点的“即时即地”与“独一无二”的论断。

  正由于创造过程中的这种随机性，玩家在探索《我的世界》游戏时会遇到各种各样的“漏洞”，比如一个“雪屋”生成在了“村庄”的屋顶上，或者一个“林地府邸”半截埋在土里——机械创造只来自于指令的运行，因此忽视了玩家眼中“正常世界”的建构规律。有趣的是，游戏制作人还在《我的世界》中加入了一些彩蛋，比如将生物命名为“Grumm”时其会倒置等。《我的世界》不仅因其“漏洞”而暴露出了自己作为一个游戏“被构建”的身份，甚至似乎故意向玩家强调“我只是一个程序，而不是一个意图要尽可能仿真的世界”。因此玩家游玩的心态就由“我是在玩一个模拟类游戏，但是这个地方居然完全由方块构成，这些像素完全达不到仿真的效果以带来更好的沉浸感”转换为“我在体验这个创造者自己也未曾游览过的世界，并在生物与建筑等方块的生成中感受到创作者指令运行的存在”。实际上，在开启作弊模式后，玩家可以直接输入指令以批量修改世界，可以通过无限制的方块复制和放置来创造他们想要的虚拟环境，或者查看世界坐标并自由传送。这种技术复制的能力似乎使得游戏与现实之间的界限变得更模糊。因此对于本身也部分地成为游戏创作者的玩家来说，漏洞不仅在某种意义上是人工创造与机械创造的边界，也正像游戏与现实边界交织着的裂痕。

  有趣的是，玩家在这样一个故意暴露自身局限的游戏中仍然会体验到很强的沉浸感。这种沉浸感固然与《我的世界》主世界与真实世界很大程度上的相似性、游戏的第一人称视角等各类造成沉浸的机制有关，也可能与《我的世界》游戏在不知不觉中模糊了玩家与其操控的人物的边界有关。而这种边界的“模糊”，可能正来源于该游戏对自身“游戏性”与“程序性”的模糊。玩家在游玩中如果会混淆自己究竟是在玩游戏还是在“经历”一段指令，那么玩家自身到底是那个被操控的“Steve”（《我的世界》的原始人物名称）还是第四面墙以外的玩家本人就值得商榷。

  在这样的视角之下，《我的世界》中“玩家——电子游戏——游戏制作者”之间的关系与传统文学理论中“读者——作品——作家”之间的关系便更加显现出区别（此处未讨论《我的世界》作为模组游戏玩家同时还可能有 mod 制作者的身份，乃至于社交互动和合作者的身份，不过三者关系显然比当下揭示的部分远更复杂）。³

三、“机械创造”时代的电子游戏与作为艺术的电子游戏

  《机械复制时代的艺术作品》中的“机械复制”主要指的是摄影技术，因此本雅明论述的艺术作品主要是电影。其面对的是“机械复制时代”初期，人们对照相摄影乃至于电影是否是一门艺术作出的探讨，并极富先见地指出“电影的真正可能性，存在于它的这种独一无二的能力中，即用逼真的手段和无与伦比的直观性，去表现无比迷人的东西、使人惊讶的东西，即超越自然的东西” 。其中不论是“逼真的手段和无与伦比的直观性”的表现形式，还是“无比迷人的东西、使人惊讶的东西，即超越自然的东西”的表现内容，都是对电影艺术的描绘，同时也暗合了电子艺术的特征。

  从作为“机械复制时代的艺术作品”的电影到作为“机械创造时代的艺术作品”的电子游戏，两者面临的是相似的生产条件转型、世界格局酝酿变局时期的社会、极其广泛的大众的参与、媒介的转型，也具备比我们想象的要更多的相似性。这种相似即使是从本雅明文本的细枝末节也能够看出：“对电影来说，关键之处更在于演员是在机械面前所展示的自我表演，而不是在观众面前为人们的表演。” 这正与本文之前的论述暗合——对电子游戏来说，关键之处可能在于玩家在程序面前的自我探索，而不单纯是展现在屏幕上的被操控角色在被构建的固定世界中的探索。

  更进一步的，本雅明论述道：“当艺术创作的原真性标准失灵之时，艺术的整个社会功能也就得到了改变。它不再建立在礼仪的根基上，而是建立在另一种实践上，即建立在政治的根基上。” 电影在彼时作为一种先锋艺术丰富了我们观看世界的形态，作为眼前直接密集呈现的艺术品引发观众强烈的感受，还对传统的艺术观念乃至社会现有的秩序进行了革命性的批判。而电子游戏作为与电影相类似的机械复制品，其政治性也是常被主流游戏研究所忽视的，虽然这种性质其实已经在《请出示证件》（Papers，please）等反乌托邦游戏中初露端倪。

  此外，电子游戏作为先进与文学、电影的“机械创造”产品，其必然也有胜过电影先锋性的革命诉求（当下，电影已经慢慢和严肃文学一样离开大众走向殿堂）。“机械创造”或许会引起人们与对“人工智能主体性”相似的思考，或许令人想起其他。无论如何，那将是相当值得关注的话题。

四、结语

  对笔者来说，游戏内在程序与指令的存在感从未比游玩《我的世界》时“偶遇”了生成在村庄屋顶的雪屋时更加强烈，《我的世界》对“mod”的允许更加解构了其自身游戏的完整性，继续暴露了内在的程序，于是机缘巧合之下（神奇地从“随机生成区块”联想到了本雅明的“即时即地”）笔者写就此篇浅显幼稚的文章。由于学力尚浅，时间有限，本文大概有很多错漏与不足之处，也并未进行更深刻地挖掘，这是日后将要继续改进的。

《极乐迪斯科》就像是苏联寄出的最后一封信笺，通过科幻元素和游戏视角诉描绘了这样一幅画面——它告诉你说，放弃吧，屈服吧。我们没有丝毫不安与犹疑——《极乐迪斯科》就是一款生于磨难与失落的黑暗冒险。然而，细碎夹缝间偶有一丝光亮，残垣断壁处尚存几分友谊，唏嘘慨叹中不乏黑色幽默。
—— ZA/UM

醒来是在一片黑暗中，一种不存在的状态。

故弄玄虚的古老爬虫脑声音低沉：宁静的时间流逝、旧日之爱、肉球般臃肿不体面的思绪、无可挽回，遭受了彻底打击的你从宿醉、狂欢、派对、空酒瓶与其他任何形式的极度混乱中赤裸裸地醒来，梦里残存的温软全都变成寒意涌上心头。你脸上不可遏制地留着超级巨星一般的表情，你体格健壮，却因烂醉如泥和嗑 x 而脆弱得像初生的婴儿。你什么都不记得了：你不记得自己的姓名与身份，不记得自己爱过谁，不记得你所有的搭档和要做的事情，不记得失忆之前的所有狂欢和所有荒芜。

你只剩下勉勉强强拼凑成的自己：荒唐幻想世界中横跨黑白两道的迪斯科警察、木房子一般的世界中的火焰喷射器、游走于法律边缘的某类天王巨星、卡拉斯·马佐夫的追寻者、纪尧姆·列米利翁、某个自由主义者、龙舌兰日落和最后的康米主义者。

你和搭档要去探索一个吊死了人的案子，踉踉跄跄走遍整个小小的城镇，捡起每一分零钱和自己破碎的思绪，一遍遍询问自己的身份，面前展开一个宏大却荒芜的世界，以及案件之下每个人隐秘的私心、自己纷乱揪心的旧日情事、整个马丁内斯的落寞历史和芜杂的鸟鸣、铃兰与芦苇背后的秘密。

你一次又一次失败，在失败中你展现出很多小气、笨拙、懦弱、荒诞、不可理喻，这些或许是喝了酒嗑了 x 的人性之失败，也可能只是一直被掩藏的人性本色。你被人嘲笑，你向小孩打去却自己摔在地上，你一次又一次崩溃，渴望陷入虚无黑暗但温暖的怀抱。过去，你对它感到茫然，也感到惶恐。

你想成为什么就可以成为什么。你有机会选择去往康米主义（communism）、法西斯主义、道德主义还是极端自由主义。你可以继续醉酒嗑 x、可以泡女人、可以自毁、可以一心断案或者插手工会与大集团之间的利益之争、可以坐在椅子上静静思考虚无、可以漫长地和自己对话、可以听悲凉的鸟鸣。

你也可以去唱一首悲凉的歌，然后肆意舞蹈——直至达到某种神异的境界，你与瑞瓦肖的灵魂交谈，然后昏倒在地。不论如何，在这个虚无荒凉、注定失败的地方，你垂死挣扎，横冲直撞。

你所要探索的吊人案子也像是一个隐喻：你梦见被吊死的是自己，浮肿腐臭的尸体之上竟然是闪耀绚丽的迪斯科彩球的光斑。死去的是你的过去、现在与未来，也是极乐世界的过去、现在与未来——而极乐世界就是所有一切，灰域与洲，燃烧着狂怒着的真理，八千年的历史。

一直向前推理、奔走，直到最后：你终于破解了那个吊人的案子，城市的荣光和大革命的火焰归于一片废墟，所有理想主义都迎来命中注定的失败，世界无可挽回地归于虚无，你的爱情一步步失败，变成一个冰凉的吻。你通过南向高速公路，终将到达一切尚未发生的原点。声嘶力竭的坤诺。神话般的伊苏林迪竹节虫。在不知道什么时候到来的明天，太阳会再一次升起，爬虫脑和幻梦都消散，你会把竹节虫的故事讲给神秘动物学家。你会变老，在退休之后和金漫长地坐在秋千上看海，直到连金也厌烦了为止。

这个游戏构建了一个宏大奇幻的架空世界，又或者只不过是一个爱沙尼亚破败城市的复刻。它讲述了一个醉酒失忆警察的探案故事，也讲述了一段旧时代与新时代交替的悲凉史实。伟人雕像被推翻又重新树立，再被子弹刺穿，伤痕累累地俯视破败的城市。海浪拍打、吞噬醉酒的渔民。海鸥盘旋低回发出寂寂的哀鸣。教堂神像破碎：生后的世界——死亡，死后的世界——又是新生；青年们无力地狂吼着“hard core”，在教堂里肆意狂舞。没有语言，只是跳舞。

令人感动之处，大概其实是历史本身，以及对命中注定要坠毁的命运消极的或伟大的、永无止息的对抗。

搬运一段 steam 玩家 MEGALOASUKA 的游戏测评以作结：

MEGALOASUKA - 对于未来的文学界而言，Disco Elysium可能将跻身于二十一世纪第二个十年中最伟大的文学作品行列，与《看不见的城市》《我的名字是红》《哈扎尔辞典》和《万有引力之虹》等等一系列大师作品齐名。对于 CRPG 而言，Disco Elysium 的系统彻底地颠覆且革新了原有的 RPG 游戏机制，使用了经典的桌游机制，却通过扎实的写作功力，创造了多种“自洽式”的行为模式，将人类社会中的思潮与观点浓缩于文本之间，让这个世界成为了一个真正鲜活的有机体。对于我个人而言，这就是2019 年的 GOTY。

循循善诱 [ 容易：成功 ] - 事实上，如果你具有能够正常地进行文学批评的知识储备和阅读量，对于社科有基本的认知，且持左翼政治立场，甚至对先验主义和超自然主义感兴趣，喜欢阿尔普、米罗、艾伦斯待、达利、马格里特、夏卡尔等的绘画的话，Disco Elysium 会带给你更多其他游戏无法替代的价值。这部分价值对于确立你自己的价值观和哲学基本思辨有着决定性的意义。

标新立异 [ 极难：失败 ] - 还有齐泽克，你看看补 HP 用的药都是鼻通灵。

MEGALOASUKA - Disco Elysium 的生动描述，使得任何一个对文化敏感的，善于阅读的人都可以从中找出自己的韵味来。游戏本身并不吝啬于表达创作者本身的观点，但对于玩家而言，其操纵的角色就如同第一个支线的墙壁一样，杂乱却如同白纸一般，需要玩家自己动手涂满颜色，成为完整的人，直面玩家“自己”痛苦不堪又令人怀念的真实。

从容自若 [ 极难：成功 ] - ZA/UM 最令人敬佩的地方，在于其勇敢地表达出了自己共产主义（“康米主义”=Communism）的思想，在公开的、无耻的、直接的、露骨的资产阶级剥削和个人自由主义横行的当下，向主流文化挥动红色的大旗。并且他们夺取了高地，获得了尊敬，得到了胜利。ZA/UM 将“电子游戏”这一消费主义产物作为载体，擦亮了辩证唯物主义的武器。在今天，他们就是最勇敢的人。

同舟共济 [ 极难：成功 ] - 在中文版更新通告中，ZA/UM 更是直接表达了对于中国这一可能是最后传承了马克思主义火种的国家的期许和警告 -

“我们读着苏联时代的科幻作品长大，憧憬着未来的新生活，然后亲眼目睹了整个联邦分崩离析。”

“这个大都会经历了不同阶段的洗礼，从王室倒台，到革命失败。而现在，这里被所谓的国外自由市场联盟控制。民众在贫穷中艰难求生，在形态各异的政治观点碰撞中迷失自我。这里绝非乐土，但我们却再也熟悉不过。”

东欧人民在后苏联时代的迷茫和分崩离析，在 Disco Elysium 中深刻展现，一览无余。在这封“苏联寄出的最后一封信笺”里，中国人应当看出对未来反社会主义渗透的警告 - 事实上，这样的事情正在发生。- 这也正是 Disco Elysium 中文化的成功将会给我们带来巨大启示的原因。

MEGALOASUKA - GOTY 颁奖时，ZA/UM 说，“我们感谢所有伟大先哲带给我们的影响：伊利亚·列宾、弗拉基米尔·马科夫斯基、维克多·崔，以及马克思和恩格斯在政治理念上的启迪。” Disco Elysium 正是这样一个站在先哲的肩膀上的伟大作品，使得其必将被未来世界的历史所铭记。

将严肃内容与哲学思考娱乐化是消解反抗和自省的最好办法，在“极乐的迪斯科”时代之下，我们更应当感谢这个 ZA/UM 和轻语工作室带给我们的东西。它就是砸在游戏里大吵大闹的毛孩子身上的一记重拳——你有 54%的可能会自己摔倒，士气大减，但你仍要用 46%的概率挥出重拳。

平心定气 [ 挑战：成功 ] - 这很难做到，但是我们一定会做到。

But I got you, you got me. Got a chance, I believe.

Love will come and break the spell tonight.