Final Web Presence Reflection

My final web presence can be found here.

About Page

For this page, I tried my best to craft a history rather than annals or chronicles about myself. The final goal was to describe a series of events which logically leads to my becoming a game programmer, starting with being a kid and goofing around with these things, going to the potential other careers I considered, and eventually heading to where I am now.
 
I also wanted to give a sort of snapshot of my personality, in terms of my interests and generally the type of writing/creative work I do. With that in mind, going with the standard route of describing myself, where I’m from, what I’m like, all sounded a bit cliché to me. Or a little bit like a profile for a dating site.
 
The drop-down menu idea was created to allow a more dense information load in a relatively small page. By giving multiple choices to certain parts of the about page in a Mad Libs-style fashion, I think I’ve successfully given a good amount of information about myself, and my story, with little mental load. It also includes an element of interactivity, which is only appropriate considering my medium of choice.
 

Contact Page

This page was a bit of a challenge for me— I felt awkward giving people a direct call to action, and having the same information in multiple places seemed redundant. Don’t get me wrong, being able to find the information you’re looking for through multiple paths is great, but actually having to post the same four links in more than one spot isn’t ideal.
 
After getting some feedback, I decided to feel uncomfortable and use a direct call to action. Telling someone outright to “email me” has more impact than “here is my email… if that’s good for you.” Additionally, instead of including my contact info at the bottom of my About page and having a separate Contact page, I simply put everything in a section at the bottom of the About page. The Contact link in the main menu goes to an anchor link to that section of the about page. This way, the information is available there, regardless of the path taken.
 

Revised Blog Entries

The blog entries I chose to revise ended up being more recent ones. I feel that I had come more into my own with creative voice and choice of subject matter later on in the semester. Additionally, considering how busy I had become at that time, revising those posts interested me in particular.
 
Most of the edits I made were to make a more casual, consistent tone, or to clarify the intent I originally had for the post. In the case of Frustum Culling, I scrapped the entire conclusive paragraph and wrote a new one. Most of the posts were given a new title, to better fit the new tone and content of the post. New media (photos, videos) were added to a few posts to better fit the post, like in 6 Games With Perfect Aesthetic: Fight Knight was originally the only member of the list with no video. I finally found an appropriate one, so now every member of the list could be processed the same way.
 

Menu / Theme

Using a sidebar menu, rather than one which is always visible, gave me the freedom to present the blog as its own entity. Essentially, I was worried about the entire page being a mess because I was trying to make a blog, a portfolio, and a resume all share the same space and accomplish the same goals at once. It didn’t work, it wouldn’t ever work.
 
The sidebar accomplishes two things: it separates the blog from everything else, and it makes the interface less cluttered, so less thinking has to happen the first time a user lands on the page. Everything is still a maximum of two clicks away, so I don’t feel as if I’m sacrificing convenience. (Three would be too much.)
 
The new theme is significantly more geared toward a blog format. The first theme I chose almost read like a book: all text was there all of the time, the menu was always there like a Table of Contents, even the display font was a sort of block-serif. Everything about it seemed sort of analog, which is strange for a blog about technology and programming.
 
This new format of using featured images and snippets of the post to draw a reader in is exactly what the doctor ordered. It gives a quick glance into the kind of content the blog has to offer, immediately upon landing on the page. It makes browsing different posts easier to do, because so many can be crammed into a single space without them being confused. The use of clean lines, caps & sans-serif typeface, and a pop-out menu really give this the look and feel of a tech blog.

Extending the Unity Editor: A Primer



The Unity Editor’s default way of displaying things isn’t always perfect for what you’re trying to do. As a game project becomes more complicated, the heap of information you’ll need to keep track of only gets bigger and messier. To reduce complexity or confusion, we can simplify things.
 
To start, we need to decide just what we want the Unity inspector to display. Like any other script in Unity, I’ll make things in my class public, or use SerializeFields to expose my variables to the editor.


using System.Collections.Generic;
using UnityEngine;
public class Primer : MonoBehaviour {

