A lot of Rollercoaster Tycoon. Three games at a time. It’s very fun! I played through two at a time a while ago, and that was pretty chill, so now it’s three.

The main reason I decided to try this out again was my discovery of Marcel Vos on YouTube. He does a lot of very thorough mechanics breakdowns for Rollercoaster Tycoon, including, among other things, the interesting point that security guards are mechanically completely unnecessary. That got me thinking, hey…

…does Rollercoaster Tycoon encourage abolishing the police?

Just in case you weren’t aware or clear on the matter, very briefly, the notion of abolishing (or, to a lesser extent, defunding) the police is that police in the US are overburdened and ineffective; police officers (and other bodies of policing, like ICE and military) are the default means of conflict resolution, whether appropriate to a situation or not, and many necessary social services have been offloaded onto them when care-focused efforts would be both less expensive and more effective. More than just reallocating resources, it’s about evaluating why we feel the need for policing at all and finding which care-focused solutions will be cheaper and have better outcomes. Not sending cops to handle mental health crises, for example.

Okay, but roller coasters.

In Rollercoaster Tycoon, you have a few types of staff available to hire. Handymen clean the park, mechanics maintain and fix rides, entertainers make nearby guests happier, and security guards prevent nearby guests from vandalizing benches and other décor. Only unhappy guests vandalize, so as long as there’s nothing particularly bad about your theme park, vandalism simply won’t occur. Having played about 100 hours worth of the game recently with no security guards, the only time I’ve seen any vandalism was along a couple paths I neglected to assign handymen to, thus the guests were simply reacting to the worrying assortment of nearby vomit.

RCT implies that no guests are inherently vandals and will only vandalize in response to some fundamental problem. It’s a simplified model, of course, but it sounds on-brand to me.

In particular, this contrasts with one of the primary arguments against completely abolishing the police: the Essentialist argument that some people are just inherently bad. Parkitect takes this approach; while guests might vandalize due to unhappiness, occasionally a group of new guests will be set to be vandals regardless of their enjoyment of the park. The player is alerted when this happens, ostensibly to beef up security in opposition to the incoming threat.

I haven’t played Parkitect a ton, but I usually found that my security guards were never around right when vandalism happened, and I’d still have to find and replace broken stuff afterward. To my mind, this, too, nicely encapsulates the state of policing: Either the player has to hire an excess of security guards just in case they might catch criminals in the act, or they just don’t bother and recognize that it’s just cheaper and likely inevitably necessary anyway to clean up afterwards.

Now, you might reasonably point out that this is just a cute observation about RCT in hindsight, and you’d be right about that, but one main obstacle to making progress on police injustice is the inability of some people to simply conceive of an alternative to things as they are. Some people simply cannot imagine a society without a police force, so “radical imagination,” as activist Brittany Packnett Cunningham describes it, is an important tool. Simulation games have for a long time acted as a means to pose big questions and offer interesting, if simplified, answers, and it’s useful to interrogate them further.

(Oh, lastly, I’m always tickled by this product registration screen from the original game disc’s installer. Look how much fun these people are having!)

The post Rollercoaster Tycoon says Abolish the Police appeared first on Sketch House Games Blog.

Let’s walk through a shader and corresponding C# script to allow arbitrary text animations in Unity. It took a few failed attempts, but I’ve pieced together a solution that relies only on adding delimiters to the text to indicate which substrings you want to animate. I’m not super experienced with shaders, so there are probably some improvements to make, but this works well enough for me.

We’re going to make some wavy rainbow text like this:

We’ll do this by retrieving vertex indices for the text we want to animate, passing those indices into a text shader, and then applying the animations to the matching vertices.

C# Script to Retrieve Text Vertices

Start by creating this TextAnimated script as a child of the UnityEngine.UI.Text.

public class TextAnimated : Text
{
    private const char delimiter = '`';
    public Material baseMaterial;
    private float[] animateVerts = new float[16];

    public void Start()
    {
        this.material = Material.Instantiate(this.baseMaterial);
    }
}

