“Go skydiving!” Hideaki Itsuno exclaims at his 2019 GDC talk detailing the combat design of Devil May Cry 5. Not as a silly joke to complement the important, technical parts of his talk. No, ‘Go skydiving’ is his premier piece of design advice to a room packed to the brim with aspiring game designers.

Itsuno wraps many exciting activities under the emblem of ‘skydiving’: travel, attending sports games and concerts, venturing into the unknown. The ultimate goal is to build a well of emotional experiences that can’t be replicated with verbal or written description. This well, although abstract and ethereal, becomes the game designers’ greatest asset for creating raw emotional experiences. I didn’t quite internalize it the first time I heard it. I was there to hear about the implementation details of a complex action game, after all. But in the years since, ‘go skydiving’ has become my guiding light through an age of artistic drought.

The room for a Devil May Cry 5 design talk was packed to the brim, of course, because developers across the globe are obsessed with Japanese games. Partially because of their historic dominance, but primarily because of how ‘cool’ they are. Video games in general, at least right now, aren’t ‘cool.’ More people play them but they don’t command the cultural attention as an artistic medium they once did. How am I defining ‘coolness?’ Beyond raw popularity or recognizability, ‘coolness’ represents cultural allure and taste-making value. A work of art is ‘cool’ when it’s treading new ground, attention-grabbing, and confident in its own direction regardless of external validation. To create ‘cool’ art requires a tasteful amount of experimentation and mainstream inaccessibility, two things that are gigantic no-no’s in the modern business world. High budgets and long development periods enforce sticking to tried-and-true trends instead of the raw artistic experimentation of gaming’s heyday, the golden era of the sixth console generation (1998–2009).

Japanese games from that era like Final Fantasy VII, Smash Bros Melee, Silent Hill, Resident Evil and Metal Gear Solid still command fierce fanbases who cannot help but be magnetized to their cross-generational appeal. Since then, we’ve been experiencing the entropy of video game coolness with the onslaught of remakes, remasters, and IP crossovers that reference that era without creating anything new to challenge or evolve it. Epic Games’ Fortnite recently added Raiden and Solid Snake from the Metal Gear franchise despite the last mainline entry, MGS:V, being a decade old.

Raiden Concept art by Yoji Shinkawa / in-game model in MGS2 (2001) / in-game model in Fortnite (2024)

It’s easy to see why they did this; Metal Gear characters and art-style command attention and coolness even amongst audiences who are completely unfamiliar with the franchise. Solid Snake is an easier sell than a character like Viktor Reznov from the objectively much more popular Call of Duty franchise because Call of Duty isn’t ‘cool’ in the way Metal Gear is. Nevertheless, we will eventually run out of ‘cool’ characters from the era in which they were allowed to be made, and the event horizon of our coolness heat death is rapidly approaching.

Japan’s ‘cool’ dominance

Every time a modern game of high artistic merit does release (and it’s usually from Japan), it has now re-upped itself as a permanent context that will be copied or compared against for the next decade. The current ‘cool kids on the block’ are undoubtedly FromSoftware of Elden Ring fame, and for how much I love them, it’s regrettable to see every modern action franchise develop in their Erdtree’s shadow. Take Game Science’s Black Myth Wukong, a game developed and advertised as a shining beacon of Chinese mythology. Wukong aims to depict the Journey to the West myth and Wuxia (武俠), a uniquely Chinese form of theatrical martial combat found in Chinese cinema, most famously Crouching Tiger Hidden Dragon (Ang Lee, 2000). I was excited to see them adapt the spatial combat style to video game form.

Sekiro: Shadows Die Twice (2019, FromSoftware)

Black Myth: Wukong (2024, Game Science)

Unfortunately, Wukong follows the FromSoftware mold to a tee, specifically their samurai action game Sekiro: Shadows Die Twice. Sekiro’s deflection-based gameplay evokes the defensive precision and discipline of a shinobi warrior, marking its gameplay as distinctly Japanese-themed. Tragically, Wukong’s minimal variations can’t avoid feeling like a Japanese samurai game with a superficially Chinese coat of paint.

Elegantly mixing verticality, wallrunning and melee combat, the Ninja Gaiden games are perfect Michelle Yeoh simulators.

Taking inspiration from spatially rich games like Ninja Gaiden II or Bayonetta would have better fit the Wuxia theme. Watching any gameplay from those two titles feels more in line with what you might see in a fight scene from Crouching Tiger than anything in Sekiro, and by extension, Wukong. The cruel irony here, though, is that both Ninja Gaiden and Bayonetta franchises are Japanese-produced. Even in my criticism of a Chinese studio to make their game more distinctly Chinese, I use Japanese products as reference points. Japan is John Coltrane on Giant Steps, switching through keys at breakneck speed, and the rest of us, from Shanghai to San Francisco, are Tommy Flanagan trying desperately to catch up.

Despite literally taking place in Japan, Assassin’s Creed: Shadows repeats the stagnant open world formula with zero learnings from Japan’s innovations in the genre.

Don’t feel too bad for China, because Japan is even beating us at our own game too (and I’m not talking about Shohei). The Open World genre, starting with Rockstar’s Grand Theft Auto III and popularized most famously by Bethesda’s Elder Scrolls V: Skyrim, quintessentially represents the American spirit. It’s a game genre about exploring a new world and conquering it, piece by piece; what could be more ‘American Cowboy’ than that? Despite this, the genre-defining open world games as of now are all Japanese. Nintendo’s Breath of the Wild and FromSoft’s Elden Ring are credited for revitalizing the genre with bold direction and experimental design that recontextualizes how exploration can be encouraged. Just this year, Nintendo’s open world Xenoblade Chronicles X edges out Ubisoft’s open world Assassin’s Creed: Shadows with the former scoring an 88 on MetaCritic and the latter scoring an 81. Even in the game genre that is most American by principle, it is ironically Japan treading new ground as to what is possible with the medium of video games.

“[Kena: Bridge of Spirits] uses Japanese iconography… presumably [only] because it looks cool, because due to missing worldbuilding, none of it is referenced anywhere.” (Malindy Hetfeld, Eurogamer)

The solution is decidedly not to make our games more ‘Japanese’ in an aesthetic or superficial sense. While the world has many lessons to internalize from Japanese design, I feel we are too comfortable in aping their aesthetics without ample narrative justification. Yes, yes — I grew up with Naruto and Ghibli films too — and Japan themselves have spent billions of dollars to hold their throne as the premier cultural exporter of the world (‘Cool Japan’ Project). However, when projects from outside Japan release with all their aesthetic trappings — Shinto imagery and anime-inspired character designs — but none of their core principles or explicit call-outs to Japanese culture, it can’t help but feel a bit embarrassing. If nothing else, it’s certainly uncool; clawing desperately for the exotic appeal of its inspirations without the confidence and focused vision to back it up.

What makes Japan so cool, anyway?

Does Japan have a secret sauce? Some umami ‘coolness’ that we can’t access without starting a new studio in Tokyo ourselves? Well, no, I don’t think so. To be fully honest, even Japan isn’t as cool as Japan anymore. Hayao Miyazaki of Studio Ghibli famously lamented on the state of the Japanese animation industry. His “anime was a mistake” quote, although arguably mistranslated and bereft of context, still resurfaces to poke fun at less-than-impressive seasonal shows.