    [SerializeField]
    byte height, width;
    public bool isDamaged;
    [SerializeField]
    List<List<string>> soldiers;

	//...
}

Irrelevant code shown as “//…”.
Let’s take a look at that in the inspector as-is:
 

We have height and width taking up their own lines. Our boolean, isDamaged, is already made into a nice checkbox. The nested List of strings, soldiers, is completely absent.
 
To make this script easier to use, we’ll have to dig into the wonderful world of the CustomEditor. Let’s go ahead and make a new class in the same script.


//...
#if UNITY_EDITOR
using UnityEditor;
#endif

public class Primer : MonoBehaviour {
	//...
}

#if UNITY_EDITOR
[CustomEditor(typeof(Primer))]
[CanEditMultipleObjects]
public class PrimerEditor : Editor
{
    void OnEnable()
    {

    }

    public override void OnInspectorGUI()
    {

    }
}
#endif

There are a few important bits here: First, the #if UNITY_EDITOR directive. Anything between that and the next #endif only runs if the code is running in-editor, as opposed to in a standalone build of the game.
 
Second, the class we’re creating extends Editor, but has a few attributes as well. All of these are necessary to recreate Unity’s usual inspector behavior.
 
Lastly, there are two functions in our new class. OnEnable() will run as soon as the object becomes active in the scene hierarchy. Think of it as ‘Awake()’, but for the editor. OnInspectorGUI() will run whenever the GUI is interacted with. Clicking a button, writing in a text field, or even clicking and dragging your cursor around the inspector will run this function. It’s a bit like ‘Update()’.
 
 
If you look at the inspector now, you’ll see that the default appearance has been replaced with our blank slate. Now that we have a custom editor up and running, let’s make it do something.
 
The Unity Editor uses SerializedProperty objects instead of just changing the variable directly. This way, functionality like ‘undo’ can exist. To grab the variables in our class, we’ll instantiate a few SerializedProperty objects and hook them together with the class properties in OnEnable().


//...
public class PrimerEditor : Editor
{
    SerializedProperty height, width, isDamaged, soldiers;

    void OnEnable()
    {
        height = serializedObject.FindProperty("height");
        width = serializedObject.FindProperty("width");
        isDamaged = serializedObject.FindProperty("isDamaged");
        soldiers = serializedObject.FindProperty("soldiers");
    }

    //...
}

 
Now, we’ll use OnInspectorGUI() to display our properties, and apply changes if they’re made.


public class PrimerEditor : Editor
{
    //...

    public override void OnInspectorGUI()
    {
        serializedObject.Update();
        EditorGUILayout.PropertyField(height);
        EditorGUILayout.PropertyField(width);
        EditorGUILayout.PropertyField(isDamaged);
        EditorGUILayout.PropertyField(soldiers);
        serializedObject.ApplyModifiedProperties();
    }
}

Let’s take a look at that in the inspector now:
 

I didn’t even bother taking a new screenshot, honestly.
It’s exactly the same as it was before… plus a NullReferenceException.
 

 
Since we haven’t changed anything to do with the appearance of the editor, we’re only at the default. The exception comes from an issue with Unity’s SerializedProperty class: nested Lists can’t be serialized.
 
Let’s tackle these one at a time.

Horizontal Properties

One of the main things I meant to do by creating a custom editor is put height and width side-by-side. Let’s give that a go with BeginHorizontal() and EndHorizontal().


public class PrimerEditor : Editor
{
    //...

    public override void OnInspectorGUI()
    {
        serializedObject.Update();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PropertyField(height);
        EditorGUILayout.PropertyField(width);
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.PropertyField(isDamaged);
        EditorGUILayout.PropertyField(soldiers);
        serializedObject.ApplyModifiedProperties();
    }
}

 

 
It looks alright, but kind of spaced-out. If you work with Unity in a smaller window, things could even get cut off.
 

 
To save on space, let’s make the any labels like ‘Height’ and ‘Width’ less wide.


public class PrimerEditor : Editor
{
    //...