First, we define a delimiter character. This is a character we know we will never want to actually appear in our text that we will use to indicate the text we want to animate. I use the grave mark (`) since it’s present on most keyboards and I have never used it for any other reason.

We also expose a Material to use for our text and clone it so that each TextAnimated can modify its own version without affecting the others. This Material will use our text shader.

The animateVerts array will be used to communicate with the text shader. This will act as a big buffer where the TextAnimated will write start and end target vertex indices, so it will hold two indices per animated text range; that is, for each block of text marked with our ` delimiter, animateVerts will receive two indices. (Note that these should be ints, but they are instead floats since Material has no SetIntArray method for some reason.)

Now, we need a way to populate the animateVerts array. Create a method SetText, which we will use instead of assigning to TextAnimated.text directly.

    public void SetText(string newText)
    {
        if (newText.Contains(delimiter))
        {
            string[] substrings = newText.Split(delimiter);
            int charCount = 0;
            int spaces = 0; // Whitespace doesn't have a glyph, so we need to deduct from the vertex indices when counting characters.
            StringBuilder output = new StringBuilder(); // The actual output text should not have the delimiter.

            for (int s = 0; s < substrings.Length; s++)
            {
                output.Append(substrings[s]);
                if (s == substrings.Length - 1 && s % 2 == 0) // The text to animate will always be an odd-numbered substring,
                    break;                                    // so if we're on an even-numbered substring with no corresponding odd-numbered one, we can just stop.

                spaces += substrings[s].Count(c => char.IsWhiteSpace(c));

                this.animateVerts[s] = charCount + substrings[s].Length - spaces; // This gives the index of the character at the start/end of an animated text region, accounting for whitespace.
                this.animateVerts[s] = 
                    this.animateVerts[s] * 4 + // Each glyph has 4 vertices (TL->TR->BR->BL), so this gives the actual vertex index.
                    (s % 2 == 1 ? -1 : 0); // For the ends of animated text substrings, that index will be the first index after the substring, so add -1 to get the last index of the substring instead.

                charCount += substrings[s].Length;
            }
            this.animateVerts[substrings.Length] = -1; // We'll use a -1 index so the shader knows where the valid data ends, since we don't ever clear out this array.
            this.text = output.ToString();
        }
        else
        {
            this.animateVerts[0] = -1;
            this.text = newText;
        }
    }

We first Split our input text on the ` delimiter, so we know that even-numbered substrings are normal text and odd-numbered ones are animated (Split will return empty strings between any adjacent delimiters). Then, we just need to track the length of each substring so we know what character they start and end on. Each character glyph has 4 vertices (for the top-left, top-right, bottom-right, and bottom-left corners, in that order), except for whitespaces which have no glyphs. Using that info, we can calculate the indices of the vertices for our odd-numbered substrings and then write those values into the animateVerts array.

Now, animateVerts has pairs of start and end indices, using a -1 entry to note the end of valid data, but we need to update the shader with these data. We can use OnPopulateMesh, which is called any time a Unity Graphic needs to be redrawn. This is why we’re making a child of Text – so we always update the shader exactly when the text is getting redrawn.

    protected override void OnPopulateMesh(VertexHelper toFill)
    {
        base.OnPopulateMesh(toFill);
        this.material.SetFloatArray("_AnimateVerts", this.animateVerts);
    }

Text Shader to Apply Animations

Now that we have a C# script that retrieves the text vertex indices, we need a shader to use them for animations. Download the built-in shaders for your version of Unity from the Unity downloads archive (or you can use some other text shader if you have one). The UI-Default shader should suffice, so make a copy of that one in your Unity project.

We have two minor edits to make before adding our animation logic. First, the appdata_t struct needs to include a vertex ID. This is a built-in variable for vertex data in ShaderLab, so that each vertex will know its index.

struct appdata_t
{
    // [Other members defined here...]
    uint vid : SV_VertexID;
};

Next, add the _AnimateVerts array in the body of the Pass function. There are likely other members declared there to match the shader’s Properties; we can also declare a member without a corresponding Property if we don’t want it to appear in the Inspector. Make sure it has the same capacity as animateVerts in the C# script.

float _AnimateVerts[16];

In the vert function, we can now add whatever animations we want for the text. Let’s add a simple vertical wave and a cycle through the full rainbow of colors. I’ve included simple implementations of these with some values hard-coded in just to look nice for our example, but in practice you can do whatever your’d like now that you have the vertex indices. Note that we use the built-in _Time value to advance the animations over time.

v2f vert(appdata_t v)
{
    // [Other logic here...]

    // Check this vertex against all valid animation data to see if this vertex should be animated.
    for (uint av = 0; av < _AnimateVerts.Length - 1; av += 2)
    {
        if (_AnimateVerts[av] < 0 || _AnimateVerts[av+1] <= 0) // -1 is used to indicate the end of valid data. Also, no valid end index could possibly be 0, though a start index could.
            break;
        if (v.vid >= _AnimateVerts[av] && v.vid <= _AnimateVerts[av+1])
        {
            OUT.vertex.y += (cos(OUT.vertex.x / 4 * 80 + _Time * -120) / 80); // Vertical wave. The exact values used are arbitrary; tinker with them to suit your needs.
            float t = (_Time + v.vid / 4 * 2.0) * 100; // Rainbow timing. The values are also arbitrary. This uses v.vid so each character is entirely one color.
            float r = cos(t) * 0.5 + 0.5; // 0 * pi
            float g = cos(t + 2.094395) * 0.5 + 0.5; // 2/3 * pi
            float b = cos(t + 4.188790) * 0.5 + 0.5; // 4/3 * pi
            OUT.color.rgba = float4(r, g, b, 1);
        }
    }
    return OUT;
}

All that remains is to create a new Material that uses our shader, assign that as the baseMaterial of the TextAnimated, and call SetText with the text to animate!

Full Unity Text Code

Here’s the full TextAnimated script and the shader edits. There’s also an Editor script for the TextAnimated since it otherwise just looks like a regular Text in the Inspector. Cut them up to suit your needs!

using System.Linq;
using System.Text;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// A Text that can supply a custom shader with data for animated text.
/// </summary>
public class TextAnimated : Text
{
    private float[] animateVerts = new float[16]; // 16 is arbitrarily large. Make sure this matches the shader.

    [SerializeField]
    private Material baseMaterial;
    private const char delimiter = '`';

#pragma warning disable CS0114 // Member hides inherited member; missing override keyword
    public void Start()
#pragma warning restore CS0114 // Unity will handle that since this is a Unity function.
    {
        this.material = Material.Instantiate(this.baseMaterial); // Make a copy so we don't modify the base material. Note that this means edits to the shader won't affect this while in Play mode.
        this.SetText("Here's some text. `WOW!!!` It's great!\nLook, it even crosses `multiple\nlines!`"); // Just for demonstration.
    }

    /// <summary>
    /// Be sure to call this instead of setting TextAnimated.text!
    /// </summary>
    public void SetText(string newText)
    {
        // If the text uses the delimiter, we need to both calculate the correct vertex indices and remove the delimiter from the output text.
        if (newText.Contains(delimiter))
        {
            string[] substrings = newText.Split(delimiter);
            int charCount = 0;
            int spaces = 0; // Whitespace doesn't have a glyph, so we need to deduct from the vertex indices when counting characters.
            StringBuilder output = new StringBuilder(); // The actual output text should not have the delimiter.

            for (int s = 0; s < substrings.Length; s++)
            {
                output.Append(substrings[s]);
                if (s == substrings.Length - 1 && s % 2 == 0) // The text to animate will always be an odd-numbered substring,
                    break;                                    // so if we're on an even-numbered substring with no corresponding odd-numbered one, we can just stop.

                spaces += substrings[s].Count(c => char.IsWhiteSpace(c));

                this.animateVerts[s] = charCount + substrings[s].Length - spaces; // This gives the index of the character at the start/end of an animated text region, accounting for whitespace.
                this.animateVerts[s] = 
                    this.animateVerts[s] * 4 + // Each glyph has 4 vertices (TL->TR->BR->BL), so this gives the actual vertex index.
                    (s % 2 == 1 ? -1 : 0); // For the ends of animated text substrings, that index will be the first index after the substring, so add -1 to get the last index of the substring instead.

                charCount += substrings[s].Length;
            }
            this.animateVerts[substrings.Length] = -1; // We'll use a -1 index so the shader knows where the valid data ends, since we don't ever clear out this array.
            this.text = output.ToString();
        }
        // If the text doesn't use the delimiter, just show it normally.
        else
        {
            this.animateVerts[0] = -1;
            this.text = newText;
        }
    }

    /// <summary>
    /// This is called whenever the text Graphic needs to be redrawn. We're just using it to know when to update the shader data.
    /// </summary>
    protected override void OnPopulateMesh(VertexHelper toFill)
    {
        base.OnPopulateMesh(toFill);
        this.material.SetFloatArray("_AnimateVerts", this.animateVerts);
    }
}