The full quote points to an educated frustration with the state of his industry: “You see, whether you can draw like this or not,” Miyazaki explains as he sketches a character, “depends on if you can say to yourself, ‘Oh, yeah, girls like this exist in real life.’ If you don’t spend time watching real people, you can’t do this, because you’ve never seen it… Almost all [Japanese] animation is produced with hardly any basis taken from observing real people, you know. It’s produced by humans who can’t stand looking at other humans. And that’s why the industry is full of otaku!”

Otaku (Japanese term):

A young person who is obsessed with computers or particular aspects of popular culture to the detriment of their social skills. (Oxford Dictionary)

A similarly unfortunate fate has befallen the games industry, both in terms of consumer-base and production. The population of people making and playing games are overrun with a disinterest in life and culture outside of digital worlds. I can imagine a statement similar to Hayao Miyazaki’s coming from the lips of Hidetaka Miyazaki, director at FromSoftware, who credits much of his inspirations to novels, manga, and architecture studies outside of just video games. Miyazaki was famously inspired by getting his car stuck during a particularly gnarly snowstorm for the unique co-op features of the Souls franchise. Meanwhile, every new ‘Soulslike’ game made in Elden Ring’s image feels starved of any other cultural nutrition than the video games themselves. Video games aren’t cool, they haven’t been cool in a long time, and it feels like we all wordlessly expect that by following in Japan’s footsteps they’ll become cool again. I’m here to tell you that no, that won’t happen. Not without understanding that life experience and a wide cultural diet is what’s necessary for creating good, cool art.

Indie as a response

A common rebuttal is to associate the entirety of our cultural drought with the much maligned ‘AAA’, or popular high-budget video games produced at multi-billion dollar companies like Activision-Blizzard, Rockstar, or Ubisoft. For true, real artisanal experiences, one must seek out indie games! There are many strong contenders for ‘good video games’ in the indie space; games that tell interesting stories, dazzle with vibrant visuals and keep players coming back for refined, polished gameplay. Despite this, the indie space is stuck in a rut of constantly reinterpreting nostalgia without any reinvention to push it forward. We are currently in a 90’s nostalgia phase, which means roguelikes, platformers, and survival horror games are all in vogue. A Y2K nostalgia phase peeks around the corner with several indie action and adventure games currently in development. These projects revere their inspirations but fail to justify themselves evolutionarily. If you really love Zelda enough to make a whole new Zelda game of your own, matching everything up to but just short of IP infringement, why would I play yours instead of just playing Zelda?

‘Central character overlooks grassy green expanse…’ describes nearly half of new adventure game announcement trailers in the years since Zelda: Breath of the Wild.

Indie falls into the same trap as AAA, stuck looking backward and lacking inspiration beyond the video games that spawned it. Between Steam’s 2-hour rule and the market of public opinion on Twitter, the indie game market highly optimizes for easily digestible mechanical or narrative gimmicks. This context for development and marketing does not foster the experimentation or artistic excellence found in the Y2K Japanese golden age, and I can’t say I’m looking forward to the troves of games made by other people who really really love that era but have nothing else to say about it. Even if indie games are good, even if they are great, I don’t believe they will stand the test of time in the same way that golden age games do. My 15-year old cousin just told me she’s getting a PS2 second-hand for Silent Hill 2. She was born almost a decade after that thing came out! Do we truly believe that anything released as of late has that same cultural pull?

Randomly remembering that:

Classmates at my prestigious game art university said Silent Hill 2 looked ‘old’ and ‘ugly’ and the ‘dialogue is trash,’ which makes me chuckle when thinking of my little cousin’s opposingly strong curiosity. No shade, we were 20 years old, all love <3

On the topic of Silent Hill, just take a look at their development team. Team Silent exudes the confidence and aura of a historied group of artistic collaborators. From the development documentaries, it’s easy to observe that their office is filled with books on art, history, classic literature, architecture, and philosophy. You can imagine they’d take smoke breaks to discuss topics that have nothing to do with video games at all, yet effortlessly and unambiguously filter into the trilogy of masterpieces they were about to create. Not to mention they dress well too! This is the atmosphere in a studio required to create a timeless work of art, beyond any technical expertise at programming or design or whatever else.

“That’s just how they do it,” or Japanese mysticism

Designer at Capcom working on Marvel vs. Capcom: Infinite

I’m sure you may have come to the following conclusion: “this writer is tragically butthurt that he wasn’t born in 1980s Tokyo so he could have burgeoned into the Japanese golden age during his 20s.” I’m sure I gave off that impression, but to be honest, no. As much as I cherish and respect the golden age and the numerous classics that era of Japan has given us, my dream is for the rest of the world to catch up. I’m tired of Japan being the only voice of reason in the medium I love so dearly. Much of the conversation around Japan seems to align their stellar products with an unreplicable Japanese-ness, and I could not disagree more. It’s a niche fact that acclaimed Japanese film director Akira Kurosawa named Bengali-Indian director Satyajit Ray, notably his film Pather Panchali, as one of his premier inspirations:

“The quiet but deep observation, understanding and love of the human race, which are characteristic of all his films, have impressed me greatly. I feel that he is a ‘giant’ of the movie industry. Not to have seen the cinema of Ray means existing in the world without seeing the sun or the moon. I can never forget the excitement in my mind after seeing [Pather Panchali]. It is the kind of cinema that flows with the serenity and nobility of a big river. People are born, live out their lives, and then accept their deaths. Without the least effort and without any sudden jerks, Ray paints his picture, but its effect on the audience is to stir up deep passions. How does he achieve this?” —Akira Kurosawa

Pather Panchali (1955, Satyajit Ray)

Yojimbo (1961, Akira Kurosawa)

Just reading that passage alone may enlighten you as to the magic of Kurosawa’s own work: Japanese cinema classics like Rashomon, Seven Samurai, and Yojimbo. These works are talked about as if they spawned from nothing else but uniquely Japanese sensibilities for serenity, gracefulness, and technical craftsmanship, when in reality even legends crafted with a nod toward their own (in this case Bengali) heroes. Kurosawa’s work was lightning-fierce, and we still feel his influence into a medium he was never alive to observe. Sucker Punch Studios’ Ghost of Tsushima shipped with a ‘Kurosawa Mode’ for their samurai game to pay homage to the legendary director, and Japanese titles like Sekiro, Rise of Ronin, and Onimusha are undoubtedly developed with his films pinned tightly to the wall.

I would describe my own Japanese heroes, ranging from Shinji Mikami to Fumito Ueda to many more, with the same reverence that Kurosawa paid to Ray. Never having played Dark Souls or Resident Evil 4, games I hold dearly to my heart, may be as debilitating to me personally as never having seen the sun, moon, or a beautiful eclipse. Now, as a person of Bengali heritage, I feel some responsibility to put my culture back on the map and close the loop that was started nearly a century ago. I’m excited to produce works that are inspired by the Japanese masters but indelibly marked by my own cultural upbringing. Let’s not kid ourselves into believing that artistic inspiration and technical craftsmanship are ‘just how the Japanese do it’ as an excuse for our own shortcomings. Many of the legendary creators of that era — Kamiya, Mikami, Ueda, Kojima, Itsuno, Inaba — are now heading new studios working on completely new IP’s or revitalizing classic ones. As an avid fan, I’m more than excited for their work, but eager to see the rest of the world rise to the competitive challenge.

How to be Cool 101