    public override void OnInspectorGUI()
    {

        EditorGUIUtility.labelWidth = 45;
        serializedObject.Update();

        //...
    }
}


 
Better, but… now our ‘Is Damaged’ label is cut off. Let’s try to set our label width more than once.


public class PrimerEditor : Editor
{
    //...

    public override void OnInspectorGUI()
    {
        serializedObject.Update();

        EditorGUIUtility.labelWidth = 45;
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PropertyField(height);
        EditorGUILayout.PropertyField(width);
        EditorGUILayout.EndHorizontal();

        EditorGUIUtility.labelWidth = 90;
        EditorGUILayout.PropertyField(isDamaged);
        EditorGUILayout.PropertyField(soldiers);
        serializedObject.ApplyModifiedProperties();
    }
}


 
Okay, we can read now! Let’s fix that exception.
 

Nested List

There’s no pretty way to solve this issue, but here’s a workaround I can tolerate.
 
Unity can serialize Lists of custom classes. If that class contains a List, that’s acceptable. So, we just create a serializable wrapper class that contains a List, and use a List of those:


public class Primer : MonoBehaviour {

    //...
    [SerializeField]
    List<myWrapper> soldiers;

	//...
}

[System.Serializable]
public class myWrapper
{
    public List<string> names;

    public myWrapper()
    {
        names = new List<string>();
    }
}


 
Soldiers finally shows, although… we can’t see what’s inside of it. Our last step is to allow our custom editor to show its children.


public override void OnInspectorGUI()
    {
        ..///

        EditorGUILayout.PropertyField(soldiers, includeChildren:true);

        //...
    }

And I added actual values, just for fun.

 
There we have it: a functional custom editor. This borders on the too-simplistic: there’s plenty of built in functions in EditorGUILayout and EditorGUIUtility to make way cooler and more functional editors. I hope this helped get you started!
 
Show Full Source


using System.Collections.Generic;
using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
#endif

public class Primer : MonoBehaviour {

    [SerializeField]
    byte height, width;
    public bool isDamaged;
    [SerializeField]
    List<myWrapper> soldiers;

	// Use this for initialization
	void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {
		
	}
}

[System.Serializable]
public class myWrapper
{
    public List<string> names;

    public myWrapper()
    {
        names = new List<string>();
    }
}

#if UNITY_EDITOR
[CustomEditor(typeof(Primer))]
[CanEditMultipleObjects]
public class PrimerEditor : Editor
{
    SerializedProperty height, width, isDamaged, soldiers;

    void OnEnable()
    {
        height = serializedObject.FindProperty("height");
        width = serializedObject.FindProperty("width");
        isDamaged = serializedObject.FindProperty("isDamaged");
        soldiers = serializedObject.FindProperty("soldiers");
    }

    public override void OnInspectorGUI()
    {
        serializedObject.Update();

        EditorGUIUtility.labelWidth = 45;
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PropertyField(height);
        EditorGUILayout.PropertyField(width);
        EditorGUILayout.EndHorizontal();

        EditorGUIUtility.labelWidth = 90;
        EditorGUILayout.PropertyField(isDamaged);
        EditorGUILayout.PropertyField(soldiers, includeChildren:true);
        serializedObject.ApplyModifiedProperties();
    }
}
#endif

Narrative in Games vs Andrzej Sapkowski

CD Projekt Red’s Witcher games has garnered millions of fans internationally, but Andrzej Sapkowski is not one of them. Sapkowski, the author of the Witcher novels, is famously outspoken in his opinions about video games as a creative medium. He was recently interviewed by Waypoint, hashing out his animosity with CDPR and with narrative in games.
 

Much to his chagrin, the covers of his books have recently used art from the games.
 
The Witcher games, rather than following the events of the novels, have an original story which picks up where the novels left off. This might have something to do with Sapkowski’s refusal to collaborate with CDPR on the creation of the games, or even his complete disregard for video games a storytelling medium.
 

Where’s the room for depth or sophisticated language with which games could elevate culture? There’s none.