using UnityEditor;
using UnityEngine;

[CustomEditor(typeof(TextAnimated))]
public class TextAnimatedEditor : UnityEditor.UI.TextEditor
{
    private SerializedProperty baseMaterialProp;

    protected override void OnEnable()
    {
        base.OnEnable();
        this.baseMaterialProp = serializedObject.FindProperty("baseMaterial");
    }

    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
        serializedObject.Update();
        EditorGUILayout.PropertyField(this.baseMaterialProp, new GUIContent("Base Material"));
        serializedObject.ApplyModifiedProperties();
    }
}

// This is just part of the shader. Add this to the relevant text shader.
Shader "UI/TextAnimated"
{
    // Add this to your struct appdata_t
    uint vid        : SV_VertexID; // Adding this in to identify verts more easily.

    // Declare this in the Pass body
    float _AnimateVerts[16]; // Pairs of start and end indices. There's no Material.SetIntArray for some reason, so use floats.

    // Add this to your vert function
    // Check this vertex against all valid animation data to see if this vertex should be animated.
    for (uint av = 0; av < _AnimateVerts.Length - 1; av += 2)
    {
        if (_AnimateVerts[av] < 0 || _AnimateVerts[av+1] <= 0) // -1 is used to indicate the end of valid data. Also, no valid end index could possibly be 0, though a start index could.
            break;
        if (v.vid >= _AnimateVerts[av] && v.vid <= _AnimateVerts[av+1])
        {
            // Here is where you can call whatever animation logic you need.
            OUT.vertex.y += (cos(OUT.vertex.x / 4 * 80 + _Time * -120) / 80); // Vertical wave. The exact values used are arbitrary; tinker with them to suit your needs.
            float t = (_Time + v.vid / 4 * 2.0) * 100; // Rainbow timing. The values are also arbitrary. This uses v.vid so each character is entirely one color.
            float r = cos(t) * 0.5 + 0.5; // 0 * pi
            float g = cos(t + 2.094395) * 0.5 + 0.5; // 2/3 * pi
            float b = cos(t + 4.188790) * 0.5 + 0.5; // 4/3 * pi
            OUT.color.rgba = float4(r, g, b, 1);
        }
    }
}