Well, how can we achieve that? Like any other early-in-career, I work a technical industry job, absorbing as much knowledge and experience as possible. I dream of starting a studio one day, aware of how many others have the same dream and how hard I’ll have to work to truly achieve it. Even beyond my own ambitions, however, I dream of a world where all together we aspire to create artisanal experiences that reach beyond games as meaningless toys for wasting time. I dream of another golden age, but this time at a global scale instead of centralized to three companies in Tokyo. I dream of video games respected as artworks on the level of film, literature, and music, and the creators of those video games revered as the great artists of our generation. I dream of making a video game that, a decade after its release, a culturally curious young girl like my little cousin will fight tooth-and-nail over Ebay bids and retro stores in order to get her hands on. Is there any better feeling than sinking your teeth into a video game like that?

This dream, however, requires more than just video games. In fact, it requires the exact opposite. It requires creators who are cultured, historied, filled to the brim with ravenous hunger for life and death and everything in between. It requires creators who are sharply dressed and have a crazy look in their eyes. It requires creators who speak several languages and have seen many corners of the world. It requires creators who watch the sun and moon, sitting patiently for beautiful sunsets and mesmerizing eclipses. It requires creators who have read the classics, and the contemporaries, and some shitty reality television too. It requires creators who have gone skydiving, felt the wind cut and stab at their cheeks and smiled ear-to-ear the entire fall.

If you work in the games industry, or aspire to, or love video games and art in general in any capacity at all. Please, please, please. I beg you. Go skydiving. More than ever, art needs to be interacted with by people who have gone skydiving. In front of the screen, yes, and behind it too.

For Legal Reasons:

‘Go skydiving’ is defined as an allegory for reading, studying, travelling, meeting new and different kinds of people, interacting with foreign cultures, learning a new language, trying new hobbies, exercise/working out, becoming a sports fan, switching up your fashion, and/or going to music shows. I am not responsible for skydiving (or otherwise) related injuries.

P.S: On AI Art (not sure about keeping this part)

Maybe you’ve gotten to the end of this blog and are still wondering what the big deal is about ‘coolness.’ So what if art nowadays is less ‘cool’? Does it need to be ‘cool’? Isn’t ‘coolness’ arbitrarily exclusive and immature? I’d like to point you to last week’s Ghibli AI Art fiasco.

Popular meme images converted to Ghibli-style with ChatGPT.

With ChatGPT’s image generation feature, troves and troves of users converted every kind of image to AI-generated artworks in Ghibli’s famous house style. Hayao Miyazaki has been outspoken about his distaste for AI-generated artwork, and it’s clear to see why. A studio that has dedicated its entire artistic portfolio to capturing an impressionistic portrait of life has been sullied against their will for corporate, anti-artistic greed.

There’s a lot of talk on the pro-AI side of ‘democratizing art,’ and making art accessible for everyone. So let me clearly state, in no uncertain terms: art shouldn’t be democratized like this. You shouldn’t get to make art that looks like the art cool, interesting, skilled people make if you yourself aren’t cool, interesting or skilled. Art has already been democratized in the sense that making great art is accessible to everyone of all races, creeds, and economic statuses. There has been widely celebrated art created by the homeless, the disabled, and the most ostracized minority members of society. The only limiting reagent is whether you have something valuable to say; a limiting reagent that has proved debilitating for a certain crowd. I live in San Francisco, and it’s clear to see that the Bay is filled with individuals of privileged socio-economic backgrounds who can buy any experience money can buy and yet are permanently stuck reaching toward the uniqueness or individual confidence that others easily exude. These are the people prompting and peddling AI art; unromantic, culturally unrefined ignoramuses who wouldn’t know ‘cool’ if David Lynch came down from the smoke room in Heaven and handed it to them on a silver platter.

AI Art is only going to get better at doing what we were kind of already doing before it hit the market; copying, and copying, and copying. What were funny pitfalls months ago — fingers, text, continuity — have been overcome swiftly by hardworking, highly paid and hopelessly uncool AI engineers. The only thing AI Art can’t ever be is ‘cool.’ As a machine, it can only move all of its creation towards a middling median, appealing to all but loved by none. So you, the human artist reading this. You need to be cooler than the techbro down the street. Don’t worry, you have quite the head start. And, after that — you need to make cool art. Art that is somewhat inaccessible, foreign, or hard to grasp. Art that is magnetic and interesting without needing to bend over backwards for broad appeal. You need to make the art that cool people will gate-keep away from the lames who use AI art for no other reason than “they just wouldn’t get it.”

And you, non-artists who have gotten this far. Poptimisim is over, okay? Start making fun of your friends who only watch mainstream things again. Yes, you are a better, cooler human being because your Spotify end-of-year has more than just artists with 10M+ monthlies. Our society depends on a healthy amount of gatekeeping and snobbiness, and the pendulum has swung too far the other way. This healthy pretentiousness is the coal that fuels our society to both make and appreciate the kinds of art that AI could never make.

Godspeed! Go live life and make masterpieces that only seasoned, interesting, cool people can craft!

Follow me @wheatpenguin on Twitter.

Tabis — Japanese design of shoe with a toe separator

Later, we celebrated our respective new careers that happened to land in our interests (I had started working at Niantic on Pokemon Go around the same time he got his job). What was intriguing was that neither of us could pinpoint what put us a cut above the applicant pool. The interviews went smoothly in a sterile way; no ‘knock their socks off’ moments for either of us. I proposed that maybe our interviewers saw something in us, a potential or promise that was invisible to our eyes. Like a pair of too-big tabis. The theory was vague and inconclusive, but it sounded satisfying enough.

Another of my college friends grew up in Beijing. We speak in English, but anytime she’d run into a word or concept she couldn’t find a satisfying stand-in for, she’d teach me a Chinese word and do her best to convey its meaning. One of these phrases was 审美 — shen mei. It refers to a discerning taste, a vision of quality or beauty that remains invisible to anyone without. It’s like a sixth sense built through hours of study, practice, and instinct.

Shen (审) means ‘examine’ and Mei (美) means ‘beautiful.’ I interpret their combination here as a form of divinely inspired beauty held entirely in the eye of the beholder or similarly discerning observers. A mysterious, alchemical sophistication present in wine tasters or vocal judges. My friend introduced this word to describe an artist classmate’s impeccable understanding of color theory. Many of our classmates at USC crafted visually impressive pieces, filled with detail and vibrancy — but her work could make a simple sketch look beautiful with choice colors that perfectly complemented each other. Good sense? Taste? No… a mere English word wouldn’t cut it here. I can’t help but think about shen mei often, and it’s become one of my favorite borrowed words. Do I have shen mei? If I do… then in what, exactly? It’s hard to tell what’s visible to me but invisible to others. I’d like to think I have a certain instinct with game feel: the tactile nature of real-time games. The way the animation, sound, and movement all come together to give a game a special immersion that melts the fourth wall and spirits you away. Think of drifting in MarioKart and how your physical body leans with the motion, as if that might help you make the turn.

Thanks to my jack-of-all-trades-master-of-none skill set in game development (and a little bit of instinctual shen mei), I have a knack for producing highly game-feeley projects. Among classmates and colleagues, I’ve become known for this. Whether it’s a jump attack or a special effect, people who playtest my games say “It has the Sheehan bounce to it!” This has given me a strong sense of artistic identity, one closely knit to video games. I have met much better artists, much better programmers, much better everything really… but few of them could deliver that game feel quite like I could.