-Andrzej Sapkowski, via Waypoint

 
I can’t blame the man for having this outlook: he’s a 69-year-old writer. Aside from having a bias toward the kinds of media patterns his generation was fostered into, it’s fair to say that writers would value their medium above others. There’s no reason to do anything if you don’t think it’s worthwhile.
 
Like most people my age, I’m inclined to support video games as a creative medium, especially a storytelling medium. They’re something that can have the depth of a work of literature without being literature. If I didn’t believe that, I wouldn’t be making video games.
 
To say that there’s no room for sophisticated language in a game only belittles the medium. It doesn’t speak to the medium itself, but it does speak to Sapkowski’s unwillingness to see games as a medium. As he’s said, he’s never played video games and he never will. So of course he wouldn’t get it.
 
In Waypoint’s double-interview with Sapkowski and Dmitry Glukhovsky, writer of the Metro novels, Glukhovsky offers a shorter and more succinct rebuttal.
 

I think that he’s totally wrong, and that he’s an arrogant motherfucker.

-Dmitry Glukhovsky, via Waypoint

 
I’m inclined to agree. But I can’t be too upset about it, really. The Witcher novels are incredible, and I don’t blame him for defending their integrity. His stark refusal to even collaborate with CDPR on a game is sort of disheartening, but it’s 10 years too late to be upset about that. If anything, I’m more upset that this press is all about his disinterest in video games. It would be wildly more valuable to learn about his interest in literature, and what he thinks it has that video games might not.
 
Plus, The Witcher 3 has the best, most polished narrative of any game, ever. That opinion borders on fact. All things considered, it doesn’t really matter who is ultimately owed credit for it. We’re all better off for it being around, if we don’t refuse to play it that is.

Frustum Culling.

At a certain point, the things that become controversies in the game dev community just stop surprising you. Then frustum culling becomes a meme.
 
I’m going to tell this story the way I discovered it: splintered and backwards, and full of spicy memes. First, all I saw was memes about frustum culling, plastered all over my Twitter feed.
 
mind blown
 
I thought, That’s hilarious. Moving on… huh. What’s this?
 
frustum tweet
 
Wait, why is this a thing now?
 
another frustum tweet
 
Is it really that bad? I’m… going to search this.
 
Upon searching ‘frustum culling’, I was greeted with a slew of opinions, mostly about how novice developers should keep their mouths shut about things. Even a helpful graph about the Dunning-Kruger effect.
 
dunning kruger graph
 
So, eventually I gathered that some newbie developers were making fun of people for… not knowing what frustum culling is? Which seemed oddly specific and really unnecessary.
 
Sadly, I guessed right. This Polygon article laid out the whole weird debacle: a bunch of developers were mocking people for thinking that this gif was interesting.
 
horizon zero dawn
 
And suddenly I remembered, I saw that gif earlier this morning. I was familiar with what the game was doing, but strangely enough I didn’t feel the need to make fun of anyone. It’s even exciting to me, seeing something I know about in action in a modern, AAA title like Horizon Zero Dawn. Aside from that, it’s just plain pretty.
 
The irony is absolutely delicious: not only did these developers have their “expertise” backfire on them, but now that frustum culling has become a meme so sporadically, anyone who didn’t know what it was before is absolutely going to learn.
 
While the means is a little absurd, this silly meme is performing the same function that the gif originally did: telling people about a really neat thing that video games do. I couldn’t be more pleased.
 

 

Tiny Portfolio Explanation

My portfolio was created to exhibit some of the different ways I’ve tackled graphics programming, as well as exhibit myself to an extent. I wanted to make absolutely certain that a reader could skim and enjoy the final product if they so desired. However, I am a programmer, and I wanted to show my code off as well to those who might be interested– without clogging up the portfolio with long sections of code. That was my challenge.
 

Intro

To start, I wanted to make my angle perfectly clear. My intro had to be a sincere, no-frills summary of what I do and how I feel about it. I think I pulled that off successfully, without distracting from the main body of work.
 