The post Make Unity Text Animation Easy with Shaders appeared first on Sketch House Games Blog.

Hey, let’s talk about Mitzi the cat, and about how Animal Crossing: New Horizons abandoned the series’ origins to promote player expression through control.

In my original Animal Crossing town, Mitzi was my favorite villager. I liked Bunnie and Punchy, too, but Mitzi was my favorite. I eventually learned that a new friend of mine had the game as well, so one day I visited his town.

Now, in addition to having to plug both memory cards into one Gamecube, visiting another town in the original AC meant that a random villager from one town could immediately move to the other. And, wouldn’t you know it, when I got back to my town, Mitzi was gone.

I cried. I was devastated. I never visited another town again. People will often praise games that move them to tears, but I’m pretty sure they don’t mean like this.

Still, the original Animal Crossing did something that I think New Horizons is incapable of doing: It gave the villagers agency, that they may act outside the player’s control and feel believable and alive.

New Horizons does everything it can to make you feel like you’re in control, and indeed you are; the placement of every building, the decision to allow a new villager onto the island, even the landscape itself are all up to the player’s discretion. The entire progression of the game serves to let players handle things how they want and express themselves.

In the original AC, the primary objective is to make enough money to pay off your debt, with side goals of scoring high marks with the Happy Room Academy for displaying complete furniture sets and of completing the museum. There aren’t really any shortcuts to these, as the only way to earn Bells or acquire things to donate is settling into the daily routine of fishing, foraging, and so on. You could try selling turnips, but whereas in New Horizons it’s easy enough to hop on someone else’s island when they have a good price, in AC even if you did have access to multiple towns you’d give up a villager to make the trip.