I love movies, music, writing — and I hope to acquire a workmanlike expertise in each field — but my strongest shen mei will always be in the immersive feel of video games. I can press a button in a new release and tell you that the response needs to be fifteen frames shorter, the way a cook could tell a dish needs an extra pinch of salt. It’s exciting to cross paths with friends whose shen mei are in completely different fields, whether that be fashion, architectural design, or photography. Observing their ability to see things that I can’t is inspiring in a way I can’t quite explain.

There’s a new piece of Gen-Z slang I like: “for the love of the game.” It’s usually used to humorously poke fun at individuals who perform a certain activity purely for its own sake without any ulterior motive. For example, most people dress nicely to appear clean and attractive or portray elements of their personality and interests. I can attest that’s about as far as it goes for me. However, for my fashion assistant friend, it’s deeper than that. You can tell that he truly loves fashion for the love of the game. In much the way that Gen-Z usually does, slang tends to touch upon ancient philosophical truths with the casual goofiness of a grade-school sleepover.

Many of my orbital interests serve an underlying interest in games. I’d like to learn photography to frame better shots while programming the cameras in my games. I’d like to learn music and sound design to better score the important moments in my games. It’s only games themselves that, no pun intended, I love for the love of the game. With that perspective, it becomes clear to me why I hear perfectly clear sounding music when my sound designer friend raises his eyebrow and observes, “The mix isn’t great on this.” I can ask him what he means, and I learn. Maybe in the future, I’d be able to make the same observation. But he can hunt these nuggets of discernment down in the way a bloodhound can track prey for miles. It’s a means to an end for me; it’s the love of the game for him. The shen mei must come naturally after that.

Inscryption: a 2021 indie game that went viral for pairing card roguelike with experimental metafiction.

You’d think I might say that shen mei only comes from loving a craft so deeply, and yet I’m not so sure. I think that’s the most common path to achieving shen mei, and most of the people I know who have it are deeply embedded into their craft, but it isn’t a hard rule. The next day, I was in Chicago visiting another friend, a barista who also runs an online sticker business on the side. She’s highly economical with her hobbies — music, games, art, fashion — and I can’t help but admire (and envy) her high degree of shen mei with everything she takes a passing interest in. I watched her play an hour of Inscryption and her keen eye picked up on so many details I had assumed only someone in the business of game development would notice. “You can tell this game is well-made,” she mentioned. I can, I thought. I’m impressed and overjoyed you can, too. My habit would be to intellectualize this somehow — find a working theory that transposes the intricacies of coffee-making to game design — but nothing ever is so simply capturable. Many avenues can exist to reach shen mei, even if loving the game is my personal favorite.

It’s poetic that I was introduced to the concept of shen mei by a friend who couldn’t find an English word to describe what she meant in our conversation. As English becomes the globally default language, there’s a certain amount of shen mei in discovering the cracks where its linguistic possibilities fall short.

I try to end my blogs with some kind of takeaway, but I find myself unable to. Whoever you are, reading this — there is beauty in your world that I can’t describe because I can’t see them the same way you do. There are takeaways out there that can’t be written down, in English or any other language. Ghosts of our ideological and artistic pasts, yearning for an observer to understand them. I hope you can see them and cherish your own shen mei, whatever it is that calls to you. Whatever it is that you love purely for the love of the game.

Follow me @wheatpenguin on Twitter.

Notice that when the player selects a unit to move them, it displays a grid. This grid depicts grid cells the player can move to in blue, and grid cells they can attack in red. This display is integral to the strategy of Fire Emblem, as it gives the player a clear yet informative summary of their tactical options.

I wanted to recreate the effect myself, with an added optimization challenge; have the whole algorithm run on the GPU with a pixel shader.

Why the GPU?

Speed is a concern, since moving units is a common command. The game freezing up every time you click on a unit to move is unacceptable. This also can’t be solved with multithreading instead, because the game needs to show where a unit can travel immediately upon clicking on it. In conclusion, our solution must run fast on the main thread using a pixel shader.

Expected Behavior

Firstly, let’s review the needs and expected behavior of the system:

• The world is organized into grid cells. Each grid cell has an integer Movement Cost (1, 2, 4, or 8), or is a wall that cannot be moved upon or through.
• There are Units that live in individual grid cells, and can move to other grid cells. Units can only move up, down, left or right. “Diagonal” movements are counted as moving two grid cells.
• Each Unit has an integer Movement Range. This means that they may travel as far as the sum of the travelled grid cells’ Movement Costs is less than or equal to their Movement Range.
• A Unit will be able to move at least one grid cell away from their starting one, even if their Movement Range is less than the cost of that cell’s Movement Cost.
• Units additionally may Attack up to an integer Attack Range grid cells away from their ending position. Attack Range ignores Movement Cost and walls.

Dijkstra’s Algorithm

The needs and expected behavior denote two specific problems:

• How can we find every accessible point given a starting cell and movement range?
• How can we trace this point back to the starting point?

This is best done with Dijkstra’s Algorithm because it’s essentially built to solve this problem.

Here is a brief paraphrased refresher on Dijkstra’s as it applies to our problem. This is for newcomers… or if your memory of sophomore-year algorithms class is getting hazy.

1. Start with every cell marked open, other than a start point cell, which is closed. We will “close” nodes as we visit them to keep track of where we’ve been.
2. Assign to every cell a Travel Cost value. This defaults to infinity for every cell other than the starting cell, which is zero. This value represents the shortest possible path to reach this cell from the starting cell.
3. For a current node, consider all open neighbors. If an open neighbor could be given a Travel Cost less than the one it currently has by virtue of travelling there from the current node, assign it the newer Travel Cost. Close the current node.
4. Repeat step 4 for every open neighbor of the current cell in a breadth-first search. Stop when cells whose Travel Cost exceeds the Movement Range are reached.
5. After this process, every “closed” cell can be travelled to, and each contains a Travel Cost defining how much of the Movement Range is expended to reach it. (This is loosely paraphrased from the Wikipedia article on Dijkstra’s algorithm)

Running an algorithm on a Pixel Shader

Dijkstra’s algorithm is cool and all but… how do we run that on a pixel shader? The algorithm asks for maintaining a set of closed cells, and shaders can’t really keep consistent state like that. It also involves a Breadth-first search, which would be best done in a loop. As it’s currently defined, a pixel shader is incapable of adapting Dijkstra’s algorithm.

So, we’ll have to think outside the box… and flip the script.

if(current is Wall or current is Closed or all neighbors are Open)
	return

if(up_neighbor is closed && up_neighbor.travelCost is least)
	current.nearestNeighbor = up
	current.travelScore = up_neighbor.travelScore + up_neighbor.cost

/* repeat the above if statement for down, left, right */

if(current.travelScore <= movementRange)
	close(current)

Holding Dijkstra State in an 8-bit RGBA Texture

We can’t rely on holding state externally to the texture. Instead, we will find clever ways to use all 4 channels in the 8-bit texture in order to store state.

The only offline information we need for a Map is the Movement Cost of each cell and whether or not it’s a wall. This will be stored in the Red channel, as follows:

Which can be simplified to:

In a real game, this Red Channel will be populated by sampling the tile map of the game world. For the purposes of this demo, I’ll draw up a sample map in Photoshop instead.