Shaping the Page

Since this is such a visual-heavy portfolio, I wanted to keep any text light and easy to scan, even more than usual. Making strong visual structures was important as well: any captions for videos, descriptions of code, or the code itself had to look as if it served that function.
 
After that, I had to make sure each individual project felt distinct. Making three separate videos rather than a single one, and using them as a sort of signpost that a new project had begun, was a conscious choice.
 

Code

Showing off my code without making the page too text-heavy was sort of a catch-22. My solution was to make the code all available on the page itself, just hidden until the reader reveals it. After weighing this against the alternatives (linking to the source on GitHub, for example), it seemed like the most direct and hassle-free way to view the code.
 
This also came with the added benefit of my being able to highlight anything in the code I found particularly important or interesting. This makes the code somewhat skimmable as well: breaking it into smaller paragraphs makes no sense, but putting anything important in blue allows a reader to get the idea of the program much more quickly.
 
One issue that arose as I added the “Show Code” links was the phrase “Show Code” itself. I wasn’t sure if I should have labelled the links with a description of what was behind them, since “Show Code” isn’t too different from “Click Here.” Ultimately, I made the choice because it seemed clearer to give the link text which described its function. A link called “Modified ‘Softy’ Lighting” could open another webpage. “Show Code” is more clearly labeled.

Bits & Brews: Why Programmers Love Beer

Developers are borderline obsessed with their substances. Coffee is definitely the drug for most, but beer is a close second, at least among the programmers I know. I’ll admit it, I’m a bit of a snob (read: pompous idiot) when it comes to what I’m drinking. And I know I’m not alone there; I’m definitely in good company among other programmers. Hell, here’s a list of programming languages if they were beer.

Of all people, why programmers? Logic would dictate that sobriety would make our work easier. However, it’s been proven that the opposite is true: To an extent, alcohol increases programming skill.

ballmer_peak
As always, there is a relevant XKCD.
 
This study published in 2012 suggests that creative problem solving increases alongside BAC. Programming is just that– in order to find those non-obvious solutions to problems, or gain useful insight into the inner workings of something, creativity is key. Apparently, this comes at the price of working memory. But that’s what Stack Overflow is for, right?

There’s a decent amount of evidence as to how alcohol can positively affect programming. It doesn’t adequately cover why programmers themselves obsess over it so much. Here’s my theory. This is pure conjecture, so do with it what you will.

Programmers tend to obsess over getting the most performance out of their work. It makes sense that we’d do the same thing with our mental performance. We also get in flame wars over small details: vim versus emacs, tabs versus spaces, SQL versus NoSQL.

mixed braces
Or these curly braces.

So it follows that programmers have the capacity to be total snobs about minute details. Put the two together, and you get someone obsessing over which kind of hops were used to make the IPA they’re sipping.

I’m curious as to how far programming and beverage preferences correlate. This is about as scientific as a horoscope, but I’m sure there’s some relationship between people who can drink straight whiskey and people who will insist on using ternary if operators instead of an if statement.

I’ll volunteer my preferences to be judged by the greater internet. If you can extract some useful insight from this, I owe you a pint: Mainly I program games in C#, C++, and Cg/HLSL using Visual Studio & Unity. Tabs > spaces, the brace should go on a new line, and while I don’t use ternary conditionals for the sake of clarity, I do love C#’s null-coalescing operator. I prefer Porters and Stouts, especially Russian Imperial Stouts. But my absolute favorite is Off Color’s Scurry.

Emergent Gameplay: Why?

In my last post, I started and ended on the notion that emergent gameplay is something worthwhile. I never really mentioned why, though.
 
Here’s why.
 

Seamless Agency

Agency is a term that gets thrown around quite a bit among game design circles. In essence, it’s the idea that the player has enough control and information to make decisions and act on them. A really simple thing that breaks a player’s agency is invisible walls: the ability to walk normally is taken away. Any game with successful design has what I like to call seamless agency.
 