The only consistent option for achieving the primary goal was to engage with AC as a lifestyle game – jump on for a bit each day, make steady and measurable progress, enjoy the occasional seasonal events, savor the mundanity.

This ultimately aligns well with the game’s core conceit: You’re moving into an existing town when you boot up a fresh save, joining what is supposed to be an existing community. As the original English commercials emphasized, the game is designed to feel like a living world that keeps going whether you’re playing or not, which makes your town feel alive and makes the residents feel like they have agency, and you can’t simply binge it for a few days to generate all the cash you need.

New Horizons, on the other hand, positions improving the island as the main goal. The literal main quest line to entice K.K. Slider to the island culminates in raising your island’s rating, to which all the previous quest activities (inviting more villagers and building buildings) happen to contribute, and your own house is largely irrelevant towards that end.

Critically, since the biggest rewards and goals in New Horizons are terraforming and placing new bridges or exterior features, nothing in the game dares to make any meaningful changes to the state of the island in the absence of the players. Villagers feel like toys, living wherever you decide they should be and just as likely to do some fun activity of their own accord as they are to drop everything at your appearance so they can give you a new chair to put out on the island if you want to but hey, if not, that’s cool too! If someone wants to move in or out, they will make certain that you have had the chance to vet their decision first. If you feel like shuffling some buildings around, say the word and Nook will make it happen.

This also causes some weird metaphors with the deserted island setting. I’m sure not qualified to do a deep dive into the role of capitalism in New Horizons, but suffice it to say that when it offers an infinite supply of definitely uninhabited islands to extract resources from (“uninhabited” aside from all the bugs and fish, but they don’t count, except for when they do) without any regard for the consequences, I’m just a little troubled. And let’s not get into the weird gray markets players have made for trading villagers who are ready to move out (and the scramble after launch to learn how to force certain animals to move out), such that players can easily exchange animals they dislike or find ugly for those more in line with their sensibilities.

Note that this behavior would be unacceptable if you believe the villagers to be real characters making their own decisions, but if they only exist as objects, toys to be dressed up and played with, then it would be more reasonable.

The post Animal Crossing: New Horizons and Gaining Control appeared first on Sketch House Games Blog.

I will never again make a game with characters who have knees.

Looking at modern video games, there is a mind-boggling amount of time spent making 3D characters feel cohesive with the worlds they inhabit to avoid breaking immersion. Inverse kinematics, animation lerping, idle fidgets, facial expressions…there’s a whole host of little details to nail, and nothing shatters verisimilitude like the player character’s cool dress clipping through her giant sword.

But folks, that’s all very hard. Even after animating an entire game, the most basic rigging and IK tasks still prove esoteric and frustrating. I targeted an N64-era aesthetic in hopes of reducing my workload for these technical tasks, but I overlooked a critical characteristic of early 3D games: Expectations and hardware were different in the ‘90s, so even when animation and rendering details were visible at 240p on a CRT TV, they would go unnoticed by most players. Consequently, their developers necessarily opted to cast aside unnecessary details in favor of tightening their aesthetics.

I don’t think I’m injecting too much intentionality through hindsight here. Sure, perhaps character animations needed to be exaggerated just to be understandable at low resolution, but that also made them more expressive. Yes, objects needed bright colors and clear silhouettes so they didn’t all blur together, but that’s just good visual design.