Here is the test map I drew, stored in the Red channel but displayed in greyscale for clarity. It’ll work well for testing purposes, although I can’t say Shouzou Kaga would be proud of the design. As you can see, the absolute black and shades of grey define grid cells that may be travelled to and their Movement Cost, whereas the absolute white defines impassable walls.

With the Movement Cost stored in the Red Channel, that leaves the other three channels (GBA) to hold state.

G: During algorithm, will be used to mark open/closed cells. After algorithm completion, acts as a mask for entire travelable area.

B: Travel Cost.

A: Points to nearest neighbor (lowest travel cost). When the player picks a point, this will be traced to move the Unit to that location.

Now that we know how to use the texture, we can define our pixel shader’s behavior. Instead of travelling top-down from the starting cell, the pixel shader will apply an iterative process to the entire image. This single iteration will use a plus-shaped kernel to convolve the image.

What is a kernel?

A kernel describes a certain shape for sampling around the current pixel when running a pixel shader. Usually, this is a square with specified dimensions. For example, a simple box blur uses a 3x3 kernel to sample the 9 pixels surrounding a pixel and average them to achieve a blurring effect. In our case, we use a 3x3 plus-shaped kernel because Units can only move up, down, left and right, not diagonally.

Now that we know our kernel, lets write the pass.

float pack255(float val) { return val / 255.0; }
float unpack255(float val) { return val * 255.0; }
float getMoveCost(fixed4 col) { return max(1.0, pow(2,ceil(col.r * 4.99)-1)); }
bool isWall(fixed4 col) { return unpack255(col.r) >= 200; }
bool isOpen(fixed4 col) { return col.g <= 0.01; }
void close(inout fixed4 col) { col.g = 1.0; }

const float2 cell_size = _MainTex_TexelSize.xy;  
fixed4 col = tex2D(_MainTex, i.uv);  
const fixed4 col_u = tex2D(_MainTex, i.uv + cell_size * float2(0.0, 1.0));  
const fixed4 col_d = tex2D(_MainTex, i.uv + cell_size * float2(0.0, -1.0));  
const fixed4 col_l = tex2D(_MainTex, i.uv + cell_size * float2(-1.0, 0.0));  
const fixed4 col_r = tex2D(_MainTex, i.uv + cell_size * float2(1.0, 0.0)); 

if(!isOpen(col) || isWall(col) || max(max(col_u.g, col_d.g), max(col_l.g, col_r.g)) <= 0.01)  
return col;

const float tc_u = unpack255(col_u.b);  
const float tc_d = unpack255(col_d.b);  
const float tc_l = unpack255(col_l.b);  
const float tc_r = unpack255(col_r.b);  

float min_tc = 9999; // minimum travel cost  
float mc = 0.0; // movement cost

// If closed and travel value < minValue  
if(!isOpen(col_u) && tc_u < min_tc)  
{  
	min_tc = tc_u;  
	mc = getMoveCost(col_u);  
	col.a = 0.1;  
}  
if(!isOpen(col_d) && tc_d < min_tc)  
{  
	min_tc = tc_d;  
	mc = getMoveCost(col_d);  
	col.a = 0.3;  
}  
if(!isOpen(col_l) && tc_l < min_tc)  
{  
	min_tc = tc_l;  
	mc = getMoveCost(col_l);  
	col.a = 0.5;  
}  
if(!isOpen(col_r) && tc_r < min_tc)  
{  
	min_tc = tc_r;  
	mc = getMoveCost(col_r);  
	col.a = 0.7;  
}

const float tc = min_tc + mc;  
col.b = pack255(tc);  
if(tc <= _MoveRange)  
	close(col);  
return col;

for(int i = 0; i < movementRange; i++)  
{  
	Graphics.Blit(mRenderTexture, tempRT, mAlgorithmMaterial);  
	Graphics.Blit(tempRT, mRenderTexture);  
}

And… the result:

Although the above gif is slowed down for clarity, the actual algorithm runs lightning fast. For expected use-cases of Movement Ranges under 32, I consistently get <0.2ms of total runtime.

Attack Ranges

We’re over the hard part, but still need the attack ranges. These are the little red squares that show how far a Unit can attack if they move to the very edge of their Movement Range.

Luckily, this is quite simple. Since the Attack Range ignores Movement Cost and walls, we don’t need to do any pathfinding of any sort. Instead, we will convolve the G channel of the Reverse Dijkstra result with an expansion formula, using the same plus-shaped kernel.

fixed4 col = tex2D(_MainTex, i.uv);  
const float2 cell_size = _MainTex_TexelSize.xy;  
const float down = tex2D(_MainTex, i.uv + cell_size * float2(0.0, -1.0)).g;  
const float left = tex2D(_MainTex, i.uv + cell_size * float2(-1.0, 0.0)).g;  
const float right = tex2D(_MainTex, i.uv + cell_size * float2(1.0, 0.0)).g;  
const float up = tex2D(_MainTex, i.uv + cell_size * float2(0.0, 1.0)).g;  
const float maximum = max(max(down, left), max(up, right));  
col.g = max(col.g, min(0.5, maximum));  
return col;

Perfect! Now the effect is complete.

Conclusion

Here is the demonstration of the final effect.

In the future for my tactics side-project, I’ll add:

• Red Channel auto-generation from world map contents
• Pretty in-game shader to display this grid to the player
• Arrow tracing player start to destination

Thank you for reading my blog. If you were impressed and are an employer, consider hiring me as a Graphics Programmer (My LinkedIn).

Otherwise, follow me @wheatpenguin on Twitter.

If you know, you know…

Among the sea of endless debate about whether or not the franchise should have easy modes, ‘Dark Souls being a cozy game’ is a fresh take – most likely because of how absurd it sounds. To be clear, I’m not “Die Hard is a Christmas movie”-ing this. This isn’t a categorization purely for categorization’s sake, and there’s valuable takeaways for game developers about the nature of ‘cozy gaming’ that I can only reach after you’re with me on the “Dark Souls is one” thing.

The first trapping to let go of is the idea that a game’s visuals, aesthetics, or mechanics directly influence the categorization, because they don’t. It sounds ridiculous when laid out like this — how can the individual components of an artwork have no bearing on the genre? Well, we don’t treat genres of any other mediums like this. Movies aren’t categorized into genres by the content of their individual scenes. Mad Max and The Batman both have car chase scenes, but one is a dystopian action film while the other is a crime drama. These individual scenes can contribute to the genre, but only when considered in the context of the overall work.

So… what do we categorize by? Consider how people refer to genres: “I’m feeling sci-fi today.” People gravitate to certain genres by virtue of a shared set of emotions. Adventure films may look completely different from one another, but they all give you the feeling of a swashbuckling journey through uncharted territories. If emotions are colors, you can think of genres as paintings that share a palette, even if they depict wholly different subjects.

Regardless of other mediums, many would be skeptical that such a reading fits games, which are often defined entirely by their core mechanic. In reality, I find that designers talk about games like this much more often than games audiences do. It’s quite difficult to think of a single emotionally compelling game wholly defined by a singular mechanic. Games are a rich combination of emotive materials just like any other art-form, and the idea of a singularly defining “core” mechanic is outdated. We regularly observe games reuse many similar mechanics to their contemporaries without falling into the same genre. Metal Gear, Fallout, Call of Duty and Bloodborne all involve firing a gun but nobody would confuse any of these works as remotely similar.

You’re a cozy game! No, you’re a cozy game!