Ordinary player agency gives a game’s players certain abilities, but not all of them. Take Skyrim, for example. One of the most meaningful ways the player can affect the world of the game is by killing things. However, characters important to the plot can’t be killed. The player’s agency is stripped away, because otherwise the game couldn’t go on.
 
skyrim
You can’t kill kids either… I think that’s for the best.
 
Games with seamless agency have this same situation: players are given the ability to do a finite amount of things. But in this case, there’s no gray areas, no exceptions to the rule. A good example of this is Rocket League. You only have the ability to race around and perform little jumps. But there are no exceptions: all of the areas presented to the player are fully accessible. You can do anything within the bounds of what you think you can do.
 
When a game achieves this level of agency, a lot of people will take the enjoyment they derive from it and say it’s because the game is immersive. You’ll often hear people say things like “it really feels like I was there,” or, “I had no idea it was already 4 AM.” To be perfectly candid, “immersion” isn’t worth talking about. Let’s talk about something better.
 

Immersion Flow

Flow is a psychological concept that extends well past games. Ever get so into something that you don’t notice time passing? Anything at all: reading a book, knitting, playing games, cleaning— they’re all tasks that enable flowing.
 
Another important aspect of flow is the melding of thought and action. Rather than thinking things through, they’re simply done. People who play action games sometimes will jerk their controllers around as they move, as if it will do something. It’s not a thought-out action, it’s the result of thoughts being put into action without anything in the way, including a consciousness of the self. In effect, it’s a projection of the self into the game avatar, rather than a conscious control.
 
The only way this can be possible is if the player has seamless agency.
 
ouroboros
We’ve gone full circle.
 

Play > Gameplay

Once there are enough things to the player to mess around with, finishing ceases to be the end goal. Giving the player the ability to do something, and successfully creating a space to let them explore that ability fully, is the essence of play. Gameplay can be anything: a game of Go Fish involves gameplay. Play is something very different.
 
When encountered with a problem in real life, we analyze it from every angle first, we experiment, and we do something clever if we can. In many video games, problems are solved by pressing every button we have to see if it will make a difference.
 
When challenges in games become more flexible, like real world challenges, we become clever again. We experiment. The reward of solving the problem comes from the experience, not just from finishing. We relish the challenges. And we lose ourselves in the process. We play.
 
 
Much like describing a song in words, describing how emergent gameplay feels different from ordinary gameplay is difficult. It’s also difficult as hell to make this kind of design work in a game. If the success of games like Minecraft or Breath of the Wild is any indicator, people do relish this kind of experience. It’s a worthy goal. To me, it’s the only goal.

Emergent Gameplay: What?

Emergent Gameplay is the highest goal a game developer can hope to achieve. There are a lot of great games out there with tons of diverse strategies and higher concepts to make their game worth experiencing. But there’s nothing else quite like it.
 
breath of the wild
Breath of the Wild creates immense opportunities for emergent gameplay.
 

What It Is

It seems tough to nail down exactly what emergent gameplay means, simply because it’s one of those really exciting buzzwords that developers like to throw around now and again. (Like immersion. Ugh.) But, it’s pretty easy to tell if a game has it: If the player can make creative choices to solve a problem, then it has emergent gameplay.
 

What It Can Be

A lot of games are created to allow creative expression, with a sort of game-wrapper around it. Games like LittleBigPlanet and Scribblenauts allow players to customize and make their own path toward a goal, although these goals are relatively simple.
 
scribblenauts unlimited
Not 100% on what the goal is, but this person is probably doing great.
 
Then there’s rarer games like Breath of the Wild, which was created with tons of systems that interact with each other simply to give the player a lot of options to play with. In the screenshot up above, that event was not scripted. Impressive, but completely because of the player’s choices. They could easily have walked into the front door without all that exploding. I’d even include Dwarf Fortress in with this category. There’s an infinite amount of ways to solve a single problem, if you can think around it.
 
dwarf fortress
Not nearly as pretty, but definitely emergent.
 