Fittingly, Kirby 64 is still one of the best-looking games out there. The use of colorful backdrops populated by abstract shapes and patterns reflects the playful nature of the franchise, while also cleanly evoking a sense of each location without getting bogged down in the details of actually rendering it accurately. Enemies are often little more than colored 3D shapes, carefully selected and dramatically animated for an intuitive a sense of how they move and what powers Kirby might absorb from them. Kirby and his friends never speak (aside from Kirby’s adorable cries when injured or excited), yet the game’s wordless cutscenes effortlessly convey the whimsical drama driving them forward.

The level of visual abstraction is sublimely balanced; details that matter most are given color and emotion while superfluous details are discarded. Reflecting on it recently, it bears some interesting similarities to Impressionist art.

The Impressionist movement in art was one of deprioritizing detail in favor of overall feel or flow, less about capturing verbatim a scene or a moment and more about reflecting its essence, its impression. A tree need not be painted to look visually realistic when the artist can skillfully compose a deeper, abstractly realistic portrayal of a tree, evoking what a tree truly is beyond its mere appearance.

Similarly, Kirby 64 often elaborates on plain setpieces with abstraction. The clean grassy fields of Kirby’s home planet are littered with checkerboard boxes and green pyramids, not to depict literal objects but to simply evoke the sense of the planet itself. Later, there’s a delightful mall-like level consisting of vignette rooms, each of which clearly reflects a specific scene – a furniture shop, an electronics store, a storage room – using only what explicit features are necessary, with haphazard shapes filling in the rest.

Additionally, Impressionist paintings highlight their own artificiality; look closely and the individual brush strokes are laid bare, the hand of the artist manifested in the work. Impressionist paintings are in part a celebration of themselves, revelry in the craft and techniques that produced them.

Kirby 64 is no different in this regard. Kirby bounds and bounces past enemies who stretch and skew alongside him, with exaggerated animations that make clear the computation driving them but also express energy and joy with even simple movements. His attacks are huge and evocative, with flaming phoenixes and electrified boulders that clip through objects without a care. And, how does Kirby enter each stage? He and his friends huddle together in a plaid void, with a simple prop or two to evoke the theme of the world, and the sense of joy and adventure is palpable as he runs off-screen with a wave and a cheery “bye!”

Details are omitted or ignored because they don’t matter, and what remains is engineered to reflect an emotion, an essence. Kirby 64 is simply a cute, cheery game, and it is also a simply cute, simply cheery, simply gamey game. At every step, it is a distillation of the inherent joy of playing a game and having a good time, making every oversight, hardware limitation, or technical hiccup melt away.

I mean, can you even imagine Kirby with knees?

The post On Kirby 64 and Impressionism appeared first on Sketch House Games Blog.

I, a smart individual, exclusively wrote those old posts in the WordPress editor, so I have little record of most of them. I can probably reconstruct a lot of them from the images I had uploaded? As I recall, there was something on:

• Pokemon Dash’s use of its balloon microgame as a meaningful interruption of its core gameplay
• My distaste for the hybrid of pure and directed exploration in A Link to the Past
• The homogeneity of modern mainstream consoles, manifesting in the then-upcoming The World Ends With You remake
• An extremely concise synopsis of the Kingdom Hearts plot leading into KH3 (in hindsight, this turned out to be unnecessary as KH3 completely discarded the foundations built by the preceding games)
• An overview of Flags enums in C# and how to use them for RPG status effects
• I think something about how most RPGs use elemental types poorly, using Bahamut Lagoon as an example?
• There’s something in here about Mega Man Battle Network 3, but I have no idea what that would have been…
• Solvability and bounded creativity in simulation games
• Pokemon’s stagnation being its greatest asset
• An unfinished hypothetical Pokemon Red/Blue redesign by just swapping out which Pokemon are in the game

So, not a lot, but there are a couple things that I’m sure will come up in the future. I suppose I intend to pick up where I left off with that: a haphazard assortment of video game design essays with a little bit of coding thrown in and also just a lot of Pokemon, probably.

There’s gonna be a lot of Pokemon stuff.

Oh, and I guess I should learn some more HTML so I can make this look less like a template design. I should really do some web coding at some point, especially for the aforementioned Pokemon stuff…

The post What’s happening here? appeared first on Sketch House Games Blog.