I would be remiss to not mention the gendered element of the ‘cozy’ moniker, which is often associated with games made for a predominantly female audience. I think this topic is large enough for another discussion entirely, so I will link this great video essay by Graythorn about how games with similar mechanics are taken seriously or not based on superficial traits: The Worst Double Standard in Gaming

Where do we start then in defining what a “cozy” game is? Let’s begin with the word itself. Cozy isn’t exactly the same as comfortable; you are cozy when sitting by a campfire in a dark forest, or huddled up in your bed during the deep of a winter night. The word implies a sublime quality, a danger lurking just beyond where the speaker is. Cozy is a safe space in the midst of a dangerous world.

This is the original Japanese box artwork for Dark Souls before we Americans got that dreadful localized version. We see the player avatar — the Chosen Undead — sit beside a bonfire, which restore the players resources and act as brief moments of respite during the endless dungeons of the game world. After enduring whole sections of pure danger and despair, catching a glimpse of a bonfire’s red-orange flames fills the player with a feeling of incomparable safety and calm. Here lies the key emotive core of Dark Souls: chipping away at a desolate and scary world, one bonfire at a time. This is a game filled with dragons, wizards, horrific beasts and gorgeous 100-foot-tall goddesses! Nevertheless, the protagonist resting by a bonfire is the image FromSoft chose to represent Dark Souls.

Coziness.

But wait, you say, Dark Souls is mostly a tense action game with role-playing elements that is famous for brutal difficulty. The individual moments of sitting at bonfires don’t add up to more than a single percent of a playthrough. How can this possibly be a fair assessment of the game’s emotional goal?

I find the ‘mathematical’ approach to categorizing games completely ineffective, especially because audiences never talk about other mediums like this. Imagine if people identified Transformers as a more of a war movie than Zero Dark Thirty by the number of explosions. Great art spends most of its time setting up the big, hard-hitting moments that affect you emotionally. Again, a game’s genre is a product of the strongest emotions it makes you feel, not the mechanics or aesthetics it employs in the process.

Putting the final nail in the cozy coffin involves separating Dark Souls from the genre it’s traditionally associated with, Action. For how popularly it’s grouped in with action games, Dark Souls shares incredibly little with those contemporaries. The other standouts serve to empower the player with a unique moveset representative of the game theme. Dante from the Devil May Cry series utilizes a plethora of absurd weaponry to fulfill your fantasy of being a stylish demon hunter, while Bayonetta’s titular heroine makes you feel like an elegant dancer as she pirouettes from one racy move to the next. Dark Souls… has none of this. A typical playthrough involves stepping up and poking an enemy before backing off to safety, over and over until the job is done. It’s hardly engaging by itself, made all the more clear by FromSoft’s other game Sekiro, which has a dexterity focus and plays fundamentally differently than any of their other work.

“This right here is 90% of Dark Souls combat,” I say with love.

No, Dark Souls is not special because of the intricacies of the combat system, much to the demise of copycats who incorrectly identified this as the secret sauce. Slow animations and hard-hitting enemies are deliberate design choices, yes, but they are supporting elements rather than fundamental. Souls series director Hidetaka Miyazaki famously claimed he never prioritized creating a ‘difficult’ game. This sounded absurd at the time, but it makes more sense after playing the game and especially after playing other clearly inspired projects that miss the mark. Dark Souls doesn’t brutalize you as much as it wants you to succeed and feel the warmth of the next checkpoint. The fact that the multiplayer systems have a clear bias towards cooperative play rather than antagonistic PvP play bolsters this notion. The harshness of the world simply serves as the dark forest around that campfire.

We assume Dark Souls is a difficult game because we associate death to be a failure state, but the assumption that mechanics foster the same emotions in every game requires rethinking. Death in Dark Souls initially feels punishing because it takes away so much: the progress you’ve made in the level, and your souls, the de-facto points system of the game. Despite this, Dark Souls forces death upon a new player so frequently that they learn to stop fearing it, and can even see it as a tool. In my first playthrough, I often went on ‘scouting runs’ where I had zero souls in order to survey a location and gather information. Death acted as a safety net, as it would simply bring me back to the bonfire without punishment. The repeating content doesn’t hurt when most levels in the game are quite short anyway, having a span of maybe 3-5 minutes of in-game walking. Most if not all non-boss encounters can be skipped by a clever use of running and jumping, turning the game into a faux-platformer. Dark Souls doesn’t use death to punish you; rather, it gently teaches you that death is just another tool in your arsenal to conquer the content. Ask any player who has reached completion and they will no doubt tell you that the deaths eventually stopped hurting as much as they did in the introductory hours. As you expand your exploration of Lordran out from the home-base of Firelink Shrine, more and more of the map begins to feel safe, like building little campfires out from your first one. The game is expertly produced to leave just enough room between bonfires that each and every one feels like a treat to find. This brilliant emotional pacing is the true champion of Dark Souls’ design rather than the surface level mechanical rules of the combat engine.

In the mainstays of the cozy genre, we see the necessary darkness shine through and through. There’s a haunting quality to the quietness of Animal Crossing’s world. Your villagers in AC can leave anytime, giving you a short warning when they rest by a campfire, taking memories and gifts with them. Stardew Valley gets scary after night falls, and the entire narrative has an ever encroaching megastore that threatens to replace the local businesses. Losing a harvest in Stardew is arguably worse than ten deaths in Dark Souls. This darkness and loss is more than important – it is integral to the cozy feeling.

If you don’t want to hear it from me, hear it from Katie Chironis, senior designer at Riot Games:

in both series there is a lot of wistfulness, sadness, even anger from some characters and elements (Mr. Resetti! Grouchy villagers!) because these are the things that lend believability to the fantasy, which makes it more compelling. can't make cake without a little salt, right?

— Katie Chironis (@kchironis) June 26, 2023

I watched the Wholesome Direct this year and it pained me to see what looked like several cozy-likes fall into the same trap that souls-likes did from the opposite direction. Where souls copycats ignore any sense of safety and home to create a cruel, brutal and ultimately forgettable combat simulator, cozy-likes fear any negativity in their perfect candy simulation as if it would infect the happiness. Both of these groups of developers could stand to more closely examine the games they so clearly love and feel the warmth of their tones brave against the cold of their moods. Sheer positivity without any counterbalance risks a cynicism greater than that of the apocalypse.

I don’t wish to cast judgment on artists creating what they want to create, but if your express goal is to make a “cozy” game, you have to be aware of what that word means and what makes games of the genre compelling. As a person who credits Dark Souls with helping my journey in overcoming mental illness, I think cozy games are some of the most important games to be making right now. In a world marching towards destruction on so many fronts, we need games that let people feel warmth. However, for this warmth to be genuine, for it to have any staying power in our hearts, it can’t exist without acknowledging the dark forest surrounding us first. Don’t be afraid to fill your dark forest; just don’t forget to give your players the tools to chop down the mighty trees and fuel their campfires.

Or, if you’ve gotten this far and want nothing more to do with cozy games, please try my favorite hardcore survival-horror strategy game, Pikmin.

Special thanks to Bethany Lai, Weston Bell-Geddes & Jebby Zhang for helping me edit this post.

Follow me @wheatpenguin on Twitter.

File Naming

The format for all filenames is: PREFIX_[Group]_[Name]_SUFFIX

• PREFIX defines the kind of asset.
• [Group] defines which group in the project this asset belongs to. For example, if an environmental model, which level it appears in. Or, if an NPC model, whether it is an Enemy or a Player.
• [Name] self explanatory. Name appropriately and descriptively.
• SUFFIX for extra dilineation on the asset type.