Then there are… other ways. Sometimes, emergent gameplay is a complete mistake. Something the devs overlooked, or was discovered as a “feature” while they were making it. For example, rocket jumping. The technique is usually included in first-person shooter games, but it can lead players to areas of the game that weren’t meant to be seen by players, or break the game’s intended course for the purposes of speed running.
 
 
Creating spaces for people to make meaningful and creative choices is nothing to sneeze at. Of all the kinds of games a person could make, creating one with opportunities for actual play is by far the most challenging, and the most meaningful.

Unconventional: 4 Games That Break the Rules

As developers, it’s our duty to break the rules. Whether it’s a popular opinion or a common game heuristic, people generally stick to the same old. Breaking old patterns makes a game stand out.
 
Rewatching the Wattam panel from a couple of years ago, Keita Takahashi made a great observation about this:

There are some meaningless restrictions which people don’t know the reason for, because they were established long ago… we might be restricted without noticing, or we might restrict ourselves.

 
That’s enough introduction, let’s talk about the games. Here are a few great ones that do away with convention. I hope it gets your wheels turning.
 

Octodad

octodad
Octodad is a perfect inversion of the action/adventure genre. In Octodad, you play an octopus whose only task is to act like an ordinary human. Common knowledge would dictate that easy, streamlined controls are better, but the entire game’s success stems from not being able to control the main character very well. They’re so clumsy and difficult that the final boss of the first game is a ladder.
 

Braid

braid
I could make an entire post about all the individual ways Braid turns the platformer genre on its head. Here’s a spoiler-free taste: There’s no way to die. You control time, so you can always rewind the death. Enemies can kill each other, though. This can sometimes be a bad thing, since they’re necessary to complete parts of the game. The official walkthrough for the game tells you not to use a walkthrough. The game’s story was created to be thoughtful and rife with symbolism, a pill for generic action fodder.
 

Starseed Pilgrim

starseed pilgrim
The goal of Starseed Pilgrim is to learn how to play Starseed Pilgrim. Sound backwards? Other than simple controls, there’s not a lick of what you’re meant to achieve. It’s completely engrossing, but in a task-oriented way; as for the purpose or meaning, there’s no immediate clue. The game is meant to be played until you finally understand it. A few other games have pulled this off successfully. Mu Cartographer and Plug & Play immediately come to mind.
 

Splatoon

splatoon
By far my favorite shooter, and only because it gets rid of the staple mechanic common to every other shooter. In Splatoon, kills don’t matter. The only way you can lead your team to victory is to cover the battleground in your team’s ink color. Killing enemy team members might help you in that effort a little, but they don’t contribute to winning in the long run. This little gimmick makes teamwork and exploring maps fun, unlike other shooters.
 
 
There’s a lot more ground that could be covered here, but this list isn’t meant to be exhaustive. It’s here to inspire more great rule subversions, inversions, and whatever else. Nevertheless, leave a comment, tell me about a game that breaks the rules.

Making Tasty Code for Games

This is a re-write of a previous post, Good Taste vs Working In a Team.
 
If you’re a programmer, chances are you want to be a good one. It’s difficult to pinpoint what makes one programmer better than another, but defining what good code looks like is a start. Linus Torvalds talked about what good taste means for software developers at a TED interview not too long ago.
 
good taste
Torvalds’ examples of bad taste and good taste, respectively.
 
As always, problems arise when other people become involved. Working on a team has its advantages, of course. It’s basically required to finish something quickly. But having good taste doesn’t always count when the code you’re writing depends on someone else’s.
 
I’m left to wonder how much good taste matters in the game industry. Making quick fixes is a necessity whether they’re tasty or not. Goals for game developers can change weekly. Making polished work, especially when it might be scrapped later for something completely different, can have little appeal.
 
To me, the challenge of making a perfect solution to a problem is enough of an appeal. So, per a McCarthy Bootcamp protocol, I try to keep my focus on what I’m passionate about, and do my own work the best way I can. Outside of what can be measured quantitatively, good code is subjective anyway.
 
real programmers
All a matter of preference, per the norm. (source: xkcd)