Code

Code File Naming

Code Naming

public enum ExampleEnum
{
  ENUM_MEMBER_ONE,
  ENUM_MEMBER_TWO,
  ENUM_MEMBER_THREE
}

// "A" prefix because abstract class
public abstract class AExampleClass
{

  // Arrange variables in this order: 
  // Serialized > Public Vars > Public Properties > Member Vars

  [SerializeField] int SerializedVariable;
  public int PublicVariable;
  public int Property => mMemberVariable;
  int mMemberVariable; // Omit 'private' for private vars
  bool mIsElectric; // Bools should be named in such a way that you can tell what true or false means implicity. IE: `mIsElectric` instead of `mElectric`

  // Arrange methods in this order:
  // Unity > Protected > Public > Private

  // Unity functions should be private
  void Update()
  {
    
  }

  protected virtual void ExampleVirtualMethod() {}
  protected abstract void ExampleAbstractMethod();

  public int GetValue(int parameter)
  {
    return parameter * mMemberVariable;
  }

// ----------------------------------------------------
// Run coroutines like this:

  // Reference to the running coroutine so starting again stops the old one.
  IEnumerator mDoTaskCoroutine;

  // Function to start coroutine
  void DoTask()
  {
    mDoTaskCoroutine = CR_DoTask();
    StartCoroutine(mDoTaskCoroutine);
  }

  //Function of the coroutine itself, CR_ prefix
  IEnumerator CR_DoTask()
  {
    for(float t = 0; t < 1.0f; t += Time.deltaTime)
    {
      Debug.Log("The current time is " Time.time);
      yield return null;
    }
  }

// ----------------------------------------------------

}

Folder Structure

Top-level folders are capitalized, all else lower are lowercase.

• Art
  • example_category_static
    • material instance (UNREAL) / material (UNITY)
    • model
    • texture
  • example_category_skinned
    • animation
    • avatar_masks
    • material instance (UNREAL) / material (UNITY)
    • model
    • texture
  • …
• Blueprints (UNREAL)
• Data
• Font
• Icon
• Maps (UNREAL) / Scenes (UNITY)
• MasterMaterials (UNREAL) / Shaders (UNITY)
• PostProcessProfiles
• Prefabs (UNITY)
• RenderTargets (UNREAL) / RenderTextures (UNITY)
• VisualEffects

Made with Unity, Blender, HLSL, ShaderGraph, VFX Graph

My friends in LA look at me like I’m crazy when I mention how much I love rainy overcast days. I can’t help it! I’m from the best place on Earth: the Pacific Northwest.

Gathering Reference

Now usually if I wanted to take a close look at rain, I would just take a stroll outside, but Portland is having an unfortunately dry summer. I checked out some YouTube videos instead, like this one:

There were some phenomena in the reference video that I chose to leave out, namely the bubbles and the base waves on the surface of the water. I wanted to shoot for a shallower puddle that still had the vibrancy of rain hitting a deep body of water. It’s not completely realistic, but then again, no great visual effect ever is!

My effect was made in Unity by layering several steps/passes:

• Droplets (ortho camera depth pass -> VFX graph spawn)
• Splashes (ortho camera depth pass -> VFX graph spawn)
• Puddles (vertex color + height blend)
• Ripples (UV manipulation shader)
• Wash cascades (transparent mesh with scrolling shader)
• Mist (depth effect)

The Base Environment

The base environment is a simple blocky mesh that has areas of cover, elevated ground, and varied shapes (sphere and angled block). These represent the main environment problems I expected my rain to solve for. I wanted the splashes to follow the form of the environment and rain to ignore areas that should be covered and safe from rainfall.

The Ortho Camera

Inspired by my friend Sichen Liu’s Odradek Scanner effect, I created an orthographic camera facing down on the scene. I render out this camera’s depth and normals to a RenderTexture. These will come in handy later.

Droplets

The droplets are as simple as can be: a LineRenderer in the VFX Graph that scales the lifetime of each line according to the depth of the ortho camera. This ensures that rain droplets don’t intersect the level and appear underneath cover.

Splashes

Splashes are a spritesheet particle spawned along the ground with the particle-up facing the normal and the particle-forward facing the camera plane. During my process, I ran into issues with ledges. Splashes were spawning half-on a ledge and along the wall, which were immersion-breaking and ugly. To solve this, I run the orthographic camera’s depth through a Sobel filter, which essentially creates outlines around areas of depth contrast. Because the camera is facing downward, these areas of high contrast are my walls and ledges.

By passing this mask into my VFX graph, I can make my splashes ignore walls. The outline has the added benefit of culling away a bit from the ledges, which solves the half-on-ledge problem as well.

Puddles

The puddles and general wetness in the scene was painted on through vertex color and adjusted by sharpness and fill. This is also influenced by the heightmap of the underlying texture.

Ripples

The typical approach for ripples on deep water is a voronoi-style pattern that creates overlapping circles. I wanted to make the ripples feel like they had more local impact, so I instead used a normal texture for the ripple.

In my shader, I sampled this texture with two layers of ripples. Having two layers on separate start times helps kill the grid-like look. I then simulate a ripple animation by scaling the UV of the ripples and fading the normal strength in and out with an ease curve based on the following function:

1.0 - pow(2.0 * input - 1.0, 2)

This function gives a nice ease to the ripple transparency that looks natural.

I also use a population slider that basically compares a floor(rand(uv)) sample against a threshold value to kill a certain percentage of ripples. A full set of ripples looks strangely uniform anyway, and this gives me control over how torrential I want the rainfall to look.

Wash Cascades

I saw this effect on a pillar in Overwatch 2, and it felt like a nice, slightly stylized way to evoke water travelling down a lateral surface.

I recreated it in a relatively simple way: generating a mesh at the side of every ledge that water would be washing down on and scrolling a voronoi + clouds texture along the Y of the UV. Here is the effect with exaggurated visibility.

Mist

Finally, the mist is scrolling noise with a depth mask in order to keep it closely hugging the ground. Here is the effect with exaggurated visibility.

Conclusion

Thank you for reading my breakdown! This was a fun project that challenged me to use the information I had at hand in interesting ways. Making a tribute to my home state felt satisfying, and I feel well-equipped to use ortho-camera depth sampling techniques for various other effects.

Follow me @wheatpenguin on Twitter.

I started game development when I was around ten using Clickteam Fusion to make simple platformers. After learning to code, I started using Unity, and have been a pretty loyal Unity dev ever since. All I’ve ever really known is coding within Unity’s paradigm of GameObjects and C# and whatnot. I figured it was time to try something new.

What to pick?

To maximize the learning opportunity I wanted to use a lower-key framework, something that leaves most of the game loop to me.

I ended up settling with Monogame, as coming from Unity I’m most used to C# anyway. Monogame (prev. XNA) is very battle-tested: several high-profile indie games use it, like Celeste by Extremely Ok Games, Terraria by Re-Logic and Stardew Valley by Eric Barone.

Other choices I researched and did not go with, but you might!

• Godot: Although I appreciate how much more it stays “out of your way” than other engines, it still feels too much for my current wants.
• Bevy: Young but I am keeping an eye on this one!
• SDL2/C++: I use C++ all the time at school anyway so wanted to do something else when I’m coding for fun.

First date with Monogame, a little nervous

It seems like a pattern I have for any new engine/framework is… try to make Cave Story with it. It was the first thing I tried to do with Clickteam Fusion, Unity, and now Monogame.

Getting Quote on the screen with relatively basic platformer controls is at this point my personal Hello World. I have to admit, I was intimidated at first by having no software to go off other than good old VSCode, but after this point most of my anxieties disappeared. I love the freedom of having the framework give me just the bare essentials: an entry point, a Tick(), and a Draw().

I was about to type out a familiar Actor.cs class… when the freedom really went to my head. After all, I’ve been doing the traditional pattern my whole life. While everyone else was going out and partying and hating OOP last year, I had to stay inside with my GameObjects and MonoBehaviours. It’s not a phase, Mom!

Which brings us to…

In my ECS Era

I watched that one Overwatch GDC Talk about ECS and was immediately sold. One of my absolute favorite aspects of game design is consistent systems. I love when every actor in a game, from the player to enemies to even random little objects, have to obey the same rules of the universe.

These personal core values of game design is basically a match made in heaven with ECS, a programming paradigm based on “declarations (there shall be this)” instead of “imperative statements (do this)” (Martens). To use an example from Breath of the Wild: I want to tell my game that fire catches on wood, no matter the circumstance of fire catching wood, whether I am lighting an arrowhead on a bonfire or hurling magic fireballs at an enemy Bokoblin’s wooden shield.

What is ECS, anyway?

There are a lot of in-depth explanations for ECS online – one of the best ones is an Overwatch GDC talk linked above – so I’ll try to distill the essence of it briefly in three main points.

• 1: Your game consists of a list of Entities. These have no individual data/functionality but contain a list of Components.
• 2: These Components are SIMPLY data-objects with zero functionality. Nothing more.

So far, this may sound familiar to Unity or Unreal users, but the zero functionality is a key difference. No mutations, no logic, nothing. Imagine if MonoBehaviours or ActorComponents were only allowed to have public variables. All of your functional code is instead delegated over to…

• 3: Sets of Systems iterate over components that they care about and read/write accordingly.

This is the crux of ECS software design: complete separation between data and logic. Entities only care about what components they have and components only care about what data they hold. It’s all up to systems to determine the flow of change in your software, and an ordered set of systems is massively easier to keep in check when compared to the typical OOP slew of side-effects. The “I want to damage my enemy, but sometimes they can block it, but sometimes I have armor-piercing”-type situations we’ve all been in suddenly feel a lot more manageable.

For my project I decided to go with a C# wrapper for Flecs.

NOTE: Original Flecs is written in C/C++. The wrapper adapts C source code to be usable by C# projects.

Paradigm shift

ECS sounds very cool at first, but once you start trying to create components and systems it can be a bit daunting of how to proceed appropriately. Researching the Flecs user manual helped me understand a lot of the unique aspects and challenges of ECS. I decided on a new Hello World: Have at least 5 digits of entities carrying this image of Pochita from CHAINSAW MAN bounce around in an enclosed square.

The best way to start planning an ECS project is to boil down entities to as granular components as possible. My first hunch was that I would need a Transform component, but this is actually incorrect as per a direct example from the Flecs manual. A Transform is already not granular enough, because it could be boiled down further into Position, Rotation, and Scale. This atomic way of thinking about data allows systems to only bother the data that they need to, instead of having to manage potential side effects of entire OOP classes. I’m excited by the possibilities but recognize that this will take a lot of getting used to.

For my Pochita game, I figured I would need the aforementioned Position, Rotation, and Scale components, as well as two more components: Velocity and Sprite. The components themselves are kind of self-explanatory, especially since they literally do not contain anything other than their named value. For example, Position is just:

public struct C_Position : IComponent
{
    public Vector2 Position;
}

That’s literally it. It’s very freeing that in terms of data, ECS is very WYSIWYG (What you see is what you get) about things. Data is granular and gives you exactly what you expect. Nothing less, nothing more.

My Sprite component ended up being more verbose, but mostly due to helper functions and some data I assume will never be used outside of the context of a sprite draw. If I need to refactor it into multiple components later, it should be easy enough to do so.

TIP: When using Flecs, REMEMBER that every component needs to be registered at the beginning of the program.

Systems are defined as functions that can get subscribed into the Flecs ecosystem. They take an Iterator as a parameter and use their Field<T> function to generate several Span<T> that allow the developer to access specified components. Here is the system that applies velocity to position.

public static void ApplyVelocityToPosition(Iterator it)
{
    float deltaTime = it.DeltaSystemTime();     // Gather deltaTime. I contributed this method! :D
    
    var posIter = it.Field<C_Position>(1);      // Initialize span for position
    var velIter = it.Field<C_Velocity>(2);      // Initialize span for velocity

    for(int i = 0; i < it.Count; i++)           // Loop thru every entity in the game
    {
        ref var pos = ref posIter[i];           // Position component MUST be mutated so use 'ref' keyword
        var vel = velIter[i];                   // Velocity component is simply being read

        pos.Position += vel.Velocity * deltaTime; //Add velocity*dt to position
    }
}

As you can see, this loops through every entity to handle a system all at once. It’s not difficult to imagine the possibilities for how this simplifies things. You have access to every other entity that a particular system concerns, right in the business-logic code for that system!

Subscribing the function as a system to ECS looks like this:

World.RegisterSystem(S_Physics.ApplyVelocityToPosition, EcsOnUpdate, $"{typeof(C_Position)}, {typeof(C_Velocity)}");

The EcsOnUpdate describes the phase this will participate in. the $"{typeof(C_Position)}, {typeof(C_Velocity)}" describes the query that will occur to search through entities to update. It specifies to only bother Entities with C_Position and C_Velocity components with this system.

This is pretty beautiful because this system will apply to any entity that has both a position and velocity without asking any other questions about them. Also, the data being structs means I have to explicitly state when variables are to be mutated or not, using the ref keyword.

The 4 total systems are: ApplyVelocityToPosition, BounceOffWall, RotateTowardVelocityDirection, and PendSpritesForDraw. All of them were pretty straightforward to write and do exactly what their name implies with zero side-effects.

Visualizing ECS data with Dear IMGUI

With ECS as data-driven as it is, I would like to have a way to visualize all of my entities with their components. I decided to start with a simple approach that could grow to be more complex later. For my visualization I went with the .NET Wrapper for Dear IMGUI. This tutorial from FlatRedBall was really helpful to figure out how to do this.

So far it’s just a simple setup with an entity browser that allows the user to dynamically change values at runtime. It doesn’t have any features for adding/removing components or entities as of now.

Conclusion

The final result (for now) is 10,000 Pochitas bouncing around a virtual box. I can move the camera around or change any of their positions/velocities as I wish.

Next steps

So far all I have used Flecs ECS for is a simple physics simulation. I’m sure trying to make a character-based platformer video game like Cave Story will have its own set of challenges, like handling different kinds of queries, using tags, and component relationships. I’ll see how it goes and continue to publish my progress here.

For the IMGUI visualizer, there are a couple next steps I have in mind.

• Entity focuser. A toggle that targets the camera at a specific entity’s position.
• Entity browser filter by component.
• Hierarchy based on Flecs relationships.

Thanks for reading! School starts in a couple days but I’ll try to continue this side project as well as I can.

Follow me @wheatpenguin on Twitter. Check out this project repo on Github.