This content is password protected. To view it please enter your password below:

Password:

We’re going to commandeer the “using” keyword for something it wasn’t originally designed for but which is a 100% legal use of it.

Have you ever needed to do this in C#?

In Unity there are some very common examples of this problem, most famously in the old GUI.* API (which is finally, slowly, being replaced by UIToolkit – but there’s a lot of GUI.* code still in live games).

GUILayout.BeginVertical();
GUILayout.Label( "Options" );
if( GUI.Button( "Option1" ) )
{
   Process1();
}
if( GUI.Button( "Option2" ) )
{
   Process 2();
}
GUILayout.BeginHorizontal();
GUILayout.Space( 20 );
GUILayout.BeginHorizontal();
GUILayout.Label( "[advanced]" );
if( GUILayout.Button( "Option3" ) )
{
   Process3();
}
... and now I have to remember which order to EndHorizontal, EndVertical, and how many times for each

This is a very simple example and yet already it’s both timeconsuming to type all those “GUI.EndHorizontal/EndVertical” (the IDE cannot autocomplete them for you because it has no idea what you want here) and also highly error-prone.

Problems: Code together … but apart

It’s annoying trying to remember all the bits you’ve Begin’d but not yet End’d, but the real problem comes when you need to edit that code, inserting another piece of embedded horizontal layout halfway down.

Or when you copy/past a chunk of it and try to re-use it elsewhere.

You might try to be smart and move this stuff to a method call, but … that quick becomes painful for two reasons:

1. You need to generate method calls and insert them in your sourcecode based on context. You can do that, but now you’re having to pass-around functionpointers, it’s no longer a simple method.
2. You don’t know which order they’ll happen in, or how many times, so now you also need to create a stack object to keep track of this. You also have to implement all the cases of Exceptions etc and making sure the stack unwindws correctly, and … and …

Solution: IDisposable / using{}

C# has a nice little feature that fixes all of this. It converts my code above into:

using( new Vertical() )
{
   GUILayout.Label( "Options" );
   if( GUI.Button( "Option1" ) )
   {
      Process1();
   }
   if( GUI.Button( "Option2" ) )
   {
      Process 2();
   }
   using( new Horizontal() );
   {
      GUILayout.Space( 20 );
      using( new Horizontal() );
      {
         GUILayout.Label( "[advanced]" );
         if( GUILayout.Button( "Option3" ) )
         {
            Process3();
         }
      }
   }
}

Two things have happened here:

• Improvement 1: We never have to remember to End() anything!
• Improvement 2: All code is now surrounded in {braces} making it much easier to read, and to edit safely!

Both of them are side-effects of IDisposable/using.

How to implement it

You have to create a class that holds the magic code. In the GUILayout.BeginHorizontal example I made a class “Horizontal”. This class has to implement Microsoft’s IDisposable interface – and there’s plenty of docs online for how to do this, it’s quite easy. Here’s a simple example:

class Horizontal : System.IDisposable
{
   public Horizontal()
   {
      GUILayout.BeginHorizontal();
   }

   public void Dispose() // but read WARNING below
   {
      GUILayout.EndHorizontal();
   }
}

The way that “using” is implemented by Microsoft is:

1. The object is created as normal (when you call ‘new’ in “using( new Horizontal();”)
2. The code in braces runs as normal
3. When the close brace is encountered, MS destroys the temporary object you created
4. …which has the side effect of calling “Dispose” on that object
5. All of this is managed for you, and copes well with exceptions etc

WARNING: the simple example isn’t quite correct

If you subclass your Horizontal object this may start to go wrong because of how Dispose works. This is documented on MS’s official pages, but the simple explanation is that “Dispose” can be called more than once on the same object (when they’re subclassed), so you need to add some code to ignore the extra calls. Here’s the classic example:

class Horizontal : System.IDisposable
{
   public Horizontal()
   {
      GUILayout.BeginHorizontal();
   }

   public void Dispose() // perfect example
   {
      Dispose(true);
      GC.SuppressFinalize(this);   
   }
   protected virtual void Dispose(bool disposing)
   {
      if (!_disposed)
      {
        if (disposing) 
        {
            GUILayout.EndHorizontal();
        }

        // Indicate that the instance has been disposed.
        _disposed = true;   
      }
   }
}

Performance optimization: ZERO garbage-collection!

If you care about performance then you typically want to make your core methods non-allocating. Creating temporary objects like in the above examples has no effect most of the time – but if you ever use it on a core method that you call tens of thousands of times a frame (note: anything less than tens of thousands and you probably won’t notice, unless your game is very performance-heavy) it’ll start to create enough garbage that GC becomes a problem.

We can fix that, and get rid of the double-dispose problem, by converting it to a struct.

Unfortunately … C# doesn’t allow structs to have a zero-argument constructor, so we have to add at least one fake parameter to make this work. In most cases there’s some obvious parameter you can think of that improves your implementation. e.g. here I’ve added the same optional param that GUI.BeginHorizontal has:

struct Horizontal : System.IDisposable
{
   public Horizontal( params GUILayoutOption[] options )
   {
      GUILayout.BeginHorizontal( options );
   }

   public void Dispose() // but reading WARNING below
   {
      GUILayout.EndHorizontal();
   }
}

• We want to use jupyter-lab instead of the legacy jupyter-notebook
• The notebooks/labs must be private, it’s absurd to think otherwise
• We want online / cloud access to our work
• We want the minimum of effort to install and get working with Jupyter
• We want the minimum complexity to maintain the installation

Core investigations + conclusions

Hosting: Use AWS

I researched many sources of 3rd-party hosting for Jupyter and they all … well, sucked. There was a great article on free hosting – but all of those forced your private data to be placed in public for anyone/everyone to take.

I looked at the ones that had private “upgrades” available from their free/public tier, but they came with intensely complicated procedures (e.g. you lose access to all your data) and confusing and difficult pricing (mostly designed for ML programmers, but irrelevant to people not doing ML).

Finally I went through the most widely-referenced “Jupyter hosting” companies I found via Google and forums posts and reddit etc etc. Some of these looked good, but nearly all of them were running either legacy Jupyter (which was superceded 2 years ago!) or their own custom “this isn’t jupyter, it’s a thing-that-is-a-bit-like-jupyter, missing core features, with our own proprietary changes” which is undesirable. Poster-child there was Google who – yet again – created a pointlessly proprietary system that you’re locked into, and which has a high probabilty Google will shut it down and delete all your data with no upgrade option (as they are currently doing multiple times a year :)).

Eventually I came back to self-hosting: how hard would this be? There are multiple guides on this, both from 3rd parties (some of them broken/incorrect with key steps missing) and from the official Jupyter website. Custom instructions were provided for AWS which was a good sign (along with GCE, Microsoft cloud, etc) Reading through the instructions they were essentially:

“Steps 1-20: Setup a new AWS default cloud instance (identical to all AWS hosting.
Steps 21-25: Do a couple of Jupyter-specific post-install steps”

…with the vast majority of the setup work being AWS (which isn’t a great install process, but if you’ve used AWS you’ve already done this many many times and are comfortable with it), self-hosting seemed the best way forwards.

AWS: tiers and options

Confusingly there’s two branches of Jupyter self-hosting: Jupyter and JupyterHub. The latter is a multi-users-working-on-one-machine with each having their own loing username and personal password, with private or semi-private notebooks etc. For myself as a single user that was overkill – although the install instructions were even simpler than the main Jupyter (ironically).

None of the install guides were detailed (or useful) in their advice on picking an AWS instance, apart from the JupyterHub one. With some digging on reddit it turns out that 100MB or so of RAM should be more than enough for running notebooks, with “as much more as the size of data you intend to hold in RAM”. If you’re coding very lazily you might try loading massive source data into RAM but … we’re sensible programmers, we don’t do that.

Summary: The smallest AWS instance - t2.nano - works fine with 0.5GB RAM, and the (2020) minimum EBS disk of 8GB SSD.

(If you hit the RAM limit: spin down your AWS instance, replace it with a t2.micro, attach the EBS to the new AWS, then spin it up again. This is exactly what cloud hosting was invented for! It’s easy, so no need to worry about it here)

UPDATE:

Jupyter doesn’t need much RAM.

But node.js – which a lot of UI-related Jupyter plygins rely on – requires gigabytes of RAM to work at all, and it crashes with useless error messages rather than handle its own errors.

It’s quite eye-opening how bad node.js code is (I believe this isn’t node.js itself, rather it’s an ecosystem and habits of people who write node.js apps – there’s nothing wrong with their choices, but they’ve prioritised embedding other people’s code they don’t understand (and mostly don’t need) rather than spend a few minutes writing simple code themselves. The net result is that if you want to install (or even reconfigure :() any of the JavaScript related plugins (which is all of the UI ones) then you’ll need to temporarily boost your AWS instance to a larger instance each time, and then downgrade it after the upgrade. 2GB RAM is recommended for node.js. To be clear: for actually using Jupyter, 200MB is more than enough – i.e. node.js alone requires 10x as much RAM as the entire system you’re running!

AWS install summary

If you’ve created EC2 instances before, the short version here is:

• A small EC2 instance
• Running standard ubuntu (18.04 or 20.04 as of this writing)
• A security-group which unblocks SSH (for manual install tasks) + one port (for web access)

Traditionally a lot of people unblock port 8888 but there appears to be no reason for this other than installation being done by people who don’t really know what they’re doing with web server configs. A bit like the node.js setup – people copying random pieces of instructions without actually reading them. In months of usage, I’ve found no ports need to be unblocked (why create a security hole when you don’t need to?).

Jupyter initial install

Installing Jupyter core is straightforward … and broken in ubuntu 18.04 (the main ubuntu release when I did this in early 2020, unless you’ve upgraded to 20.04 already). By default it will fail to install – this appears to involve known bugs, but the workarounds are so quick to do that no-one is in a rush to fix it. I’m assuming that in ubuntu 20.04 it’s been fixed.

Step 1: Update Ubuntu

Do your apt updates etc (I prefer to use aptitude for all apt management so I can see what’s happening and make more informed choices about versions etc – for me it’s hitting ‘u’ and let aptitude do it automatically).

Step 2: install jupyter

The apt is named ‘jupyter’ and should automatically bring in all the required modules, python3, pip, etc. It should also setup a basic install of jupyter with Python notebooks enabled etc. The magic of debian/apt!

Step 3: install the python parts of Jupyter (specifically: JupyterLab)

Here’s where it goes python-y and stops working. Unfortunately Ubuntu does not (yet) have an apt for JupyterLab that actually works – and it has to be installed over the top of a legacy Jupyter installation (that we already have thanks to parts 1 and 2).

What follows is all standard for python developers, nothing new. But if you’re not a python developer … You have to “install” jupyterlab by using python’s in-built self-management systems, which aren’t as good as the OS ones. No more apt for you :(. For extra pain: python wants you to jump through hoops to keep multiple copies of itself on the system – because the packages aren’t managed well enough for the OS to use python and for you to use it at the same time.

In my case: I have a dedicated server that is doing nothing but running Jupyter and I have no intention of upgrading python on one without upgrading the other. I was happy to use a single Python install, and avoid a lot of problems and confusion. Worst case if one does something weird in a future release I’ll simply wipe the server and re-install – we’re in the decades of commodity cloud computring, and re-installing OS’s in seconds, not hours.

In theory (from the docs), you run:

pip3 install jupyterlab

In practice, that:

• Installs it in a hidden folder buried inside the home-directory of the current user
• Fails to install it correctly: it cannot work
• Leaves a different version of Jupyter on the system that is missing the new features

FAIL. Maybe related to the expectation that you have multiple Python installs – but I wasn’t going to mess around with that added complexity only to discover that it was broken anyway (if it doesn’t work out of the box, I don’t trust it to work out of a more complex box…).

The nearest I found to an official workaround appears to be: update your linux user’s PATH to make it preferentially run the hidden-secret-silently-mis-installed version of Jupyter. Do that and everything appears to work fine. Or … just remember to always type

/home/ubuntu/.local/bin/jupyter

everywhere that you would normally have typed:

jupyter

Step 4: configure jupyter to work correctly

Out of the box Jupyter won’t work on a server: it’s been deliberately designed to fail even if you correctly installed it (this is not a bad thing: it’s designed to be idiot-proof for people who install on their personal laptop). To make it run as a server you can either mess around wasting time doing ssh-tunneling (why? WHY??!! Why have so many online guides told people to do this? Blind leading the blind, it seems…).

…Or: you can simply enable the server mode :), which works fine and is easier to setup (and cleaner).

But at first: you cannot do that. Out of the box jupyter can’t even be configured: it’s missing it’s own config file. Fortunately it has a ‘feature’ where you can get it to auto-create the config file (why it doesn’t do this as part of installation I have no idea), but it’ll be placed somewhere super-annoying:

jupyter notebook --generate-config

…and helpfully it’ll immediately tell you where it created it, probably:

/home/ubuntu/.jupyter/jupyter_notebook_config.py

As per this stackoverflow answer (https://stackoverflow.com/a/43500232/153422) you only need to change two lines to enable server mode. One line allows server access, and the other says “listen on all IP addresses”. You can find the commented-out lines in the file and uncomment them + change their values, or you can just copy/paste the values from that SO answer into the bottom of the file.

While you’re there, it’s worth changing the default values / inserting:

c.NotebookApp.open_browser = False
c.NotebookApp.port = 8888 (whatever you unblocked in AWS security group)

Step 5: run Jupyter-lab and login for the first time

To run jupyter-lab you need something like this:

~/.local/bin/jupyter-lab

Three things now happen:

1. Jupyter is up and running and spits out lots of info to the command-line. Check it for errors – there shouldn’t be any
2. It specifically tells you which IP addresses it’s listening on.
3. It gives you a magic, temporary, token to login with.

The IP address list is wrong, but … at least it will show you that it’s listening to more than just localhost and 127.0.0.1 (if it’s only listening to them then you failed to edit the config properly).

It tries to guess the info using OS lookups, but they did it naively and they did it wrong: they will fetch private addresses that don’t exist, instead of the public ones. But if you’ve used AWS before you know how to get the public IP and/or public DNS from your EC2 management console (in AWS management console, select the EC2 instance, and click on the “Connect” button and you get a popup telling you exactly how).

So use the correct IP/DNS, go directly to that server / port address (ignore the ?token rubbish that the jupyter commandline app wanted you to use). You’ll get a login page where you can copy/paste the token from the commandline output and immediately login.

Or, better: jupyter’s login page helpfully gives you the option here to use the temporary token to generate a password you can use in future instead.

Step 6: Switch to TLS/HTTPS (make the web-browser connection secure)

Don’t self-sign, self-signing is being aggressively blocked by web-browser vendors (Google, Mozilla, Apple, etc) – again: ignore the bad advice and articles written by Jupyter users who don’t know what they’re doing. Instead use the free LetsEncrypt service for industry-standard automatically renewing signed certificates that you can fire-and-forget.

Follow the jupyter main docs directly:

https://jupyter-notebook.readthedocs.io/en/stable/public_server.html#using-lets-encrypt

Step 7 (final!): make Jupyter run as a service

This part shows how poorly this python app is integrated with the host OS – Jupyter doesn’t run as a service. You have to manually convert it into one.

Most people do this the brutally simple way: either run the command line with ampersand (i.e. linux’s “run-in-background but if you lose your ssh connection it might die”) or run it with ‘screen’ (linux’s more advanced multi-tasking app that makes it easy to re-access later and will survive even if you lose SSH connection or logout of ubuntu).

Much much better would be to convert it into a full ubuntu service – I googled the latest recommended instructions for this and followed them, but sadly I didn’t save the URL. It depends slightly whether you used new-style ubuntu (with systemd) or legacy (init) – but creating new ubuntu services is very common and quite easy to do so I’ll leave that for you to Google and find your preferred approach :).

CSS/Flexbox has a much better layout algorithm (and a free, open-source, speification that anyone can implement). In the Flexbox4Unity plugin, this works nicely, and auto-resizing / size-to-fit UIScrollviews just happen “for free”, every time, no problems. I’ve posted a guide for setting up UIScrollviews this way inside Unity: http://flexbox4unity.com/2020/04/08/guide-automatically-resize-uiscrollview/

http://t-machine.org/wp-content/uploads/UnityAssetStoreRevenues-Template.ods

Usage/setup instructions included on the first page (scroll down).

To fill in the data, I use a script that scrapes the Unity publisher portal. But for short periods of time, you can easily fill this in by hand. My script needs some cleanup before I share it – some recent changes to the Unity webpage broke it and I haven’t updated it yet.

But what about the Terrain itself? Unity 2019.2 and 2019.3 still have the ponderous old API and it seems we’re stuck with it for at least another few years. Today I found and fixed an issue in my custom Terrain-tools that took our Editor rendering from < 4 FPS back to normal realtime speeds.

The secret is to use Unity’s required float[,,] arrays (which Microsoft only partially supports in C#) but plug the gap in C# which causes them to be slow when interacting with Unity’s Serializer (which fires 6 times per frame in the Editor, magnifiying any slowdown considerably!)

NB: As far as I can tell, you cannot fix the Unity “serialize 6 times even if it’s not needed, where only 1 would have been fine” issue, because the methods to do that only exist on Custom EditorWindows, and not on Custom Inspectors. But it’s bad practice to be slowing-down the serializer anyway, so I’m happy with fixing MY code to run fast, and then stop worrying about the Unity Serialization layers being inefficient.

The problem: float[,,] isn’t supported by Unity

Unity requires you to use float[,,] for textures/splats/alphamaps on their terrain.

However, Unity has never supported multi-dimensional arrays in their engine (this is finally getting fixed sometime in 2020, I believe, with the new Serializer). So your data gets wiped every frame. Thats a pain when making Terrain-editing scripts.

The workaround is to implement Unity’s ISerializationCallbackReceiver interface, and provide the missing code that Unity doesn’t (i.e. serialize a float[,,]). The standard way of doing this is something like:

NB: I’m only showing half of the serialize/deserialize here, just to illustrate the point

[code language=”csharp”]
void ISerializationCallbackReceiver.OnAfterDeserialize()
{
deltas = new float[_Serialize_2D_Length0, _Serialize_2D_Length1, _Serialize_2D_Length2];

/** NB: iterate in C#’s internal storage order for [,,] */
for (int i0 = 0; i0 &lt; _Serialize_2D_Length0; i0++)
for (int i1 = 0; i1 &lt; _Serialize_2D_Length1; i1++)
for( int i2 = 0; i2 &lt; _Serialize_2D_Length2; i2++ )
deltas[i0,i1,i2] = _Serialize_1DArray[i0 * _Serialize_2D_Length1 * _Serialize_2D_Length2
+ i1 * _Serialize_2D_Length2
+ i2];
}
}
[/code]

…which retrieves every cell in the float[,,] from a cell in a private float[] (which Unity DOES support and will auto-serialize for you).

The problem is that C# for-loops are extremely slow when used like this, simply because of the scale of the operation. For a typical Unity terrain, you’re copying up to 4096 x 4096 samples (your splatmap) with anywhere from 5 to 10 values for each. Each value is a 4-byte 32-bit float.

i.e. 4k x 4k x 10 x 4 == 640 MB of data

…which destroys your 100+ FPS frame-time, taking it to 1 FPS or worse.

You need to copy this data in a single call, not in 640,000,000 separate method calls.

But … how?

Array.Copy() to the rescue!

It doesn’t work. You can compile your C# class, and then the C# runtime will cry when you try to execute it:

RankException: Only single dimension arrays are supported here.

Bummer. In theory, Array.Copy() would have solved the problem – this is literally what it was designed for: bulk copying of large arrays without the overhead of doing millions of tiny copy-calls.

Try again … Buffer.BlockCopy()

Fortunately there’s another method in C# core that steps-in and saves us. I often find that when C# ties your hands behind your back, the reason it hasn’t been changed/updated/improved is that there’s a lesser-known behind-the-scenes low-level method that you can (ab)use to achieve what you need, and the language maintainers recommend you do that instead of them updating the mainstream stuff. Fair enough!

The one caveat with BlockCopy is that you need to tell it the size in bytes that you’re copying NOT the number of array items.

i.e.: [code language=”csharp”]Array.Copy( from, 0, to, 0, length )[/code]
becomes: [code language=”csharp”]Buffer.BlockCopy( from, 0, to, 0, 4 * length ) // if copying float, or int, or any of the other 32bit primitives[/code]

20x faster Terrain data handling

The modified serialization callback becomes:

[code language=”csharp”]
void ISerializationCallbackReceiver.OnAfterDeserialize()
{
deltas = new float[_Serialize_2D_Length0, _Serialize_2D_Length1, _Serialize_2D_Length2];

int bytesPerFloat = 4;
Buffer.BlockCopy( _Serialize_2D, 0, deltas, 0, bytesPerFloat * deltas.GetLength( 0 ) * deltas.GetLength( 1 )*deltas.GetLength( 2 ) );
}
}
[/code]

But Unity still struggles to figure out what it should look like and how it should work for users/purchasers. The raw content is the biggest determinant of the store’s success, but closely followed by the browsing and discovery experience – which have hardly improved at all (and in some ways have gone backwards) over this past decade.

Based on hundreds of purchases, and having launched and maintained some small assets on the store myself over the past 5 years, here’s what I’d like to see now.

The A-test for Unity Assets

Every asset-purchase page should have a section that answers the critical, machine-answerable, fully 100% automatable questions that matter to purchasers. There is no excuse to miss this out – these make a huge difference both to users, and to authors, and to Unity itself: they massively reduce the amount of refund requests, and increase the purchase volume due to increased buyer-confidence.

How well do your assets score on these? If you’re an author, do you publish all this information up-front (some do – their Full Description on the asset page is long and scrolly)

Art Assets

• Min/avg/max verts per model in package
• Top 3 shaders in package, with number of models that use each
• Min/avg/max texture sizes in package
• Total number of materials with unassigned textures/colors vs fully assigned
• Total number of materials using Standard shader with Albedo, Metallic, Normal, Roughness maps assigned
• Total number of models with LODs vs number of models without LODs
• Min/Max LOD levels for models with at least one LOD
• Number of prefabs in package that have same prefix-name as an FBX/model file

Code Assets

• Number of files that include source code (C#) vs number without source code
• Number of (Unity official) Unit-tests in package
• (one line for each Unity version): Num Errors, Num Warnings, when installing the project
• (one line for each Unity version): Num Errors, Num Warnings, when opening the marked demo-scene
• (one line for each Unity version): Num Errors, Num Warnings, when pressing play in the marked demo-scene
• (one line for each Unity version): Number of Unit tests passed, number failed

All Assets

• Number of demo scenes in package
• PDF documentation in package
• Time since Author’s last edit of package (upload)
• Time since Author’s last discussion of package (meta files + comment threads)

Self-reported / author-tagged info

All the above was easily automatable by Unity (Apart from “issue reports”, which Unity keeps private, I’ve written scripts myself that do all of them!)

What happens when we extend the Asset Store Publisher Upload tool to let authors add extra info that Unity can then collate and publish? Well…

Art Assets – author controlled

• Render-pipelines supported: Default?, URP?, HDRP? (tickboxes)
• Player platforms compatible: Windows, PS, XB, VR, iOS, Android, WebGL (tickboxes: “compatible” means “author expects it to work, but isn’t actively testing that platform – it may not work out of the box”)
• Player platforms supported: Windows, PS, XB, VR, iOS, Android, WebGL (tickboxes: “supported” means “author actively tests on this platform and promises it will work out of the box (or fixed very rapidly)”)

Nice-to-have’s only Unity can provide

• Ask-the-author question box on purchase page (SO MANY TIMES people need to check if an asset supports X or Y, or ask the author if they include something, and Unity still provides no way for the purchaser to do this)
  …with answered-questions automatically appearing for all to see (just like Amazon has done for the past 15+ years)
• Number of reported issues per Unity version (OR: star-rating per unity version)
• Number of refund requests (successful + unsuccessful) by Unity version and/or package version

2020 future-looking awesome “make everyone rich” features

• When author uploads the asset, choose a Demo scene that will be auto-built as a WebGL build and embedded in Asset Store page (if build succeeds)

e.g. I tried to take a screenshot of an app that I needed for a receipt for expenses – and the app’s authors had blocked all screenshots on all parts of their app. They used a Google-sanctioned feature of the OS because, it seems, they are afraid of competitors “copying” their graphical design. I ended up having to use a second phone to photo my screen [Facepalm]. (Google’s attitude with Android seems to be crystallising around: You do not own your phone; we own your phone).

e.g. This week I arrived an hour early for a meeting because the Android version of Google Calendar got confused over timezones (again). (I now write the TIME for every meeting in the title of the meeting if it’s been put in Google Calendar, but when other people create the meeting I don’t always have edit access.

(Which is a strange flaw in gCal: it’s in my calendar, my personal/private calendar, but I’m not allowed to edit, fix, change, or annotate it. I tried recently with one, and it sent an email to the organizer saying I’d cancelled their meeting (after it had already sent one saying I’d accepted the meeting) – and Google didn’t inform me, didn’t give a warning, didn’t give a popup, didn’t email me. I got a panicked reply from the organizer asking why I’d cancelled at the last minute (I hadn’t cancelled it – Google inferred that!). None of this seems to happen with corporate G-Suite, but it seems the personal/mobile edition of Google Calendar is still buggy.)

e.g. today someone asked “how to get rid of the annoying alarm clock icon that WILL NOT GO AWAY!” on Android.

It turns out Google allows apps to put icons in the notifications bar, but doesn’t require there to be notification … giving the user no way to know which app put it there, or why. There are dozens of forum threads about people begging for help getting rid of the icon. e.g. even as recent as the Pixel: https://support.google.com/pixelphone/thread/1448787?hl=en. The solution is “simple”: open every single app on your device, go through every possible screen, and hope that you find one that has an alarm set (Although it might not call it that!).

Hmm.

• MariaDB’s supporters put a nasty little poison-pill into the Debian OS that blocks MySQL DBs from working once triggered, to try and force everyone onto Maria.
• My online backup setup couldn’t cope with the > 1GB of images + videos I had embedded in this blog over the years, so I was manually doing full backups of images every year or so.
• In an emergency (needed a particular version of OS X to run something for work, at very short notice) I wiped the hard drive with my local backup of images.

MariaDB’s poison-pill damaged the OS so badly that I had to do a complete wipe + re-install the OS. I couldn’t unfuck the packages. I had complete backups of all configuration, and recent backups of the DB contents (although I lost about 5 or 10 blog posts, spread across my various blogs, maybe 2 or 3 each). Maria refuses to come online with the fully up-to-date backups I had from MySQL (double yay for how crappy this Maria thing is … although this is an inherited bug from MySQL itself, it’s always had major problems with restoring databases by any means other than text dump, which in my haste I forgot), and after a few days of work, I gave up trying to fix it.

The last two items were temporary hiccups (I was in the process of setting up and testing a new multi-gigabyte backup system when I ran the automatic update for Debian). The first item, the root cause of what happened … my opinions there are quite salty. Yay for politics in OpenSource being more important than preserving users’ data!

(the poison-pill was a virtual package that if you tried to do upgrades to MySQL would insert itself and break your OS’s packages. The idea appears to have been: “Many people won’t realise that MySQL is no longer politically free, and is now owned by Oracle, and that the MySQL original team have abandoned it to make a new rival! So … let’s stop people from accidentally continuing to use Oracle-owned software!”.

In principle, I agree with that idea: I hadn’t noticed the spat in MySQL world, and was only vaguely aware of MariaDB. It was good to be informed that something odd was going on in MySQL. HOWEVER … their choice of a dangerous and ultimately (in my case, at least) destructive bomb in the OS was extremely bad form, and frankly unforgivable: it violates one of the basic trusts of Debian, built up over decades.

Incidentally … a spat that I have noticed is the splintering of Debian, with a substantial bunch of the maintainers dumping it and making a “new” Debian thing that’s supposedly true to Debian’s roots. That upset me, but switching was going to be very expensive (I’ve investigated it a couple of times). However, the Maria incident strikes me as exactly the kind of “screw Debian’s reputation; let’s abuse our influence!” attitude that those guys were complaining about. I guess it’s time to more aggressively dump Debian – certainly for all new installs!

Don’t you just hate it when people come along and shit on the shoulders of giants? :)

Unfortunately, no-one has documented SetMesh, and it has significant bugs, and breaks with core Unity conventions. This makes it rather difficult to use. Here’s the docs I’ve worked out by trial and error…

CanvasRenderer.SetMesh

The minimum for this method to work is:

1. A Canvas in mode “Screenspace: Camera”
2. A child object with:
   1. A mesh (that must be hundreds of meters wide/tall)
   2. A material (see below. Not optional!)
   3. A CanvasRenderer

Usage

Mesh bounds are ignored; if CanvasRenderer had been designed to render meshes to canvases, it would use this method – but as noted above, I believe it was designed for something completely different: it’s a low-level helped method rathe than a user-facing API method.

Instead, your mesh will be rendered at the Canvas’s own pixels/meter scaling (a scale of 1 meter = 1 pixel by default). In the Editor, this will make it appear very large, but it will render correctly on your cameras.

Current bugs

CanvasRenderer frequently deletes the mesh, but has no method (public or private) to detect when the Mesh has been deleted so you can re-create it. It deletes when you enter or exit play mode, but after that it seems to leave it alone. There is a hidden delegate inside the class that appears to let you react to this – but it’s not public and I don’t know how to use it (yet).

Unlike all rendering elsewhere in Unity, if there is no material, this method will silently fail, and will NOT render a magenta object. This makes debugging misleading and difficult.

In “Screenspace: Overlay” mode it seems to be broken; not only does nothing render, but it doesn’t even render in the Editor, suggesting to me that it’s disabled. I couldn’t find a combination that worked.

You cannot set/add a material to this object using standard Unity approach, instead you must first alter the value of materialCount to the number of materials you intend to have on the mesh, or it will crash. The docs tell you to use a non-existent method – don’t worry, simply alter the property directly (this works).

EnableRectClipping doesn’t work at all – this is a serious problem if you’re using this method to draw 3D objects inside a 2D layout-managed GUI. As mentioned above, I think it was either never intended to be used, or there was a mixup and people forgot that it’s a low-level method, and not an API method.

If there were one internal class/method/field in the UnityEditor namespace you would want exposed properly, what would it be? #unity3d

— Shawn White (@ShawnWhite) June 29, 2016

We only get to pick ONE? :).

How do we decide?

There’s two ways to slice this. There’s “private APIs that would hugely benefit us / our projects / everyone’s projects / 3rd party code that I use (e.g. other people’s Asset Store plugins I buy/use)”. We can judge that largely by looking at what private API’s I’ve hacked access to, or decompiled, or rewritten from scratch.

Then there’s “what CAN’T I access / hack / replace?”. That’s a harder question, but leads to the truly massive wins, I suspect.

Stuff I’ve hacked access to

The Project/Hierarchy/Scene/Inspector panels

So, for instance, I made this (free) little editor extension that lets you create new things (scripts, materials, … folders) from the keyboard, instead of having to click tiny buttons every time.

There are no public API’s for this; that’s a tragedy. Most of these Unity panels haven’t been improved for many years, and are a long way behind the standard with Unity’s other improvements. They “work”, but don’t “shine”.

What could I do with this?

Well … a few studios I know have completely rewritten the Scene Hierarchy panel, so that:

• it does colour-coding of the names of each gameobject
• clicking a prefab selects both the prefab and any related prefabs, or vice versa, or hilights them
• added (obvious) new right-click options that are missing from default Unity Editor
• automated some of the major problems in Unity’s idea of “parenting” (parenting isn’t always safe to do; you can enforce / protect this with a custom scene hierarchy)
• made it put an “error” icon next to each gameobject that is affected by a current error.
• …etc

All massively useful stuff that helps hour-to-hour development, reducing dev time and cost.

It’s all “possible” right now by writing lots of horribly ugly and longwinded boilerplae code, and using the antiquated Editor GUI API.

But to make it play nicely with the rest of Unity requires also hacking Unity API’s for the various panels/windows, and detecting popups (and adding your own popup classes, since Unity keeps most of theirs private), and detecting drags that started in one panel but moved to another, detecting context-sensitive stuff that is not exposed by current API’s, … etc.

A better List editor

The built-in sub-editor (like a PropertyDrawer – see below) is very basic – really a “version 0.1” interface.

There is a much nicer one, that does what most Unity developers need – but it’s private and buggy (last time I tried, it corrupted underlying data. That’s presumably why it’s still private?)

@ShawnWhite The re-orderable, nicely rendered, editable List. (but @AngryAnt's is definitely a top-3 too)

— Adam Martin (@t_machine_org) June 30, 2016

Editor co-routines

Co-routines work perfectly in the Editor. (EDIT: thanks to ShawnWhite for the info): Unity doesn’t use co-routines outside of runtime; what appears to use them is OS-provided multi-threading. Strangely, when using that, I haven’t seen any of Unity’s ERRORs that are usually triggered by accessing the Unity not-threadsafe code from other threads – something weird happening in the OS?

Why doesn’t Unity support co-routines in the Editor?

I’ve no idea. There are many people who’ve re-implemented co-routines in editor, exactly as per Unity’s runtime co-routines. As a bonus, you end up with a much better co-routine: you can fix the missing features. But there’s some strange edge-cases, e.g. when Unity is reloading assemblies (which it does every time you save any source file), for a few seconds it presents a corrupt data view to any running code, and you if start running a co-routine in that time, it will do some very odd things.

Unity recently exposed some API’s to detect if Unity was in the middle of those reloads, but last time I tried it I couldn’t 100% reliably avoid them. An official implementation of Unity’s own co-routine code, that was automatically paused by Unity’s own reload-script code, would neatly fix this.

Until we have something like that, we’re forced to write two copies of every algorithm (C# doesn’t allow co-routine code to be run as a non-co-routine) so we can test in Editor, do level editing, debug and improve runtime features, etc … which is silly.

Stuff I CANNOT hack into/around

Serialization

Unity is the only engine I’ve worked with where the core data structures and transformations are opaque, hidden, can’t be extended, can’t be debugged. Tragically: also has many missing features, bugs, and serious performance issues.

There are good reasons for why this remains in such a bad state (It’s hard to fix. Meanwhile … it sort-of works, enough to write games in – you just have to occasionally write a lot of bad code, have to rewrite some ported libraries, have to know a lot of Unity-specific voodoo, etc).

But if it were exposed – we could (I would start on it tomorrow!) fix most of the problems. I’ve done proof-of-concepts with some terrifying hackery that show it’s possible – and a lot of the architecture is well explored, other ways it can be implemented, that could be given to developers as options (some would work better for your game, others might not; but you could pick and choose).

It’s too much to ask for (it intersects so much of the engine, and it would unleash a horror of potential bugs and crashes), but my number 1:

@AngryAnt @ShawnWhite **No. 1**: (but I know we won't get it ;)) Serialization. No more opaqued, invisible, non-extensible, broken types…

— Adam Martin (@t_machine_org) June 30, 2016

Callbacks for ALL core Unity methods

This sounds small but would have positive impact on a lot of projects.

c.f. my reverse-engineered callback diagram for EditorWindow in Unity:

…but we have the same problems for MonoBehaviour, for GameObject, etc. Not only are lifecycles poorly documented, but they’re inconsistent and – in multiple places (c.f. above diagram “Open Different Scene”) – they’re not even deterministic! It’s random what methods the Editor will call at all, let alone “when”.

Under the hood there must be reliable points for doing these callbacks … somewhere.

Undo

Undo has never worked in Unity. The worst stuff I narrowed down to ultra-simple demos that Unity’s own code was broken, I’ve logged bugs and Unity fixed them – but the current system is a horrible mess, much too hard to use. Many methods only randomly do what they’re supposed to, and there’s no way to debug it, because the internals are hidden.

If Unity exposed the actual, genuine, underlying state-change points, we could correctly implement editor extensions that support Undo 100%. I’d be happy to also use them to write an Asset that implements “easy to use Undo”, based on how other platforms have implemented it (e.g. Apple’s design of NSDocument is pretty clear and sensible, based on lists of Change Events).

Unity could then make “Undo that works” a mandatory requirement on the Asset Store. Currently it’s listed as mandatory, but no Asset has ever been checked for it (so far as I can tell).

Not least because Unity’s own code has had such problems supporting it!

PropertyDrawer: doesn’t quite do what it claims to (yet)

Recall what I said above: most of the Editor GUI/UX itself “hasn’t been improved for many years”. Unity made it user-extensible/replaceable many years ago – so in theory you could update / replace whatever you want. There’s a huge amount we’ve been able to update and customise (although it’s very expensive in coding time, due to a lack of modern GUI API’s, sometimes it’s well worth it).

But you can only replace the Inspector for a particular Component/MonoBehaviour. You cannot say “I want to replace the Inspector for GameObject’s that have Components X Y Z”.

Worse, if you wanted to replace e.g. the part of the Inspector that automatically draws a Vector … you can’t.

Unity had a great idea to solve one of these: Property Drawers. These would let you customise the rendering of sub-parts of an Inspector – the rendering of individual labels for member variables, list items etc.

IN THEORY this would let you write your own list-renderer that would work everywhere, and make lists very easy to use in the Editor – but only write the code once.

IN PRACTICE it was only implemented in a very basic way, and most of the things you want to use it for are blocked / inactive. There is NO WAY to fix this in user code.

(well, actually there is … c.f. . But this is a horrendous amount of work – AI’s author did a Herculean task! – and means you’ll never the benefit of future Unity UX / GUI updates, if there are any).

@ShawnWhite Inheriting / extending built-in editors and drawers.

— Emil Johansen (@AngryAnt) June 29, 2016

Oh dear. All sites offline. First:

Unable to connect

…then, when I fixed Apache, I got:

“Your PHP installation appears to be missing the MySQL extension which is required by WordPress.”

What happened, and how do I fix it?

Apache 2.4 upgrade is a bit dodgy in Debian

The Powers That Be decided to mess around with core parts of the config files. The right thing to do would have been to add some interactive part in the upgrade script that said: “By the way, I’ve made all your websites broken and inaccessible, because they need to be in a new subfolder. Shall I move them for you?”

Here’s the reason and the quick-fix too

Apache 2.4 brings in PHP 7.0, replacing PHP 5

PHP 5 is old, very old. Historically, PHP has also been managed in a fairly shoddy manner, very cavalier with regards to upgrades, compatibility, safety, security.

So … the standard way to run PHP is to have a separate folder on your server for each “version” of PHP. Everyone does this; PHP is so crappy that you have little alternative.

But this also means that when Debian “upgrades” to PHP7, there is no warning that the new config file – speciic to PHP7 – has been created and ignores the existing config file

This is wrong in all ways, but it’s forced upon linux user by the crapness of PHP. If PHP weren’t so crap, we’d have a single global PHP config file – /etc/php/config.ini – and maybe small override files per version. But nooooooo – can’t do that! PHP is far too crap.

(did I say PHP is crap yet? Decent language, great for what it was meant for – but the (mis)management over the years is truckloads of #facepalm)

So, instead, you need to copy your PHP5 ini over the top of your PHP 7 ini – or at least “diff” them, find the things that are “off by default” in PHP 7 but must be “on” … e.g. MySQL!

Enable them, e.g. change this:

[bash]
;extension=php_mysqli.dll
[/bash]

to this:

[bash]
extension=php_mysqli.dll
[/bash]

…and restart Apache. Suddenly WordPress is back online!

[bash]
/etc/init.d/apache2 restart
[/bash]

1. Copy/paste this into your functions.php (TODO: convert it to a standalone php file, and make it into a plygin you can activte/deactivate)
2. Create a new menu item of type “custom URL”
3. Make your URL “http://#latestpost:category_name”
   • where “category_name” is the name of the category whose latest post you want to link to
4. Make the name whatver you want to appear on the menu
5. Profit!

Based on an idea (with some upgrading + bugfixes for latest WordPress in 2016) from http://www.viper007bond.com/2011/09/20/code-snippet-add-a-link-to-latest-post-to-wordpress-nav-menu/

[php]
/** Adam: add support for putting ‘latest post in category X’ to menu: */
// Front end only, don’t hack on the settings page
if ( ! is_admin() ) {
// Hook in early to modify the menu
// This is before the CSS "selected" classes are calculated
add_filter( ‘wp_get_nav_menu_items’, ‘replace_placeholder_nav_menu_item_with_latest_post’, 10, 3 );
}

// Replaces a custom URL placeholder with the URL to the latest post
function replace_placeholder_nav_menu_item_with_latest_post( $items, $menu, $args ) {

$key = ‘http://#latestpost:’;

// Loop through the menu items looking for placeholder(s)
foreach ( $items as $item ) {

// Is this the placeholder we’re looking for?
if ( 0 === strpos( $item->url, $key ) )
{

$catname = substr( $item->url, strlen($key) );
// Get the latest post
$latestpost = get_posts( array(
‘posts_per_page’ => 1,
‘category_name’ => $catname
) );

if ( empty( $latestpost ) )
continue;

// Replace the placeholder with the real URL
$item->url = get_permalink( $latestpost[0]->ID );
}
}

// Return the modified (or maybe unmodified) menu items array
return $items;
}
[/php]

The author has disappeared, and his website has been taken over by scammers (not even going to link it), but the community has kept going the SourceForge-hosted copy of the source and continues to update it. The files are ordered confusingly (inherited from previous projects, and Civ4 itself, which was mainly shipped as a commercial game, not as a moddable game!). Here’s a few key links to find interesting / useful game-design gems:

• Folder with the XML files from community’s updated Civs, Techs, Units — all the game stats
• Folder with all the C/C++ source code (only needed for major game-changing mod features)
• Folder with most/all the custom Python scripts for the MoM civilizations (i.e. where 95% of Master of Mana is implemented)
• Base definitions of all the customized Civilizations (Their starting techs, their heroes, the units they start with, which units they can/cannot build or have special versions of, etc)
• Definitions of all the special buildable city-buildings in the game

Pros and cons

• Centers gives you STRAIGHT things (on a hex grid, it’s the only way to get straights!)
  • Roman Roads
  • Canals
  • Large rivers
• Edges gives you meandering things (on a hex grid, centers only give wiggles at very large scale)
  • River valleys
  • Realistic medieval roads
  • Modern roads in mountains and hills (tend to wiggle crazily)
• Movement is simplified with centers: If you’re on the tile, you’re on the road/river
• Inhibition of movement is simplified with edges: Civilization games have traditionally given a move penalty AND a combat penalty to any tile-to-tile move that crosses an edge containing a river

My leanings…

One thing in particular that struck me from looking at the pictures:

Straight roads look so terrible that every single Civilization game since Civ1 has artifically wiggled them when rendering!

In particular, with 3D games (Civ4, Civ5 especially) this actively damages gameplay – it’s much too hard for the player to see at a glance which tiles are connected by roads, and to what extent. So much so that they cry-out for a “disable the wiggling effect on road-rendering” setting.

Also: I’m happpy to solve the “movement” problem by saying that if you’re in a tile that borders a road or a river, you are assumed to be “on” that road/river, with special-case handling under the hood that handles cases where two roads/rivers border the same tile. It increases the connectedness “for free” – but that’s how Civ games tend to do it anyway: encourage the player to put roads everywhere!

Thoughts on a postcard…

Warnings are very, very important in any compiled language: they tell you that the computer has checked your code and realised you “probably” created a bug; they even tell you something about what the bug might be.

..but the computer isn’t sure – if it could be sure, it would be a compiler Error (in red). So (in Unity) it’s yellow, and “optional”. But in those cases where it’s not a bug – and you know it! – it’s very annoying. Most IDE’s let you turn them on and off, Unity doesn’t … here’s how to fix it.

NB: the global Disable technique can be used for a lot more, e.g. custom project-wide #defines – more info here: Unity Forum thread on SMCS etc

Check you really want to do this

If you know what you’re doing with compiler warnings, skip this section.

Everyone else: think carefully. A warning usually means one of the following:

• You have a half-written class/algorithm you’re still working on, so there are bits of unused code, etc. NOT A BUG.
• You’re using the programming language in an unusual way. MIGHT BE A BUG
  1. If the abuse is accidental: PROBABLY A BUG
  2. If the abuse is deliberate, expert-level: NOT A BUG
• You typo’d a variable name, but accidentally wrote the name of a different variable. SERIOUS, MAJOR BUG

(especially note that last one: this is the worst kind of bug, one which you can look at 100 times and never see anything “wrong”, and which the computer will say is syntactically correct!)

So … even though many warnings are “wrong” (there’s no bug, and you know it), many of them are “right” and are your last line of defence against some of the nastiest bugs. Treat every warning on a case-by-case basis!

Option 1: Disable a warning EVERYWHERE

As an experienced C/C++/etc programmer, this is most useful to me. I write code like this:

[csharp]
public void MethodBlah( int param )
{
if( param < 1 )
; // PopupDialog( "Spammy in-game message I want when debugging this algorithm" );
else
{
// …
}
}
[/csharp]

In line 4, the shorthand “; //” lets you enable/disable a line of code with 4 keystrokes, using a built-in feature of C and all C-based languages. With modern IDE’s, there are usually better ways of doing this, but this serves as a small practical example.

This triggers a warning in Unity console:

In this case, we want to disable it EVERYWHERE; it’s a deliberate technique I’m using, so I don’t need (or want) the warning. I thought about consequences of the warning: it’s afraid you accidentally put a semi-colon on the same line as the “if” statement. It’s been almost 15 years since I last made that mistake; I’m confident I won’t make it again any time soon.

1. Create a file “smcs.rsp”
2. Save it in the Assets folder of your project
3. Put one line per warning you want to suppress (see below)
4. Modify any source file, and Unity will live reload and honour your new setting

Contents of smcs.rsp:

-nowarn: 1234

“1234” has to be the number that appeared in the Warning message in Unity console – in my case, at the end we have:

…so I put in my file:

-nowarn:0642

NB: this only works for game-scripts. To do the same for Editor scripts, you use a different file – gmcs.rsp

Option2: Disable a warning in ONE FILE only

For instance … you’re working on a new game-feature, and tweaking it. You have a bunch of variables you are tweaking, sometimes using them in the code, sometimes not. You get this annoying warning:

…for this ONE FILE ONLY, you want to ignore that particular warning. When you’ve finished your long tweaking sessions, you’ll re-instate that warning.

1. Go to the very top of your file
2. Add one #pragma line for each warning you want to disable (see below)

#pragma warning disable 1234

…again, the number is whatever number appeared in the Unity console after the letters “CS”. In my case: 0219

Option 3: Disable a warning for a SINGLE LINE OF CODE

(…or for a block of code)

This works the same as Option 2, except:

1. Find the line(s) you want to ignore the warning(s) in
2. Before the first line, add one #pragma warning disable for each warning
3. After the last line, add one #pragma warning enable for each warning

commit 26eafb7865965fd5ef5ee3ad4863f00acf8d10a2

• Generates hexes landscapes, with heights (Civ5 bored me by being flat-McFlat-in-flatland)
• Every hex is selectable, using custom fix for Unity’s broken mouse-click handler (see below)
• Any object sitting on landscape is selectable (ditto)
• Selected units move if you click any of the adjacent hexes (shown using f-ugly green arrows on screenshot)

The green “you can move here” arrows look like spider-legs at the moment. #TotalFail. Next build I’m going to delete them (despite having spent ages tweaking the procgen mesh generation for them, sigh) and do something based on wireframe cages, I think.

Techniques

Hexes

I started with simple prototyping around hexes, but soon found that it’s worth investing the time to implement all the primitives in Amit’s page on Hexagon grids for games: http://www.redblobgames.com/grids/hexagons/

In practice, especially the ability to create a class that lets you do “setHex( HexCoord location, GameObject[] items )” and “getContentsOfHex( HexCoord location )” and things like “getNeighboursOf” … is very rapidly essential.

Mouse clicks in Unity

IMHO: work pretty badly. They require the physics engine, which – by definition – returns the WRONG answer when you ask “what did I click on?” (it randomises the answer every click!). They also fundamentally oppose Unity’s own core design (from the Editor: when you click any element of a prefab, it selects the prefab).

So I wrote my own “better mouse handler” that fixes all that. When you click in scene, it automatically propagates up the tree, finds any listeners, informs them what was clicked, and lets you write good, clean code. Unlike the Unity built-in version.

Procedural meshes for arrows

With hindsight, I should have just modelled these in blender. But I thought: I want a sinusoidal curve arrow; how hard can it be? I may want to animate it later, by destroying/adding points – that would be a lot of work with Unity’s partial animation system (it’s great for humanoids, less great for geometry) – but animating points in a mesh from C# code is super-easy.

In the end, I spent way too long tweaking the look, and on having 2-sided polygons that broke the Unity5 Standard shader by being too thin (on the plus side: I now know what that mistake looks like, and I’ll recognize it in future Unity projets. It has a very peculiar, unexpected, look to it).

I should have just made them in Blender, and – if I got as far as wanting to animate them – re-modelled in source code later (or found a “convert blender file to C vertices array” script, of which I’m sure there are hundreds on the web. Doh!

#lessonLearned.

1. At school: Microsoft Office 2013
2. At university: Microsoft Office 365
3. At work: OpenOffice
4. At home: LibreOffice
5. Everywhere: Apple Keynote
6. Everywhere: Google Docs

As an expert computer user (former SysAdmin), I’m often asked for help by people with non-computing backgrounds. When they see how many different suites I’m using, they’re … surprised, to say the least. Here’s a quick snapshot of what and why.

My history

I’ve been using Office since Excel version 2.0 (which ran from the command-line).

In the late 1990’s, I worked as a temp secretary, and saw a lot of offices at different companies. Office 95 was the last serious improvement we saw in Microsoft’s software. Everything since then has added features of dubious value. Microsoft had to justify regular $500 upgrade fees per person. It wasn’t until 2000’s that StarOffice/OpenOffice made significant inroads in giving businesses a viable, cheap/free, alternative.

Operating System

No matter what Microsoft marketing tells you, there has never been a fully-working, up-to-date version of Microsoft Office for Apple computers. Is this Microsoft’s fault? Apple’s? Both – probably. If you have Macs anywhere in your business, you cannot afford to go Microsoft-only.

Office 2013 for Windows

I hate having to teach lessons where children fall to pieces trying to use the absurdly badly-designed UI and UX.

I hate being asked “but WHY is that button not where it should be?”, “WHY can’t I click over here, when normally I can?” … because usually the only true answer is “because a Manager at Microsoft had to justify their salary by moving it from where you expected, and there was nowhere good for it to go”. With older children, you can give them some honesty; the younger ones lack the ability to deal with such nuance.

But UK schools have been forced into a very bad contract with Microsoft, thanks to some very bad decisions by successive UK goverments (both Labout and Conservative). The docs are public – Microsoft effectively extorts tens of millions of dollars a year from UK schools and teachers, to no net benefit.

(if Bill Gates really wanted to improve education, he could start by cancelling Microsoft’s immoral long-term contracts with schools)

OpenOffice

Free, open-source. Politically neutral, not owned by any major American company with selfish aims.

On Mac, this is the most reliable, least buggy, fastest implementation of Office.

It is MUCH faster than Microsoft’s official (latest tested with Office 2013 last year, extensively). It is also MUCH less buggy – frequently opening and fixing files that were authored in Office 2013, and Office 2013 then corrupted and could no longer open!

However, many of the lead authors jumped-ship to LibreOffice, and maintenance + feature improvements lag behind LO.

LibreOffice

Free, open-source. In theory, has every feature of OpenOffice – started from same source code.

In practice, on Mac: more buggy, with much worse UX (many icons that in OO are very clear have become absurd abstract monstrosities in LO. First rule – “User must be able to understand icon at a glance” – often fails).

HOWEVER: has MUCH better support for opening the files created by latest Microsoft versions. Microsoft keeps adding features and non-backwards-compatible bits. OO doesn’t (can’t?) keep up, but LO does.

Sadly: “better” does not always mean “good enough”. E.g. 2015/2016 versions: if you edit a Word .docx in LO, and check the printing setup, then open in Word … the printing and layout is usually wrong by 10-20%. This makes your 1 page document 1-and-a-bit pages. Your 2-side document is now 2.3 sides … stuff like this is a signifcant problem for doc-sharing.

Office 365

Office 365 is Microsoft’s panic-move because Google Docs was destroying them in the market.

I have to use it because many UK schools and Universities have been seduced into adopting it, for “free or almost free” (trouble lurks behind that word “almost”).

It sucks – not because its badly written; I suspect it’s extremely well written, but the original idea was absurd. Don’t use it for anything if you can avoid it – unlike Google Docs, its very slow and buggy. I suspect because it tries to implement every single feature of old Microsoft Office in the web browser – and that’s a lot of code, much of it outdated and slow.

Keynote

Keynote is Apple’s presentation software. PowerPoint 2016 is getting close in some areas, but my laptop is running the 10-years-ago version of Keynote, and Powerpoint hasn’t caught up yet!

Any presentation I write – even when it has to be delivered on PowerPoint on a Windows machine – is significantly faster to write in Keynote, export to PowerPoint, open in PowerPoint, fix up incompatibilities … than to write in PowerPoint.

(NB: I’ve been using PowerPoint for almost 20 years, and Keynote for a little over 10 years; I am fairly productive in both. But keynote wins time and again – better UX!)

Google Docs

Originally free, then free and paid, and now … who knows?

Google keeps making scary noises here – e.g. Google Docs officially no longer exists; we’re supposed to say “Google Drive” (because Drive is unpopular, and Google Marketing is trying to prop it up). How long will Docs live on?

Most companies and schools I see mostly use just one part of Docs: the spreadsheets. Faster than any online Excel, and much more user-friendly, with live editing by multiple people. Excellent!

It’s missing many of Excel’s features – most of the advanced stuff – so it is no replacement for some. But for most people, doing ordinary work, it’s “what you need and no more”.

Conclusion

The era of monolithic Office Suite software is clearly over; we’re mixing-and-matching based on use-case.

From memory, the era never truly existed – it was conceived as a marketing/sales scam to lock-in businesses to one proprietary platform (difficult to do, but smart; Microsoft deserved to make billions out of that). It’s taken a decade or two to undo the damage that Microsoft did to the world of people who use computers to do “work”, but we’re there.

So … don’t be afraid to mix and match. Do learn what the lowest common multiple is for each file-format – for instance, an Office 95 doc can be opened by anything, anywhere, usually with zero corruption and bugs, whereas a docx is much less global. A .CSV file is universal, suppored not just by software, but understood by webservers and apps, but a .xlsx is not.

I’ve bought and used hundreds of Unity plugins, models, scripts, etc from 3rd parties. I’ve found some amazing things that transformed my development.

TL;DR: please share your recommended assets using this form: http://goo.gl/forms/G3vddOdRL3

Things we want to improve

This is a shortlist; if you’ve got areas you want to improve, please add a comment.

Challenge 1: Value

Quality is immensely variable – there are no standards on pricing. So sometimes you get an asset worth $30 and it’s free (amazingly). Other times you pay $30 and the asset is so poorly supported, and badly written, that you feel it’s not worth anything at all.

Unity has an excellent refund policy: basically, if you feel you were mis-sold, you get a quick, easy refund. (allegedly – I’ve never tried to get it, but I know others who have, and said it went fine).

Challenge 2: Quality

The Asset Store lets you see a few screenshots and a very hard-to-read description, along with optional customer short-reviews. But we’re an audience of experts! We can write – and we need – detailed, expert reviews.

Challenge 3: Comparison

Most things have 20 or more competing solutions on the Asset Store, but when you’re looking at one, you can’t see any of the others (unless they randomly appear on the listing). Most of the time, an asset is “almost but not quite right”, and you need direct competitors you can compare to.

Bonus: if this happened more, we’d see more competition-driven improvements to assets.

Challenge 4: Compatibility

Many assets are incompatible with common / standard assets. They shouldn’t be. But with no-one holding the authors to account, there’s no reason for them to change this.

On the other hand, many assets claim compatibility with each other, which boosts their sales. So compatibility guides should help everyone.

Challenge 5: Discovery

How do you know what to look for when you don’t know what exists?

For instance, some of the major bugs in Unity that are too niche for Unity to fix … have easily-purchasable assets that fully fix the problem. If you only knew this, you would have a better, more stable Unity.

Challenge 6: UX / GUI / Usability

Unity puts (almost) no limits on the usability of assets. This is great for freedom. But it’s bad for long-term development. Often you install an asset are immediately lost: how am I supposed to use this thing? Does it have a GUI? Or not? Where do I click?

It’s often a problem for 3D models (many are packaged incorrectly), and for editor-extensions (MANY of them have major bugs eg. no support for Undo, or they corrupt when moving stuff between scenes, or … etc).

What would help enormously is some standardization that asset authors can apply, and users know and know how to use.

What can we do about it?

My plan has a couple of stages:

1. Compile a list of “best of the asset store”
2. Solicit reviews of everything on the list, and peer-review them for accuracy/impartiality
3. Create “best practices” standards for authors to follow
4. Hilight assets that adopt the best-practices
5. Start small, scale it by pushing out to Unity community to grow

Step 1: Share your favourite Asset-store assets!

Here’s a google form for sharing your favourites. NB: this will combine all the repeat recommendations for the same asset. If you add something someone else has added you’re effectively voting it to the top:

http://goo.gl/forms/G3vddOdRL3

https://docs.google.com/forms/d/18JF6uCHI0nZ1-Yel76uZzL1UfFMI21QvDlcnXSGXSHo/viewform

I’m about to publish a Patreon article on Entity Systems (here if you want to support me), but I wanted to put something up on my blog at the same time, so here’s a quick look at the stats.

Overview

So far we’ve had 203 responses, with at least one respondent for each language I included as an option (taken from the 50 most popular langauges globally):

Most respondents ticked 3-5 languages as their “I’m competent in this language”, suggesting quite experienced programmers.

Cleaning the data

Pascal/Delphi. Hmm. I could not find any Entity Systems libraries written in Pascal, and the only game-engines I could find were extremely niche and/or hadn’t seen a release for several years. I don’t know where these votes came from, so I pulled them out into a separate spreadsheet, and looked at them in more detail:

Summary: the people who ticked Pascal pretty much ignored the rest of the form and simply ticked “Pascal for everything!”. They generally claimed not to know any other languages, unlike the other respondents.

I’m assuming there’s some kind of tech in a Delphi library somewhere that’s called “Entity system”, but which means something very different from what we’re talking about here. The words are pretty generic, so that wouldn’t surprise me (if you know of one, please comment – I googled a few times but didn’t find anything substantial. But bear in mind Google hides results they think you won’t like, so it may be easy for others to see).

Personally, I’m ignoring most of the Pascal responses.

Hilights

Everyone knows C++, C#, Java, and C

This is reassuring: Java is the biggest commercial language today, and I expect systems-level (i.e. game-dev) professional programmers to know it.

Likewise, C++ is the biggest commercial language in gamedev, and I expect all mainstream (non-mobile, non-web) gamedev programmers to know it.

C# was a surprise – but I strongly suspect Unity is single-handedly responsible for this.

C … suggests to me that most respondents are veteran programmers, who’ve been programming for at least 15 years. Anyone around that long would have learnt C; anyone who’s been programming 10 years or less is unlikely to have encountered C, as C++ had pretty much wiped it out for new commercial development by then.

Web languages are well represented, albeit less than mainstream gamedev

We see a bit of Ruby, PHP, lots of JS.

Two big presences are Python and JS. Python is the new kid on the block, and Javascript is/was unheard-of in most gamedev. I suspect JS is here because of @richard_lord and his popular Ash framework for ActionScript, which seems to have been popular among web-background people. Both ex-AS coders – who naturally moved sideways to JS as Flash/AS began to fade – and JS coders looking for a framework to port from a similar language.

Most usage of ES is happening in C#

Although half of all respondents know Java, C++, and/or C# … only 8% use ES’s with Java, 15% with C++, and 25% (The winner!) with C#.

C# and C++ desperately need Entity Systems

(Bear in mind there are many open-source implementations in C#, and many MANY in C++)

C++ is especially desperate if we consider how few people are using them already vs actually want to be using them.

For the C++ users, I suspect Unreal is part of the problem: with no meaningful support for languages other than C++, and no modern Entity System that I’m aware of, it might explain the pent-up demand for a C++ solution. Otherwise, I would guess it’s a lot of people with home-grown C++ game-engines who haven’t the time/resource to convert to an ES yet.

Side note: the small group of Unreal Blueprints users all seem to want an Entity System in Blueprints. The sample size is too small to be significant (4 people right now), but it’s enough to suggest polling Unreal users in particular and seeing what response you get.

Current game-engines run in narrow range of langs; devs want much broader range

The game-engines used by respondents overwhelmingly support the classic, old, low-level languages (C, C++) and the biggest commercial modern languages (C#, Java).

…but the langs people wish they supported are vastly more diverse, with demand in particular for Swift, Rust, and Lua.

Conclusions going forwards

TL;DR: If you’re writing about Entity Systems, put your example code in any of C, C#, C++, Java, or Javascript – almost all developers will be happy reading and effortlessly using/porting that code.

If you’re making a new Entity System, and you want to make a significant success, aim for C++ and/or C#.

(although NB: I suspect that a skew towards responses from Unity devs has inflated the C# number a little; to be on the safe side, I’d lean towards C++ for a new engine, if I were you)

Followups…

I’ll leave the survey open. If anyone wants to promote it, and see if we can get a bigger number of replies (1,000 devs would be nice!), the URL is here:

https://docs.google.com/forms/d/18JF6uCHI0nZ1-Yel76uZzL1UfFMI21QvDlcnXSGXSHo/viewform

The form-results are free and open to anyone to view here:

https://docs.google.com/forms/d/18JF6uCHI0nZ1-Yel76uZzL1UfFMI21QvDlcnXSGXSHo/viewanalytics

And, of course, I’ll be using some of this in my upcoming Patreon articles on detailed Entity System design and development. After this survey, I’m inclined to push harder on producing a decent implementation for Unity, supplied as a C# libary that can also be imported to other engines:

http://www.patreon.com/tmachine

After a year-out to do a post-graduate degree in Education, I’m looking for something new and exciting to do next. My primary goal is to boost a company or team rapidly and show significant outcomes – increased revenue or other KPI’s – either through Consulting or full/part-time senior leadership.

Things I’m particularly interested in right now:

• VR – my DK2 sits on my desk glaring at me, wondering why I don’t play with it any more. “I’ve been too busy with non-VR work!”, I cry.
• Android, iOS – I’ve shipped dozens of apps. I’ve designed some, programmed some, project-managed some, and been an emergency “fixer” brought in to help established teams.
• Computer games – I’ve played well over 2,000 games. And I’ve written game-engines, libraries, tutorials, unlaunched indie games, published AAA games, MMOs – bits of everything.
• China and Korea – many years ago I studied basic Chinese (Mandarin) and Korean/Hangul; I would love an excuse to become fluent in either.
• San Francisco / Bay Area – I’ve visited dozens of times for conferences, meetings, holidays, etc, but never lived there. I had non-negotiable ties to London. But … now I’m free to relocate and travel.

Ways I can help your company:

• Creating a thriving company-culture from the ground-up, especially a tech-friendly and tech-respecting culture that works across non-tech divisions
• Identifying your strategic problems, finding high-level solutions, and organizing and motivating teams to work on them
• Identifying immediate problems, finding “what can we do TODAY?” solutions, and executing on them rapidly and effectively.
• Talk technically to tech teams, commercially to marketing teams, and pragmatically to ops and finance teams
• Build massive empathy with developer-communities, engaging frequently and effectively both with individuals and teams
• Educate and enthuse C-level management and senior management on how to better exploit tech within their own spheres, and how to interface better with tech teams
• Public engagements – pitch-meetings, conference talks, client/account-management, sales support, etc.

Miscellaneous qualifications:

• Certified ScrumMaster
• Degree in Computer Science (Cambridge University)
• BCS Scholar (British Computer Society)
• Fluent in many programming languages
• StackOverflow score of 20,000+
• Patented server technology for scalable SaaS-style backends
• Contributed chapters to two books on Game Programming

CV available on request – or have a look at my LinkedIn for basic career history. Email address: adam.m.s.martin @ gmail

The red pyramid in this image is a custom handle (3D) that you can grab, drag, and move around the screen. When it touches another GameObject, it finds any Sockets on that object, and attempts to rotate + move + scale the first object so that they connect together, like magnets.

…these things are so useful I quickly end up adding many to each GameObject. I have different sizes and “types” (type A can only connect to other type A, etc) – each with a different mesh (Pyramid, Cube, Sphere, squiggle … whatever). But Unity has a weak Hierarchy View, and it’s very hard to see which is which:

This is a 5+ years old problem in Unity. Their API for is private, making it hard for 3rd parties to fix it. I’ve hacked bits of it myself, but the hacks have often broken in successive versions of Unity, and need constant refreshing – they are not a robust solution.

So, I wanted to make a Custom Inspector (Unity allows these to be customized, and gives full control to the developer, although the API’s for it are poor) that would render each and give a preview icon of the custom meshes (where the white squares are in this image):

Summary: Display a thumbnail of the mesh for each object, in the Inspector

This is a 3D engine, with a 2D mode (which is still 3D, but has hundreds of extra classes to facilitate 2D game dev). It was customizable almost from Day 0, and “customization” is one of the biggest current selling points – c.f. the Asset Store, from which Unity makes vast amounts of money.

So: we expect that “render a simple mesh and display it next to the text saying the object’s name” should be easy, right?

Let’s go on a little journey…

Problem 1: How to make that pyramid?

Unity does not allow developers to make clickable 3D objects in the Editor.

There are a bunch of ugly, pre-made 2D only “handles” you are given, and one of them can be customized (through a torturous process of specifying matrices) into making arbitrary rectangles appear in 2D, with no lighting, and breaking the 3D positions of the Scene.

I was using that up until now. It’s ugly, but it works fine. Surprisingly, there’s not even a “drawTriangle” command. The common workaround seems to be: find the largely undocumented Graphics.DrawMesh…() methods, use trial-and-error to discover that one of them (only one!) works, and use that to draw a Mesh here.

Problem 2: How is that pyramid clickable?

I got the mesh drawing. This took a while … but what’ll really flubble your goat is when you try to make it clickable, draggable. As far as I can tell, Unity has no support for clickable meshes or objects.

There’s huge support in-game, but in-Editor it vaniehs. Their click-detection is almost entirely physics-based, but in the Editor they have to disable the Physics engine, otherwise editing would be a nightmare. Imagine: you’d try to move things, and the physics would bounce them back, or block them, or send them flying.

Some of physics is enabled – the basic collision-detection. But you cannot use this to do Editor features: if you did, the physics for the editor features would interfere with the physics for the game, or become part of it. Unity does not currently allow running multiple physics simulations in parallel. IIRC it’s a feature of the middleware they’re using, but they’ve disabled that feature.

The basic elements of interaction in 3D are therefore mostly missing in Editor: Collision detection, Mouse over, Mouse clicks, etc. There are some old bits of legacy code for some of these, but they’ve not been maintained in many years, and are no longer (or never were) included in the main documentation.

Back to Basics: Problem 2.1: Unity has no Triangle class

Workaround: create a “has the mouse clicked this triangle?” routine, and apply it to every triangle in the mesh. Use this to build-up a working “click and drag a mesh” routine.

Obviously, being a 3D engine, Unity will have a method “Triangle.ContainsPoint( Vector2 )”. Right?

Wrong. You have to write your own. Or use Google – unfortunately the first two I tried had bugs (which is disappointing; this is a very well-known/solved problem in Computer Graphics). I fixed the maths, did some tweaking, and it worked fine.

OK. Now we have a mesh that renders in Editor, and is clickable and draggable in Editor. Finally we can add the preview to the Inspector.

Problem 3: Unity’s “click mouse button” API is undocumented

Now you hit problems with mouse control. Unity has a good (albeit non-extensible) system for this – but the smart person who wrote it didn’t bother documenting how it works, and it’s non-trivial. Without documentation, almost no-one knows how to use it, and after many attempts, most give up and use something lower quality they hack together. c.f. any Google search on “Unity scene view mouse clicks”.

It took me months to reverse-engineer it, partly by decompiling the Unity libraries and partly through intelligent guess work based on previous game engines I worked on. I’ve met a few others who’ve done the same, but none who found it especially quick or easy.

Since 2015, some of this system is now pseudo documented, e.g. via some good Unity blog posts. But those aren’t linked-to from anywhere, and you have to work quite hard to find them (I don’t have the links any more; when I tried a quick search to find them, I drew a blank).

Problem 4: Unity’s mousePosition.y has been broken for 5 years

This core feature – the y-position of the mouse – has been broken for so long that everyone has now hardcoded their games to workaround it. I suspect Unity has decided: “We cannot fix it, it MUST remain broken.”

IMHO it would be fairly easy to fix: create a new global API call that returns the mouse-position (NB: There is no such API call in Unity today; there are two obscure calls in different places, one that only works in game, one that works in game AND in editor, and they return incompatible values).

Workaround: take the y-position, multiply by -1, add it to the Sceneview height. But not the camera’s height (as advised by most websites and forum posts) – Sceneview has a magic height that is 5 to 25 pixels different, and it varies over time from the Scene View Camera height. Hmm.

Problem 5: Unity has no GUI system for the Editor

After 2 years of promising a modern GUI API, Unity finally published (almost 2 years ago) a reasonable new GUI by hiring the author of the main 3rd party GUI-replacement for Unity.

A few years ago, Unity crop rebranded the nasty, end-of-life, old GUI as “the legacy GUI” and brushed it under the carpet (with good reason). Sadly, despite the marketing department’s claims, it’s very much not legacy: it’s the only GUI you can use in Editor.

Problem 6: I already drew a mesh; can’t I do the same again?

I said the Graphics.DrawMesh…() methods were undocumented, and only one works (in that context). But when you try to use them in the Inspector, they both silently fail.

Since there’s no documentation, there’s no way of knowing if this is hardcoded, or if it does in fact work, but requires a secret method call first, or a pre-multiplication on your arguments, or … or … etc. Something that only Unity staff know about.

UPDATE: Sampsa sent me some code on twitter which gets DrawMeshNow working using some GL calls:

Problem 7: Unity often blocks/disables procedural content

BUT WAIT!

There is a library call for rendering thumbnails of meshes, and it is used widely throughout Unity.

Ah, except … As a developer, you are blocked from using it on user-generated content.

You are also banned on using it on content generated by scripts: you can create a Mesh in script, but you can’t use this library call on it. The library call is hardcoded to only work on things that are compiled as part of the Build.

If I were to make a bad Plugin, that could only use a pre-made set of meshes, this would be fine [*]. But I want users to make custom meshes (that are easier to use with their own games) and scripted-meshes (that adapt based on context, making it many times easier to build large, complex games), etc.

I hit this limitation of Unity depressingly often. Many core features of Unity have the same or similar restriction: they are disabled both for runtime (procedural content in-game) and for developers working live with procedural gen (who do many things in script).

[*] = (actually, it wouldn’t be fine. It would work, but still be a little ugly, because Unity doesn’t let plugin authors bundle their meshes. My meshes would pollute every game-project that used them. You see this a lot in plugins, random things dumped into your project, because the plugin author cannot stop Unity from spamming your project with them)

…at which point, I gave up and wrote this blog post

I’ve decided I’ll do what most people do:

1. Give in.
2. Make my Plugin worse (delete features and code I’d already implemented)
3. …so that it’ll work with Unity

When the next version of Snap-and-Plug goes live, and meshes can’t be customized in code, and can’t be reactive … you’ll know why.

Conclusion: I hate extending Unity

You’ll read this, be glad it wasn’t you that wasted hours banging your head against these brick walls, and move on. I have now battered through the pain, and I’ve decided on my workaround.

But next time you buy a Unity Asset Store plugin, and find yourself disappointed that it crashes, or works strangely, or doesn’t have a great GUI … instead of hating on the author(s), consider this: maybe – just maybe – it’s not their fault. Unity has a lot of work to do in cleaning-up their Editor/Plugin/Developer API’s…

From this mess … to this:

Building some odd machines to test it works:

Features and fixes recently added

• Use shaded, materialed meshes for in-editor handles, instead of flat ugly rectangles and tris
• Click/tap a socket’s handle to directly select it in the Scene view
• Meshes are resized to fit the user-selected “socket size” variable
• Only handles that are facing you are rendered; HUGE improvement for complex levels/machines/buildings/etc
• Only handles you can see are clickable/draggable; HUGE improvement for complex scenes (where accidental clicks happened too often!)

• Dev writes game, gets share of profits when sold
• Publisher manufactures game ($10 loss)
• Publisher sells game to retailer at $30 ($20 profit)
• Retailer sells game to public at $60 ($30 profit)

…then some of the retailers spotted a flaw in the system, and started doing this:

• All the above, BUT:
• Retailer buys game back from Consumer at $10 ($10 loss)
• Retailer sells game to new Consumer at $55 ($45 profit)
• Instead of “selling” 100,000 copies of the game (giving money to gamedev), retailer “sells” 1,000 copies of the game, and then buys/resells it 99,000 times
• NET RESULT: Publishers add crap that consumers hate – e.g. pay-for DLC – and more developers go out of business than before

A simple solution…

Serious question: why aren’t publishers offering to buy-back used games for $x%, giving both cash and (say) free DLC for other games?

Having thought about this, it seems the reason game-retailers et al are causing problems is because they have zero competition in the re-purchasing market; this allows them to re-purchase at prices lower than they pay for the original copy.

Take that away from them, and … problem solved.

No?

Night Vision

I’m working on a tiny level demo to show some of my ideas together. I want one character that can see in the dark, something like the “InfraVision” of D&D.

Spec:

• Character can see independent of the existence of lights in scene
• Vision is imperfect, significantly weaker than daylight vision, in terms of details, colours, etc
• Vision enables easy location + identification of other creatures

Screenshots

Here’s my orc (a test avatar I already had) sitting on top of a building:

Step 1: cancel the lighting

We use Unity’s “GetComponent.SetReplacementShader( Shader, “” )” to change the shader to a simple “Unlit” shader (Unity provides a built-in one).

[csharp]
[ContextMenu("Enable dark vision")]
public Shader shaderDarkVision;

public void Start()
{
if( shaderDarkVision == null )
shaderDarkVision = Shader.Find("Unlit/Texture");
}
public void EnableDarkVision()
{
GetComponent<Camera>().SetReplacementShader( shaderDarkVision, "" );
}
[/csharp]

Step2: Add a vignette to nerf it

I want the DarkVision to be significantly less perfect than daylight vision, so let’s add a simple vignette (Unity has downloadable examples of this shader in their docs, but I only found it after I’d got mine working!).

This took me a long time to get working, just to get accurate screen-positions of shader pixels – so much of Unity’s semi-proprietary Shader language is still undocumented, after many years. I knew all the maths, and had implemented the effect in OpenGL / GLSL in minutes, but it took an hour or so in Unity. And once it was working, I got sidetracked in tweaking the exact curve of darkness of vignette.

Step3: Convert to grayscale (infravision should be colourblind)

This was easy – simply average the r/g/b components of your Color, somethign like:

[c]
avg = (color.r + color.g + color.b ) / 3f;
color = float4( avg, avg, avg, color.a );
[/c]

Step 4: several hours of experimenting with wild effects

I had some problems with this:

1. It was too easy to see “everything”
2. With no lighting-calcs, it was fugly
3. With no lighting-calcs, it was VERY hard to do depth-perception. In a complex street, you got lost trying to tell which objects were near, far, blocking your way, or not.
4. WAY too much detail on the textures is showing through: DarkVision should lose most detail, while keeping overall shapes clear

Here’s some of the things I tried and discarded. Note how the screenshots are from many positions – I ran around a lot, testing how effective the different shaders were for hunting a quarry (or fleeing an angry mob of AI’s).

Step5: FAILED: use depth-buffer shading

Unity staff: please write clear, correct, up-to-date documentation on depth-buffering as supported (or not) by your proprietary Shader Lab language, and with clear details on how this works in Unity5, not some hand-waving Unity4-maybe-Unity5-not-sure gumph.

I simply couldn’t get it to work. Using the proprietary built-in depth-buffer samplers either failed outright (0.5 across the sampler), or gave bizarre results.

Rumours suggest that we have to write 3 shaders: 2 for your proprietary system, and a third where we re-implement depth-buffer access by hand. This seems to me unlikely – I am sure Unity can handle that for you. This is the kind of feature that Unity’s ShaderLab does well (but no-one documents, and so it goes under-used by devs).

When you find or reverse-engineer instructions, ShaderLab is excellent. It’s such a pity that so often … you can’t.

Step6: Combine object-normals with plain greyscale

Ultimately, I fell back on “Fine, I’ll use the most basic bits of Shaders that even Unity can’t make confusing” – object normals. I faked shading Old Skool: each surface is darkened by dot-producting the forwards vector ( which by definition is (0,0,1) after the MVP multiplication stage) with the normal vector. That gives a float from 0 to 1, showing how much the surface is facing towards/away from the viewer.

I’m not delighted with this – it’s not quite the effect I was aiming for (I REALLY wanted to wipe more of the diffuse detail, but…). However, it does work quite nicely, and for now it’s more than good enough.

Benefits of final version

Here’s why I like it:

1. Runs 100% independently of my main lighting – I never have to re-write it when changing lighting.
2. Provides huge advantages at night time, or in low-light situations. More so the less lighting there is
3. Provides depth-cues to the player, so that running quickly through streets (or tunnels) is still pretty easy to do
4. Limits the over-powered nature by cutting down peripheral vision
5. Runs very fast on GPU, despite crappy hand-written shader code (mostly because it doesn’t use any lighting calculations)

That got me thinking: if you started a new commercial ES today, what language does your audience want?

Short Google form

FYI: I picked the top 10 global languages by popularity, and then cherrypicked from the next 50 or so on http://sogrady-media.redmonk.com/sogrady/files/2015/07/lang-rank-615-wm.png – favouring ones where I have met people that I know are using them in gamedev today.

So … now I’m crowdfunding the long, detailed, in-depth ES articles. This gives me a way to spend the time I need to write each one while still paying rent, food, etc.

You don’t have to sign-up – I know there’s lots of people like myself who are in bad financial situations, and I hope all the articles will be made free eventually. But if you’ve found my ES articles useful, and you want more of them, and you can spare $5 once every couple of months, please do.

You can sign up here: https://www.patreon.com/tmachine

Civ5 is tragic. It’s one thing to launch a AAA title full of nerfed gameplay and obvious, in-your-face bugs, but quite another to leave them unfixed for years after. It’s one thing to officially fix your bugs only in pay-for add-ons – but quite another to keep those add-ons at full price for years after they released.

Here’s a quick view of what’s still broken in Civ5 today, if you buy it direct in the online stores:

• The game autosaves every 10 or so turns; this has NEVER been correct for Civilization (from memory, the original game used to save every other turn by default (maybe not; running out of disk space was a real concern back then); modern teams at Firaxis seem to be too amateurish to implement this. Civ 4 used to crash so much that putting it on “save every turn” was a requirement).
  • No-one at Firaxis should be “unaware” of the need for every-turn autosaves
  • I struggle to think of a rational explanation; best I can think of so far is some weak game-designer thinking that autosaves are “cheating”, so they decided to deliberately break the concept so it only half worked.
  • I haven’t yet found an easy way to un-break this in civ5. Given how crucial it is to the game, and how it’s been present in every previous version, it should be in the game-options, but it’s not. That’s two bugs for the price of 1!
• The user-interface for moving units is more broken than in any version of Civ to date. Civ1 had a perfect system (but predated the existence of a mouse on every computer): units moved where you told them by pressing numeric keypad keys. Civ3 and Civ4 had “automatic” pathfinding that was badly broken: it often walked your units into 100% certain death for no reason.
  • Civ5 takes this one further: if a unit is selected and you move across another unit, civ5 moves BOTH units, causing double the catastrophe.
  • This automated action – that IME is almost NEVER what the player wanted to do, and is extremely destructive, frequently causing game-losing events – cannot be undone. This breaks the cardinal law of user-interfaces: if you do an automated, un-asked-for, action (which you generally shouldn’t) … then you MUST provide an Undo.
• Civ5 also has a strangely bad algorithm for pathfinding: it generally takes 1-4 seconds to run the algorithm during which time the game lies about the game-rules, and claims that your unit is “immovable”.
  • This appears to be a junior programmer discovering “asynchronous” coding for the first time in their life, and not realising the obvious side-effects
  • I have no idea why the algorithm is so insanely slow. It is slowest in a huge game, but even in a tiny game, with nothing happening, and only a tiny game-world, it randomly takes anywhere from no time to 1-2 seconds to “switch on”
• The buttons for “required” actions are deliberately placed in the worst-possible positions: the far OPPOSING corners of the screen.
  • This breaks the most basic and obvious guidelines in UX design
  • For bonus points, the buttons don’t get larger on large/wide screens. Those buttons are so small and so far away you rarely see them, let alone find it easy to press them
  • It’s as if the Firaxis team were out to beers with the misguided team at Microsoft who decided that Windows 8 would rely upon a single “magic pixel” to activate core functions, and thought: “hey, I know how we can really mess-up our players! That impossible-to-hit pixel idea is great! It’ll make the game so much harder!”
• The interactive HUDs giving critical information on the global state of politics, that made Civ4 a significant improvement over previous versions – and that were extended massively by the community, increasing gameplay without removing any challenge … have been deleted.
  • The question begs: we know Firaxis has many people who’ve played the previous civs; how on earth did they forget how critical and popular the dashboards were?
  • The game is almost unplayable without dashboards. It’s a waste of time: you have to play solo, or click through a series of menus every single turn simply to find out the current status of your opponents. A massive step backwards in gameplay.
  • Best explanation I can think of: failed game-design strategy to “make it more mass-market friendly”.

That last point leads into the legion of game-design failures in Civ5. As I understand it, most of the game was “Designed” around the idea of dumbing-down: apparently the Youth of Today are so stupid and lazy that they cannot play games that are deep, enjoyable, or interesting. The way to make money is to make games idiot-proof with as few options as possible and no meaningful decisions.

Ironically, this is the exact opposite of what the legions of Civ fans had shown they valued in the Civ franchise, via the overwhelmingly popular mods for civ4. Master of Mana added depth, difference, more depth, more variety, more difference, and yet more depth, across the board. It hacked the tech tree into becoming 5 different tech-trees, all running in parallel (WTF? Oh, yes!) – and players loved it.

One day, I may write a post on the flow of game design, successes and failures, and the #facepalm that civ3 and civ5 were (between the two of them, both abject failures). Strangely enough … the two things in civ5 that I remember the community being most afraid of (hexes and 1-unit-per-tile) … seem to have worked fine. The radical changes were a success; it was all the easy, “you can’t possibly screw this up”, parts that the dev-team screwed up. And that is why I consider civ5 “tragic”: they got the hardest bits right, despite the odds … and tripped over their own shoelaces messing-up the easy bits.

Civ4 had a similar trajectory, with two differences:

1. It appeared to be a legitimate mistake: they didn’t realise until after shipping how broken their own game was
2. Within a couple of years, the add-ons were being bundled with the core game for free, or at most five dollars. As they should be: they were mostly re-adding content that had been removed, and fixing launch-bugs, with only a tiny sprinkling of extra content/changes.

For Civ5, someone in charge (publisher? studio director?) appears to have decided: “hey, we shafted the consumers and exploited the franchise well there – but we could do so much better! Let’s do it deliberately this time: save money by deliberately shipping incomplete product, then use online market-controls to force everyone to pay 3 times to get a working game! We’ll be RICH!”.

In their defence, Firaxis did ship one major content update for free, which was wonderful: they added retina support. That’s unnecessary (not a bug, retina’s didn’t exist when it came out) and nice to have – but in no way justifies ignoring the rest.

Then, every 6 months or so, when people ask me for simple examples of how ECS’s fix Unity, I have to wrack my brains for something simple.

So I’m going to start blogging simple examples as I run into them, with only enough context for me to understand them. Here’s the first…

Share a trait between AI enemies, and non-AI, unmoving, static objects

I have blobs that move and eat each other.

Now I want to add food, that cannot move, cannot eat anything, but is edible.

This is impossible in Unity without writing deliberately-bad code, for two reasons:

1. Unity prevents you writing OOP code: Unity corp’s early programmers were inexperienced at programming, didn’t really understand C#, and broke it rather than work within it.
2. Unity does not allow traits to be selectively shared between objects. This is the core feature of all Entity Systems, and shows beautifully why we do NOT accept any claim that “Unity is an Entity System / Component System / Entity-Component System”

The best one I found has super-awesome-multi-colour mode. But by default it’s disabled, and the config-options don’t include a way to turn it on. You have to dig in the developer documentation to find out how.

ALSO … by default, it uses your theme’s CSS styles for the cloud. That is a really bad idea – it disables most of the tag-cloud features (including the “cloud” part!). Again, unfixable unless you dig in the dev docs to find the secret command.

For future reference (because I’m pretty sure I’ll be using this on other sites soon), here’s a working PHP snippet you can embed in your Template source (I hate that WordPress still has this stupid bug where you can only modify pages by writing new PHP files – so stupid and unnecessary!) in your Theme folder:

$args = array( “title” => “”, “color” => “random”, “text_transform” => “capitalize”, “link_italic” => “yes”, “hover_underline” => “yes”, “alignment” => “center”, “link_bg_color” => “#DDDDDD”, “separator” => ” – “, “show_title_text” => 0, “avoid_theme_styling” => “true”, “max” => 50 );

do_utcw( $args );

I don’t normally blog a blow-by-blow account, but this set is particularly interesting.

It suggests the tech team has been focussed on fixing many “critical but un-sexy” problems. That is a noticeable change in direction from the past few years. Possibly this is a one-off to get Unity 5 working properly.

If you’re still using Unity 4.x, it is finally safe to move to Unity 5.

Unity 5 is not a complete replacement for Unity 4 – there are still major featuers of 4.x that have been removed from Unity 5 and have no upgrade-path – but it’s finally production-ready (or very nearly). That … is big news!

Hilighted improvements / fixes / changes

Please note: there will be a lot of negative comments here; that is inevitable, considering most of the change-list is “things that were broken, or wrongly implemented, or poorly designed – and are now not”.

To be clear: I’m pleased and excited by the overall shape of these changes.

Graphics: Added CullingGroup API, which allows you to specify a large set of bounding spheres that are integrated into the culling pipeline and subjected to frustum and occlusion culling

Unity has (amazingly) never had built-in culling accessible by developers, which is almost unheard-of in game-engines. This suggests we’re getting towards it (although spheres are only a first-approximation for culling, and I wonder how deep the interaction is with Unity’s pipeline here. I’d assumed we’d get access to something more like BSP)

Application.UnloadLevel. Unloading scenes is now possible while the game is running. References to lightmaps are cleared but you have to call Resources.UnloadUnusedAssets() to actually unload them.

Scenes in Unity are very much FUBAR as a concept – they were created by people who had very little understanding of computer-game design and development. Ideally, we’ll see Unity remove the whole “Scene” concept in a future major release, but in the meantime this is a significant step towards reducing their weaknesses, which is good to see.

Layout elements under a ScrollRect component may not work properly

No s***, Sherlock! Yeah, most people using Unity’s “new GUI” have found it’s fundamentally broken in a bunch of places. Good to see Unity working on this, and hilighting some of the issues – but really they need to create an entire webpage listing “the following parts are broken, don’t use them – or beware if you do”.

Right now, you tend to waste hours, half-days at a time … re-discovering known bugs in Unity’s GUI.

Scene view picking in linear color space does not work for DX11 when MSAA is used (quality: fantastic)

If you’re on Windows and have the highest quality settings, this is lethal: Unity simply doesn’t work. But it’s coming in an emergency patch very soon.

Mecanim: Playable API.

If this does what I think it does, then it was essential back when Mecanim was released (3 years ago); glad to see it’s finally here.

between 5% and 30% lower CPU cost for rendering

That’s an enormous speed-up for an engine as old as Unity – this is big news. Reading between the lines, the speed up is partly a side-effect of them making it a bit more multi-threaded (which became normal for game engines many years ago).

If we thought that was a lot, wait till you see:…

Particle rendering optimizations (especially for VR), with speed improvements varying from 15% to 50%

… 50% performance improvement! Wow. Name-checking VR here is probably the key item. We keep seeing VR’s extreme performance-requirements forcing engine-makers to up their game, and dig deep to find perf boosts. The “minimum” hardware reqs for basic VR rigs are very high even now, several years after Oculus Rift launched.

UI now uses multithreaded batching & geometry generation backend

This was the minimum we expected from the “new GUI” when it launched in Unity 4.6 almost a year ago. This fix brings the GUI most of the way towards being “production ready” … ironically, 6 months after Unity changed their website to hide the existence of the “old (but works) GUI” and pretend it didn’t exist.

Added parameter QueryTriggerInteraction to all physics queries (raycast, spherecast, overlap) to allow any query to override whether or not the query should hit Triggers

This is patching a MAJOR design bug in core Unity that has plagued Unity for many years. I want to play with this some more, and see how much we can un-**** Unity’s ****ed ray-casting system using it.

(I don’t believe any experienced game-developer would have accepted Unity’s original design here – it was clearly a terrible approach that would cause never-ending head-aches when making games. It mixed concepts that were very obviously unrelated and distinct)

Fixed Function shaders work on all platforms now (including consoles)

This one has been blogged about extensively by some of the graphics team, IIRC.

In my experience, Unity’s shaders have been OK, with a few that were terrible (e.g. all the Mobile ones), but the framework which holds them has generally been excellent: it’s isolated us from the pain and suffering of GPU-specific shader bugs. This house-cleaning doesn’t make much (if any) difference to most of us, but apparently keeps Unity’s internal code clean in a way that will facilitate rapid changes and improvements going forwards.

2D Rect Mask

TL, DR: “we finally implemented masking properly in the new GUI”.

See previous comments on the new GUI, and how it’s getting much closer to production-ready.

UI: Dropdown control

Yes, really – Unity has finally added the “dropdown”, which has been a global expectation in UI design for 20+ years (it was made compulsory in web-browsers back in the 1990’s).

Editor: Remove legacy Mac OS X corner window resize behaviour

Apple told devs to remove this … um … about 3 or 4 years ago? At first, it was broken (couldn’t resize windows), then it was annoying (Unity added optional resizing on all edges, but put an illegal resize-hot-corner in bottom right that broke all EditorWindow code, because they made it a private API).

Working around that on Mac … forced you to mildly break things on Windows.

TL, DR: custom editors (as found in many/most of the best Asset Store plugins) will now be a little less-broken across the board.

Substance … All crashes and hangs at build time, level load/change time, playmode entry/exit should be gone

Yay! I’ve not been using Substance, but I’ve met several developers who’ll be breaking over the champagne over this, given how miserable they’ve been about crashes and hangs with this in the past.

CanvasRenderer now takes a Mesh instead of List this allows for the use of imported meshs as part of the UI

Without this feature, the new GUI was not usable in most non-trivial games. It’s hard to over-estimate the importance of this for declaring the new GUI production-ready.

Allow sprites to be dragged into scene view in 3d mode

Small but sweet. It’s a little thing, but makes a big difference to the frustration level of the user; in my experience, these things are often the real reason why you sacrifice the cost-savings and benefits of your own engine and use something like Unity instead.

i.e.: with your own engine, you can’t afford the time/money to polish every small interaction; 3rd-party game-engines can shine here, and should take more advantage of it.

I sometimes mention stuff like this as suggesting that Unity’s senior management team are out-of-touch with their product. Unity’s early community loved it largely because of small things, but as Unity grew, the company stopped sweating them. I suspect time will eventually tell that was a huge strategic mistake.

Improved Export Package window (now uses a proper tree view)

This window hasn’t correctly worked for at least three years; converting it to a “proper tree view” might – finally! – make the “Export Package” function do what it’s defined to, instead of exporting the wrong things, breaking keyboard and mouse interactions, etc.

(most of the bugs appeared to be a side-effect of the non-maintained, half-implemented, custom tree view code)

Make sure ObjectField and Object Selector shows icons for game objects and prefabs

Co-incidentally, I tweeted about this recently: Unity could make their engine noticeably faster to develop with if they provided visual feedback on these fields.

It’s embarassing, almost shameful, how poor the UX is on these fields today. By the sounds of things, this patch merely makes them “less crap”, rather than fixing them – but the last 5 years has been so awful that any improvement is welcome!

Selection.selectionChange callback triggered when selection changes

To call this “important” is somewhat of an understatement.

Substantial areas of the Editor API’s are surprisingly poorly maintained by Unity. The bugs undermine people each time they try to use one of Unity’s overwhelmingly greatest features: its extensibility.

Graphics: Added a quality setting ‘Shadow near plane offset’ to allow working around shadow pancaking artifacts

If this does what I suspect, it will make it trivial to fix a lot of common, frustrating “why do my shadows suck? OMG! UNITY SUXXS!!!!” situations.

Mecanim Improvements

SO MANY.

I don’t use Mecanim: it’s been slow, clunky, buggy – and it solved the wrong problems at launch. It felt more like a marketing excuse rather than a developer feature. For me, working x-platform and often on mobile: not very useful.

However, looking at how long the list of fixes is … it might finally be worth using it. In context of all the other changes we’re seeing – maybe production-ready for general use now?

(modulo: the performance. Last time I checked, it was still way too slow for cross-platform games unless you were happy to have a relatively small number of animated objects)

Go check it out! If you’re a long-time Mecanim user, let us know what you think of this list of changes!

Now a TerrainData object embedded into a scene (created by script) allows scene objects being selected as tree prefabs

Unity’s Terrain system was implemented using a nasty, ugly hack that should never have been used.

As I understand it, that was in itself an attempt to workaround some problems with the fundamentally broken – and allegedly “unfixable” – Serialization system that is core to Unity, but is too much code for anyone to fix (and will be thrown out / fixed / replaced around Unity v6 or v7. Maybe).

This change reeks of a “workaround to a workaround”: you can’t create TerrainData in the scene (which should be the ONLY option!), but you can artifically create one if you write a script to do it for you. Either way, it’s good news – TerrainData Assets are a common source of project-corruption, because they’re abusing a feature that wasn’t intended for this.

Stacktrace logging: Allow to log full (native/managed) stack trace when log is printed, the option is available in the console window in top right corner popup menu.

OMGWTFBBQ!!!!!!!!!!!111!11111!!!!11!!!1!

I frequently discover major bugs in Unity core; there is never anything I can do about it because Unity strips / deletes all stack traces (in most cases) before outputting anything.

If this fix does what it says on the tin … WOOOHHHOOOO! … we can finally workaround Unity crashes (by debugging them!) and give Unity much more detailed and accurate bug-reports (leading to greatly increased chances of them fixing bugs).

Cross those fingers…

Fix Cursor

As I recently tweeted, Unity’s support for custom mouse-cursors was recently broken. That’s a huge pain given most games today use custom cursors. Several fixes here, looks like they’ve cleaned them all up (I hope).

Fix possible data loss on Windows when renaming folder with locked files

:O

Fix occasional recycle bin bypassing when deleting assets on Windows

:O

Serialization: Fixed not being able to serialize a field called “Base”

:O

UI: Stop disabled graphics from blocking raycasts

If this is what I think it is, it’s another example of “should have been fixed before 5.0 was released” – but I’ve had so many problems with the bad system of Unity raycasts that I go out of my way to avoid them anyway.

Core: Fixed hang when passing large arrays to the Undo system

Sounds unexciting, but … I think I’ve encountered this on some of my projects: unexplained hangs that came out of nowhere and destroyed my ability to keep working on one particular game, related to Undo.

Note: I keep saying this in public: Unity’s Undo system simply Does Not Work, it’s appallingly buggy. As far as I can tell, the person who originally wrote it had little or no experience of what they were doing, and didn’t consult the literature to find out how to implement Undo systems correctly.

Some days, I genuinely feel it would be better for everyone if Unity removed the “ctrl-z” keyboard combo, because so often when you press those letters you corrupt your game project. A lot of the time, you don’t notice that Unity has just corrupted your project – not until much later, and then you don’t realise that it was Unity’s broken Undo that caused the corruption. Instead, you blame yourself, or your co-workers. Seriously, it’s that bad.

(I’ve stopped bothering logging bugs against it)

Importing: Changes to scripts are now correctly processed synchronously, fixing a range of issues with scripts relating to asset processing at import time

Subtle, but … I suspect this fixes a LOT of bugs we see on larger Unity projects, where you’re frequently hot-loading complex sets of scripts, assets, inter-related dependencies, custom asset-processors, etc.

…the end

So that’s it. What do you think? Any other major items you notice in the release notes that will make your life significantly better?

What’s still broken?

Sometimes I get to talk about the good bits that – sadly – few people have noticed. Here’s one of those.

Unity hardware survey

Every quarter, Unity publishes a regular round-up of what hardware people are using to run Unity3D games etc (I normally see it via @ArasP – I think he prepares the page each time?). This is hugely important.

There are flaws in Unity that affect us as developers – both the software (bugs, architectural problems) and the company (tech strategies, documentation ethos). A lot of the time we have to second-guess what has happened (“why is this bug happening? Can we workaround it?”) and what will happen (“how likely is it that Unity will fix it? Will similar bugs happen again in future?”). We need data to do this extrapolation – and the hardware survey is a valuable primary source that it’s worth learning to use.

Thanks, Unity, for publishing this – don’t stop! It’s a great resource for all Unity game developers!

For instance … if you find a major rendering bug on a hardware platform that you suspect is very expensive to fix, and that platform is 0.001% of the userbase — you’re better-off working around it with changes to your game-design, than filing a bug report and waiting for Unity to eventually fix it. With the best will in the world, such a small impact / high cost task is always going to be low on the todo-list, and lose out to the thousands of high-impact / low cost bugfixes they’re working on instead.

Mobile: Android is 70% of all gaming phones

…and iOS is the remaining 30%.

Windows Phone?

What is this “Windows Phone” that you speak of?

(building for WP8 on Unity didn’t work properly last time I tried – you had to do a bunch of manual fixes to workaround some Microsoft policy on library inclusions. Does anyone care?

It certainly matters – I refunded someone an asset-store purchase because they were struggling to get WP working, and neither I nor they were 100% if my code was causing the problem – the WP process was a bit odd.

But does it matter enough? No. I’d rather do the odd refund / freebie for WP builders than have Unity waste time they could be fixing the big bugs)

If you have an Android bug on more than one phone

…I’m betting it’ll get fixed quickly. In practice, most Android bugs are one manufacturer (e.g. Samsung, I’m lookig at you) or one chipset (e.g. Tegra); if you can show it crosses manufacturers or chipsets = win.

Or if you can show it’s Android OS version-dependent: there is a large block of users for each version, and aside from the x.0 release, they don’t shrink much.

Multi-threading

5 years ago it was embarassing that Unity was still a hardcoded single-threaded game-engine; today I don’t even have the words.

Look at that graph: 6% of mobile devices and 1% of desktop devices are single-threaded. Unity can’t hold out as single-threaded for much longer, surely?

More importantly – since they have held out so long – look at the pace of change. In the last 12 months, both mobile (32% -> 47%) and desktop (40% -> 60%) have greatly increased the percentage of devices that have four or more threads.

If the engine didn’t get a core re-write and become fully threadsafe soon … it’d be time to abandon it, I think. I am convinced multi-threading will see big catch-up improvements in Unity in the next 6 months. Unity corp has the courage to roll-out all the non-backwards-compatible changes they do each major release each 12-18 months. I don’t believe they lack the courage to re-write the core … e.g. because they’ve decided it’s too amazingly expensive.

If they couldn’t do it, we as game-develoeprs would abandon their engine in favour of a modern one that is not hamstrung.

Mobile GPUs: a shattered space

Android fragmentation per se is not a problem – despite the many naive commentators who love to line up and say “there’s over 9,000 different hardware devices!”. 9,000 isn’t a problem; 9,000 with equal market-share is a problem.

GPU’s are looking like a 4-way race of equivalent shares – nightmare for developers. And they overlap in very non-predictable ways – some of the lowest-end devices have hardware specs of the high-end devices. Previously, the ImgTec share was split into multiple radically different abilities – but they were monotonically better: each was always considerably better than the previous. With ImgTec declining, deciding what rendering-path to use is even less a “if / then / else” thing, but more a complex balancing-act of heuristics.

At this point, I’m thankful that Unity takes care of it for me.

To be fair: Unity’s mobile performance is usually terrible, but I’m always grateful that it WORKS at all – i.e. renders what I expected to see! (that’s a very valuable point to start from when writing your own usable shaders to replace the Unity ones)

…But I haven’t shipped anything to mobile that uses the new rendering pipeline – GI etc. My suspicion – given all the above, and the modifications to shader development in Unity 5 – is that we’ll see mobile render performance on Unity over the next 12-24 months catching-up to be within 20-30% of what it ought to be, across the board. Or it may be there already (that’s not what I’ve heard on the grapevine of people doing high-end mobile games, but rumour is rumour – if you have any published sources on this, please share!)

i.e. “more than good enough” for all except the biggest game projects (all of whom are writing their own shaders, and customizing the render pipeline, anyway – or certainly should be! If you’re a big project, you should be pushing the tech envelope, not waiting for a game-engine company to do it for you!)

Windows, … and DX10

Can you ship DX10-only assets yet? 27% of end-users say “no”. Games may decide to drop that quarter of their sales, but asset-authors (who often take the easy route) still have to support older generations of DX, or get slammed by unhappy purchasers.

Apple, what happens when you **** on gamers?

Answer: “two thirds of them stop using OS X for games”, maybe?

I don’t know what’s caused that drop – in my experience, most of Apple’s actions against computer-owners were 2-4 years ago (deliberately selling GPUs that had already been end-of-lifed by the manufacturer, being very slow to update their graphics drivers, making laptops non-fixable, non-upgradeable, etc).

Anyone else know?

64bit vs 32bit

Apple went all-in here a long time ago; Microsoft somehow is still carrying 38% of users on 32bit. That would be all the Windows XP users, then.

Why are they still using XP? Guess: a lot of them can’t upgrade. Many GPU’s that run most games fine (on medium or low quality settings, but still look great) didn’t get updated drivers for Windows7 and Windows8. I’ve got a gaming PC that still runs XP for exactly this reason – Windows 8 is installed, but without a graphics driver, it’s impossible to play any games (thanks, AMD! Althought nVidia seems to be equally as bad).

And if you look at the games industry today, “sales are based on graphical effects” is no longer the all-encompassing thing it used to be. Graphics are now good enough that often old hardware is fine – the game studio can focus spending money on story, artistic styling, gameplay, etc.

One of the recurring problems I run into is that Unity requirs you to have precisely one “Scene” at any one time, but often you need to have multiple scenes at the same time. Problem? Yes, lots…

Unity 5 has some hacks to make it “sort-of possible” to have multiple scenes at once in-Editor.

Note: these were mentioned by Unity corp in August 2014, but aren’t available to most users yet

But they (appear to be) hacks: they help for a fraction of the use-cases. That’s fine: Unity has 10 years of software written on the assumption there is only one “Scene”; that’s an enormous amount of code to change! But can we do something about this?

TL;DR: I’ll put this on the Asset Store

If you just want a working solution, here’s the Unity Asset store page / support page, new versions will appear here first.

I’m using it myself on my own projects, and will do some beta testing with other people’s games. If it works well enough, it’ll go on Asset Store. I suggest reading this full post anyway – it’s an example of how to creatively solve small issues like this in Unity.

(if you’d like to beta-test this, tweet me @t_machine_org or email me (address at top of page). Unity Corp only let me have 12 beta-testers, so you’ll need to give me some info about what you’ll use it for, how soon, how much feedback you’ll give me, etc! Sorry :( )

Limitations, hard-coded

There can be only One!

Unity has hardcoded there can only be one Scene object. It’s unbelievably hard to change such decisions (which is why it’s famously “terrible OOP design”, and we tell new programmers: NEVER do this).

So we’ll have to do everything with Virtual Scenes: things that are like Scenes, but all exist simultaneously inside the same Unity Scene.

The universe is … not … infinite

Everything in Unity is required to have a position in 3D space. There are two positions: a “world position” (labelled “position” in code) and “local-area position” (labelled “localPosition”). In the GUI, Unity displays only the local-area position, and with parenting of objects this is frequently small numbers – 0.0, or 5.0, or 1.234324, etc.

However, every object also has a global position (calculated by adding the localPosition to the parent-object’s position), and this position is affected by the maximum size you can hold in a “float” – and more: by the precision.

So, if you place objects at (0,0, 10000000000000) … you’ll hit some very odd problems. For examples of what might happen, google MineCraft’s FarLands (where you’ve travelled so far from the 3D origin of (0,0,0) that floating-point numbers stop working properly):

“As the player journeys even deeper into the Far Lands, the effects worsen to the point where the game is unplayable. At X/Z ±32,000,000,[5] block physics stop functioning correctly. Lighting doesn’t work and the blocks, although they appear to be there, aren’t solid. If the player tries to walk on these blocks, he or she will fall into the Void. At excessive X/Z positions, world renderer no longer works, or takes incredibly long times and uses most, if not all CPU usage. It then becomes almost impossible to close Minecraft without a task manager.” – Minecraft Gamepedia wiki

Unity features we can leverage

Unity layers keep stuff apart

Unity’ layers system lets you mark things as “independent, overlapping universes”. Many missing-features and problems in Unity are officially worked-around using Layers. That’s good.

Unfortunately, someone hardcoded a tiny limit to the number of layers. As a bonus, the GUI for visualising, using, and debugging them is poor compared to most of core Unity.

So, layers work, but … a big game may not have any layers to spare. So we need to use them carefully.

Things in the same scene don’t necessarily overlap

In a game-engine, very little you see on screen is actually infinite: there’s no point. So, in theory:

• a camera can see infinitely far into the distance
• light travels infinitely far, unless blocked by objects
• physics calculations affect everything infinitely far into distance
• …etc

In practice, your camera has a “far plane” (coincidentally: for almost the same reasons to do with floating-point precision as we have with position) … light usually ignore things that are “too far away” (performance optimization) … physics pre-groups things into “near enough to worry about” and “too far away to care, for now” (massive performance optimization!).

Use cases for Virtual Scenes

Here are some I’ve run into, and felt myself wanting help with:

1. Using the New GUI / uGUI from Unity 5 into a game, without have stupid giant GUI 10-miles-high messing up your Editor view of the level
   1. Unity corp should have made uGUI have its own window for editing; they didn’t, so can we solve this?
2. If a scene has multiple areas – e.g. a world-map at small scale, and individual towns / houses / dungeons at big scale – you need it all in the same scene, but physically displaced
3. When you are embedding a preview-camera into your HUD (or GUI, or even in-scene), Unity’s implementation of RenderTexture etc requires you to construct a mini-scene somewhere inside the same Scene, but gives you no help or support to do this.
   1. We want to be able to make a bunch of these “dioramas” and switch between them
   2. …both while editing, and while trying-out different level-designs

Recurring themes:

• A lot of the cases involve embedding a camera-pointing-at-some-other-scene into your main Scene
• It has to work both in-Editor and in-Game
• In Unity, changing “Scene” is very very slow and wipes all data in the Editor; this breaks a huge amount of code and makes you write very long, painful, crappy code to workaround it. We want to avoid that and have multiple scenes that live in one Scene

Implementation / Solution

I’ve built a system of “Virtual Scenes”. The basic idea is that each Virtual Scene is a parent object floating somewhere very far away in the distance. Easy!

Most of the work so far went into adding custom GUI and window that lets you easily add, navigate, right-click move objects to/from virtual-scenes, etc. e.g. …

Features working at the moment:

1. Each Virtual Scene has its own name (can rename whatever you like)
2. Fully integrated with Unity Editor – selecting a VirtualScene in Hierarchy selects it in the Scenes Inspector, and vice-versa
3. You can right-click any GameObject / selected GameObjects and “move them to a Virtual Scene”
4. When moving-to-scene, if things have a parent, they got to the same localPosition in the Virtual Scene; this makes it very easy to organize things in different Virtual Scenes and move them to/from your main Scene
5. A SceneManager lets you easily find, view, and jump the Editor “Scene View” to each one
6. It also manages and (re-)positions them when needed (if you decide to delete some, add some, change how far “far away” is because you made your main Terrain bigger, etc)
7. They optionally have a “Scene Camera” (which is a local version of MainCamera); when you jump to a scene, it takes you to “looking hrough the Scene Camera” since that’s normally what the sub-scene is being used for
8. Setup is all automatic: if you open the Virtual Scene Manager, it automatically configures itself and adds a Virtual Scenes system to the current Scene — (this was hard to make work: I found some new bugs in Unity’s EditorWindow implementation. Sigh)
9. Everything is serialized correctly within the Unity Scene, using Unity Serialization — (this was hard to get right, since Unity doesn’t let you debug their crappy Serializer … at all :()

Features I’d like to add:

• NOT IMPLEMENTED YET: automatic managing of Unity layers, so each Virtual Scene exists in a layer of its own. NB: the Layers in Unity suck. You’ll be limited to a small number of virtual scenes, etc.
• NOT IMPLEMENTED YET: exporting / importing Virtual Scenes (SPECIFICALLY: I’d like to be able to transfer them between Unity Scenes. Unity’s “export package” feature sucks DONKEY, and still has the same major bugs it’s had for years; I can probably do much, much better)
• NOT IMPLEMENTED YET: “SceneCam” preview system: show thumbnails of all the scenes, rather than just customised names. This is useful if you have many scenes, but more just for fun and because I think it’ll look cool :).

Want an email when this goes live in the Asset Store?

It’s a test-bed for the high-performance Entity System I’m writing for Unity (more info here). I’m aiming for “gameplay considerably richer than Skyrim” with “graphics about the level of Oblivion”. To be clear: Oblivion was released almost 10 years ago! To reproduce those graphics today is fairly easy.

Challenge: Believable Cities that evolve over time

One of the things I have yet to see in any FPS RPG is believable cities, and more: cities that actually evolve. The nearest I’ve seen is the beautiful “large towns” of the Assassin’s Creed series (they represent cities, but the distances are way too small).

That doesn’t cover the “evolve” part though – even the AC cities are 100% static and unchanging. Hand-crafted, and because they cannot change (technical design choice) the player is incapable of altering them. You can’t burn down blocks, or build a new bridge. You can’t buy two houses and knock them together.

Hey, RPG industry, you can do a lot better!

This is one of the main new gameplay elements in my design. If all I managed was to take an off-the-shelf-RPG mod and add living, growing cities … I’d probably be content. What does this mean, though?

SubChallenges: “believable” cities?

A few things:

1. Cities are never EVER made of grids, unless you live in a few small enclaves of modern America, and got stuck in a timewarp to the 1950s.
2. Cities have districts, quarters, etc based on clusters of specialization. Sometimes its based on geography (“the docks”) other times on the people who work there (“the financial district”), other times on the history of the city itself (“old town” – usually the part of a city which is surrounded by medieval stone walls, embedded inside the modern city. For instance, look at London Wall in the City of London. The old wall is still there!)
3. When someone important dies: their property gets lost, fought over, split up, goes to various inheritors; the death of a person – or conversely: someone becoming rich or elected – changes the districts of the city
4. Cities GROW. London was for many centuries “the city north of the river Thames”. Where’s the Thames now? Smack-bang in the middle; the city grew along one bank, built bridges, and then exploded onto the other side.

Grids and house-positioning

In the space of an hour, I made a quick concept test to show what a city might look like to walk around:

(NB: the odd lighting is because I was testing an idea for a hand-held lantern with dynamic lighting. It kind-of works in Unity, but I’m not 100% happy with it).

Things of note:

1. Many dead-ends. This is normal!
2. Dead-ends often terminate at a door. Ideally, I believe they should nearly always have a door, or sewer entrance, or well, or … something INNATELY IMMOVABLE at the end – in the real world, an alley without a door is liable to get a wall built on the front and converted into a new house/room, annexed to one of the neighbouring houses.
   • In the UK, there are many cities where even the “immovable” things got built over. I’ve lived in houses where a sewer-cover is inside the building because the house was expanded over the top of it. I’ve also seen houses with indoor-wells (for the same reason: originally outdoors, then the courtyard got covered and became a room).
3. The city is mostly interconnected odd-shaped courtyards, with a sprinkling of broad streets. In short: if it’s empty, and it’s not full of street traffic, it gets built-on. But not in a careful, squared-off, mathematical way. No, it gets built using whatever materials are to hand, whatever lengths of wood you own, etc, so that the plans of each building and street get more and more crooked over time.
4. Hidden alleyways that are hard to spot from a distance, hidden around the corner of a building. Again, in the real world, these are COMMON (how often do you see them in games? Rarely).
   • For a modern example, in the city I live now (Brighton), there’s a network of things called “Twittens”. A Twitten is defined as “an alleyway that serves as the only route to the front-door of people’s houses”. i.e. the houses here cannot be reached at all, except via alleyway. They’re cute. People like living in them. They are very quiet even in the center of the city on a busy Saturday night – you can’t fit many drunken people in an alleyway.

Geography, Quarters, evolution, growth, adaptation

Ouch.

This is VERY HARD to simulate using random generation.

It’s been studied obsessively by western culture – the growth of towns, cities, families, dynasties, social-groups, etc is probably more of recorded history than anything except “war”. So we know an awful lot of observed facts about what gives rise to what, when, and how. But how do you tell a computer that?

The brilliant guys at Introversion Software were, for a while, working on a modern-city generator that took into account both “geography beneath/beside the city” and “specialisation within cities”. Here’s a video:

Good, eh?

But I need more than good looks: I need to store this stuff programmatically. Because it’s core to my game that I can do three things:

1. Implement quests, AI, bonuses, penalties, shop locations, etc that change based on the presence/absence of quarters in the city – and whether or not the player has “discovered” them yet!
2. Evolve the city: when the city runs the “grow city” algorithm, I need to preserve some quarters, while replacing others. I need to control that, or it will be too chaotic!
3. When the player changes the city (by being very wealthy and building new houses, or blocking-off streets, etc), I need to be able to programmatically, procedurally, detect this and re-calculate the city districts, and have the computer alter the city around the player’s actions

Solution: Generative Grammars

When I read Computer Science at Uni, the lecturers were fond of saying that the two most important things you could learn about programming were “how to make a compiler” and “how to write a new programming language”. It turns out that when you encounter a really HUGE problem, often the quickest way for a human to solve it is to write a new language that makes it easy to describe, and write a new compiler that lets the computer convert that “simple” language into vast amounts of C++ (or whatever) code.

Then you can run a normal compiler on the C++ code, and get your solution.

Using grammars in city-generation theoretically solves a lot of the above problems; in practice, it’s a lot harder than that. Mostly because it’s hard to decide what level of detail to put in your grammar!

The simple, most important thing you need to learn: BNF

If you do any programming at all, go learn Backus-Naur Form; go do it right now!

BNF is a beautifully simple way of representing most of the grammars we encounter in real-world programming. It isn’t just about programming: it’s the OFFICIAL way that all internet protocols are described.

e.g. what’s a valid email address? Can you have an @ symbol? What about spaces? Where can they go? Are you sure? … the answer is a simple BNF grammar that makes it shockingly easy to answer those questions, without any annoying verbose academic jargon. Yay!

Everyone should learn BNF. Anyway, back to the game…

How to decide? ARGH!

I spent a few weeks making mockups of cities, and transformations that would grow / improve / add detail to them. It’s tough, but I had some successes using transforms that accepted “tagged” polygons and output a new set of “tagged” polygons.

But it was quickly clear it would take weeks of work to try an idea and then dismiss it. And since this is a hobby project, that could take me half a year or more per (Failed) idea!

So I needed something smaller.

I decided to do it in 1D first. i.e. a BNF grammar on a simple string. The string reads left-to-right as a profile view of a city.

e.g.: Grass Grass Fields Farm Fields Road Big_Road CityWall GuardHouse Market Houses Houses Castle Houses Merchants Houses CityWall Beach Sea

…this lets me test ideas for GAME DESIGN (what is a “fun” level of detail? how complex do my grammar rules need to be? How many do I need for it to make interesting cities? … how much is “too many” that leads to boring cities?

At first I was visualising it using sentences, but I found that hard to work with as my cities got larger. So … I added a visual representation at bottom of the screen, using graphics I hand-bastardised using Dan’s free game art at Lost Garden.com.

I was having fun with this, but started feeling frustrated there was no point to it, even though I was making lots of mini-cities.

So I realised I could make it into a mini-game. A few hours later, and we have version 0.1 of MiniCity:

http://t-machine.org/files/cityclicker/rogue1citymaker.html (Unity Webplayer, runs in browser)

It SUCKS – yes, I know!

Right now, this is not expected to be fun; I changed the rules a few times, and found some problems I hadn’t forseen. Then I added and removed some stuff to fix them, and … ran out of free time. I hit the publish button because I think this is a very interesting idea. Don’t judge this as a game! It’s a design-tool, not a game.

BUT … on future evenings/weekends, this is something I can add to quite quickly. I’ve already started working on the 2D version: top down view of a city, using arbitrary-shaped polygons instead of bitmap tiles.

How did I do it?

In case you’re interested, I left the actual BNF transformations listed on the buttons. It’s not written in BNF syntax (sorry!) but if you’ve looked at BNF, you should easily see what’s going on.

NB: I started by writing (on whiteboard) the BNF I wanted. Then I implemented that, one rule at a time.

The rules themselves are using Regular Expressions (C#’s “Regex” class), because I spotted that this was a super-fast way for me to get somethign up and running. It will be absolutely useless for the 2D version – but Regexp’s are specifically designed to work brilliantly on 1D input (strings).

You should be able to understand what each rule does, and why it works, from looking at the button names.

Want more?

This is part of my work on Entity Systems in Unity, and a living, breathing RPG.

If you’re interested, sign up here (I’ve sent only 1 email per year so far, but hope to start sending a few more soon. Maybe 3 or 4 a year!).

A very common thing you need to during Unity gamedev – creating and testing algorithms for generating and manipulating meshes – is a pain. There’s custom classes and editors and stuff you have to write before you can create a single, basic, mesh.

One of Unity’s silly failings is that they don’t allow custom “new-project” templates, as if we were stuck in 1980 and hadn’t learned how to make IDE’s yet.

I’ve created a minimal example (should work with all versions of Unity 3.x through 5.x) which automatically creates a single mesh and scales it to fit your camera, and centers it on that camera’s screen, but positioned on Z=0, so that it doesn’t get clipped.

This solves 4 or 5 of the most common “dumb mistakes” I tend to make when trying to add new Mesh-generation code from scratch to an existing Unity project. Gives me a good starting point for new projects

Usage

The tri has center of base at the local origin of the camera, and the tip of the triangle precisely touching the top edge of the screen. This should make it very easy to visually check your meshes are generating at right position/orientation/location.

I’m assuming you’ll build your meshes in 2D; nearly all gamedev algorithms work in 2D first and are extrapolated to 3D, so that’s how I recommend writing and testing them. Once it works in 2D, move your code to a “real” game project and start doing the 3D version. This project is simply to get you up and running quickly when prototyping new Mesh-gen ideas.

I’m also assuming you’ll deal with material + texture + lighting yourself – many algorithms don’t even use textures, either because they’re using shaders (in which case you’d want to test UV too, but I’ve left that out here), or because they’re raw topology algorithms that don’t care about rendering.

So … you’ll get a pink triangle to start with. If you’re making custom mesh algorithms, you most certainly should already know how to create and attach materials in code!

Bonus: won’t delete data

There’s some code in there that each time you re-gen, it automatically gives a new name to next item, and doesn’t delete the old. You might want to remove that and have it automatically delete the old test data each time. But I erred on the side of caution.

Installation

1. Create an empty Unity project. This will have a camera by default (required!)
2. Select the camera and set it to “Orthogonal”
3. Create a new folder “Editor” (required by Unity Corp to workaround absurd bugs in Unity’s build system)
4. Create a file in that called “TestTriGen1.cs”
5. Copy/Paste the source into that file
6. Save the file, go back to Unity.
7. Wait a few seconds
8. A menu will appear “TriGen”, click the one item in that menu
9. Click your camera to see the Unity preview: you should see a large pink triangle

Code

[csharp]
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

using UnityEditor;

public class TestTriGen1 : MonoBehaviour
{

private static TestTriGen1 _ttg;
[MenuItem("TriGen/TriGen")]
public static void GenTris()
{
if( _ttg == null)
_ttg = new TestTriGen1();

_ttg.gen();
}

public void gen()
{
Camera camera = Camera.main;
float MeshDiameter = camera.orthographicSize;

string _parentName = "Gen’d tris";
GameObject parent = GameObject.Find( _parentName );
if( parent == null ) parent = new GameObject( _parentName );

int numChildren = parent.transform.childCount;
GameObject area = new GameObject("Area "+(1+numChildren));
area.transform.parent = parent.transform;
area.transform.position = new Vector3( camera.transform.position.x, camera.transform.position.y, 0 );

MeshRenderer mr = area.AddComponent<MeshRenderer>();
MeshFilter mf = area.AddComponent<MeshFilter>();
Mesh m = new Mesh();
mf.mesh = m;

Vector3[] vs = new Vector3[3];
vs[0] = new Vector3(0,1f * MeshDiameter,0);
vs[1] = new Vector3(0.5f * MeshDiameter,0,0);
vs[2] = new Vector3(-0.5f * MeshDiameter,0f,0);

int[] tris = new int[3];
tris[0] = 0;
tris[1] = 1;
tris[2] = 2;

m.vertices = vs;
m.triangles = tris;
}
}
[/csharp]

Their fault? Partly, but I don’t blame them too much – rather: Unity’s fault for failing to document (and failing to test assets before approving them!).

For those of you who aren’t happy shipping crappy, broken, buggy plugins (And charging for them), here’s a guide / reference for the lifecycle of EditorWindow. Extra info, explanations, and gotchas welcome!

This is a problem faced all the time by game designers and developers. It’s one of the most under-appreciated skills of the profession: good game developers know more about “presenting information and choices” than almost anyone else, anywhere. Because games are generally overloaded with info, and the dev teams have to filter that down and present it clearly – but if they get it wrong, the player’s in-game character dies, the game is lost, and the game itself tanks commercially. The developers then – ultimately – lose their jobs when the studio goes bust.

I’m going to start looking at non-tech examples of design and UX through the lens of game-design, and see where it goes…

Food: a fast way to self-poisoning

Here’s an interesting example where information-presentation is high-value/critical, but pervasive and difficult:

In most Western countries, the Governments ensure that all places that sell food publically – restaurants, cafes, bars, street vendors – meet or exceed good-health standards according to modern medical understanding.

Great!

But that’s a complex problem: especially, how do you “ensure”? If the food is bad, do you close down the business? The staff lose their jobs, the owners go bankrupt, the public never trusts that brand again? Is it possible for cheap food to continue existing in such a regime – or would the risk be too high, and all food would become expensive … ultimately unseating the Government itself (a population that cannot afford to eat is extermely scary to those in power!).

A common approach today is approximately:

1. If it’s dangerous, shut it down. If a vendor is – for instance – infecting ANYONE with food poisoning on a recurring basis: force them to stop selling.
2. If it’s merely risky, not poisonous but – perhaps – unhealthy: warn them, but let the public decide.

How?

UK’s 5-point Food Hygiene System

These stickers are common in UK food places. Almost everywhere has them displayed in the street window, even when the sticker says bad things about the establishment:

Thanks to the Web, it’s easy to read about this direct from the UK Government: food.gov.uk – the official website explaining the scheme.

From the website: “It’s not easy to judge hygiene standards on appearance alone, so the rating gives you an idea of what’s going on in the kitchen, or behind closed doors. You can check the ratings and use the information to switch to or choose a place with higher standards.
…
The scheme also encourages businesses to improve hygiene standards.”

That’s a huge amount of information – with enormous repercussions upon getting it wrong – that has to go out to a highly uninformed (most people don’t know, don’t care) mass audience. Let’s break it down…

Colour choice

The black border is part of the actual stickers:

This normally goes on a glass window, so the thick black border helps them stand-out, and makes sure that the pale green background is always in high-contrast to its surroundings.

The green is pretty unpleasant compared to normal Brand colours; I suspect that is deliberate.

Then the black border is re-used for the number-rating itself. So you have a contrast scheme: border – background – number. The key info has been isolated and made almost impossible to miss.

The most important info – the rating out of 5 – has been made the most visually striking item on the sticker

Weight

Let’s look at a blurred version. This is quick and dirty, but in my experience it normally maps very closely to where people look and what they notice (compared to doing proper eye-tracking studies):

1. The unselected numbers disappear; their “button shine” effect causes them to blur themselves out of existence
2. The selected number remains strongly visible: the pure flat render ensures it always has high contrast and clarity
3. The thin / narrow lines of the font-face make most of the text disappear. Combined with the thin rule separating the sections, it all takes a back seat to the rating
   • (unlike some provincial ratings I’ve seen in other Countries, where the local-authority’s own branded logo takes prominence, making their altruism appear … questionable)
4. The words “food” and “rating” stand out anyway. Bracketed at the extreme edges of the sticker, and using letters that keep their structure under blurring (compared to the “hygiene” word)
5. The “tick” is clearly visible. More on that later.
6. The numbers take up almost exactly as much weight as the title + rule + tick combined

What am I looking at?

For the ignorant man-on-the-street (most of us, I think) this is the big question: Whatever; what is this and (why) do I care?

…once I get that (OK, the title helps a lot, but people skimread a lot), there’s a few things working all at once to help:

1. Instead of a number, you’re given ALL the numbers, and one of them is VERY clearly “selected”; there is no doubt that this is an “out-of-5” rating of some kind
2. …and that the rating goes 0..5 (not 1..5, nor 1..4, etc)
3. The tick confirms exactly which rating the establishment has received. With 2-4 this isn’t a big deal – but with 1 and 5, where you might assume the number was larger because the graphic designer was bored and making it look pretty for no reason … the tick confirms “No, you didn’t misread it. This really is a 0” (or 5).
4. The tab!
   • The tab moves along with the number! No lack of clarity about whether it’s merely “bonus info”. Nope, this is explicitly part of the rating itself.
   • What does a number mean, anyway? The tab tells us!
   • The position of the tab is the 3rd emphasis on the number’s relative position. Relative position matters enormously to the public: “is this THE SAFEST place to eat? Maybe it’s not great, but IS IT THE BEST I’M LIKELY TO FIND?” etc.
     1. The numbers are all visible, and one is “selected”; the percentage left-to-right of the “selected” circle acts like a progress-bar showing how good/bad it is relative to the rest of the possibilities
     2. The tick does the same, but makes it even more explicitly “progress”-like
     3. The tab further cements this, by moving from left (bad) to right (good) with increasing scores
   • The tab is smaller than the number; why? Probably because: a few words cannot hope to give detail on this particular establishment. People understand that a number is a gross simplification, but words incline them to see it as a detailed summary. So: de-emphasize the words and emphasize the number. The words are here to shine meaning on the number, and to give reassurance. e.g. some readers may assume that “anything less than 5 means I’ll get poisoned!” – dealing with Fear, Cultural differences, and General Ignorance is a daily struggle in mass-market UX.

More thoughts…

I find it interesting that the “normal” rating is 3/5 (exactly halfway if you rated 1,2,3,4,5), but ends up positioned slightly to the right of center.

This is partly a side-effect of starting at 0, but they might have arrange 1-5 on one line, and used a different sticker (maybe a red background, for DANGER!) for 0.

However, it provides another benefit: in a well-regulated market, “average” is actually a very GOOD thing! It’s something to be proud of. In Western societies, “average” is generally associated with mediocrity and connotations of failure.

Shifting the “average” score of 3 slightly towards the “perfect” score of 5 helps suggest to the reader that they ought to be pleased with that score, rather than disappointed.

UPDATE: there’s a bug in the 1.0 version – it WILL NOT WORK if you set your Project window to 2-column layout. This is due to BUGS IN UNITY (not my code!). I have a workaround that’s in the Asset Store version, but is missing from the free version. I’ll patch it later

FreeIntelligentNew.dll – I’m not supporting this; it’s free: use at your own risk.

Or, for $2, you can get the latest version with full source code from Asset Store – I’m supporting + updating this.

Installation

Drag/drop the DLL into any folder named “Editor” in your project.

(required by Unity; this is how they make sure that Editor scripts aren’t accidentally included in your final game)

Usage

1. Select the Project panel
2. Hit shift-N
3. By default, it intelligently guesses if you wanted a new Folder or a new Script. If it guessed wrong, hit “tab” to cycle through the options
4. Choose a name and hit Enter (like normal in Unity). Done!

How…?

This works by peeking into some of Unity’s internals and detecting which EditorWindow has focus. If it’s the Project window, it uses some hardcoded constants (which differ between Unity versions, due to bugs they gradually fix, I think) to get the positions right, and offer you the popup.

I did it this way because Unity currently provides NO PUBLIC API for reproducing some of their core Editor features (e.g. where they temporarily change the render-style of the “newly-created item” in a Unity windowpane, so that you can edit the name in-line. Not possible for you or I!)

With a bit more hacking, I might be able to hook Unity’s own code and enable / trigger / alter the hidden features from keyboard, but … that’s on the wrong side of “Fragile; would probably break unexpectedly in a future version”.

How I’ve done it so far it sits independently of Unity’s code, and is very unlikely to stop working, or to cause bugs later on. YMMV…

(if you want to know more, get the Asset Store version, read the source. I’m happy to answer quetsions via the support links or in the Unity Forums page for this)

@t_machine_org any thoughts of using 128bit guids for entity-ids? too big?

— Richard Kogelnig (@RichardKogelnig) June 9, 2015

But that’s a crappy way to find things later, so I made a quick-and-dirty infographic with a few key points:

One of the Unity folk reached out to me, claimed that Unity was highly invested in improving this and asked for specific suggestions. So I wrote longer, detailed versions of each tweet and emailed them.

It’s been six months. No response. So … for Unity’s competitors, maybe looking to make/improve their own Asset Stores (or newcomers hoping to unseat the incumbents), here’s six obvious commercial improvements.

I’ve cut a few paragraphs I wrote to Unity about who I think their 3 main audiences are on the Asset Store; I included them as a “here are the assumptions I’m making” – I have no idea what their real audiences are. So I omitted that here.

NB: I’ve made the formatting webpage friendly, added some details, but this is essentially an info dump. I was too busy at the time to sugar-coat it – I figured that if Unity wanted to talk, I’d talk to them, and in person I’m really quite friendly and gentle. But at the time we were working 24/7 getting ready for a major exhibition, so this is a bit … terse.

Without stats, vendors are blind

I cannot emphasise this enough: selling on the Asset Store today is like advertising before the existence of Google. It’s absurd: the people at Unity in charge of this stuff appear to be rank amateurs at SEO, eCommerce, Advertising, etc. There is no excuse for trying to sell stuff ONLINE without metrics to tell you what’s selling and why.

So…

Set some easy measurables to gauge the health of sales:

1. what happens to sales of new assets, cohorted?
2. What happens to pageviews?
3. What’s the “reviews/purchase” ratio?
4. What’s the sales volume before and after an Asset Sale?

(if the Store is working well, the sales volume would be lower after each sale, it ought to drop-off; post-mortems by many devs suggest the opposite. In that case, the whole of “Discovery” on your store is FUBAR and needs fixing urgently: this is the initial flow of potential sales, and you’re cutting it off)

Unity’s store is ugly and impossible to navigate

Web design is a well-established skill; hire a web-design agency and ask them to design the site for you. Focus on:

1. what do people look for on your site?
2. how will they find each of those things?
3. how much effort does it take them to do so?
4. what’s confusing/misleading (and can you remove/fix that)?
5. how long is each user-journey, and how short can you make it?
6. what isn’t useful (and can be removed)?
7. …etc etc etc etc. If your Asset Store has a few hundred entries, you can get away without this (temporarily). But when you have hundreds of thousands of products on sale, it’s inexcusable

Or just copy this well-researched, well-made example that every consumer already knows how to use:

It’s also fugly. That immediately lowers people’s ambitions, gives them a negative impression of everything they MIGHT have bought, and reduces overall sales volume.

1. Build wireframes for new site.
2. Your fonts are wrong, your images are wrong, your clickable areas are wrong.
3. These should be decided by wireframe, not by “what’s easy to implement in the Unity 2.x UI”

(tongue-in-cheek; I have no idea why the fonts on the asset-store page are so poor (wrong size, poor legibility, poor kerning, etc) and the layout so weak).

But whatever the reason, wireframing for screen-size/share would be a quick route to fixing.

It’s almost impossible to find things you need on the Asset Store

COMPLETELY replace the discovery system.

At the very least, delete the search box and replace it with “search this site using Google”,
because that is MORE EFFECTIVE than the current system.

But really: search (and filtering) should only be used when Discovery is failing; there are many Discovery systems you could put in place.

The only bit that sort-of, maybe works for purchasers right now is the filtering/sorting. But even that hasn’t been thought-through: it lacks the basic essentials that most/all devs need.

1. e.g. can’t filter by Unity version.
2. e.g. categories are useless (too broad, too irrelevant; should be using a tagging system instead)
3. e.g. can’t filter/sort by “price” and “rating” simultaneously – if you hit
   the “related items” link you can’t sort by anything at all !
   • this absurd bug crops up in a couple of places on the Asset Store
   • e.g. I saw it the other day on a Sale page: the sort-by-rating link was missing
   • I don’t understand this. How can you make an ecommerce website without a Database and a CMS?
   • If you have those … these features would be one-click-enabled on every page!
4. … etc

Unity is an IDE. The I stands for Integrated

Integrate it with the Editor. Your entire audience for purchasing BY DEFINITION spends most of their time in the Editor; but you force them to stop working each time they want to use the Asset Store. You positively break their development workflow, and reduce their output; you make it harder/slower for them to make their games.

The crappy popup window (that is often VERY slow to render – why? Are you too cheap-ass to pay for proper web-hosting?) which forgets your username AND your password 9 times in 10 … is not “integrated”.

1. e.g. top-row buttons in Unity frequently vanish, requiring restart/close-open.

It’s almost as if no-one cares that the Asset Store “doesn’t work” inside the Editor. It
actively drives people away from using the Asset Store!

Rather, you want something that’s FAST and LEAN and people are happy to keep open 24/7. Normally, you wouldn’t need that – but given your flash sales, it’s amazing you don’t have it (since it would drive sales volume very effectively). Surface the wishlisting, make it
explicitly “tell me when this asset goes on sale”. Again, many many good exampels of this kind of thing elsewhere.

Before I spend, I research; I like to ask questions

Make it a source of DIALOGUE between devs and purchasers.

There is a tiny amount of this in the review/comment system, but this is a drop in the ocean compared to what could be there.

1. e.g. it’s hugely frustrating that purchasers can’t publically question authors until
   AFTER you purchase.

2. e.g. Integrate it with social networks. Amazing that there’s no twitter integration.
3. e.g. Amazing that developer-identity (who made this? Can I trust them? What’s their StackOverflow score? etc) is so hidden, relegated, hard to find.
4. e.g. 5-star ratings which 99% of the time are “we have too few ratings to give you an average, SO WE’RE GONNA SAY NOTHING” are passive-aggressive insulting to your purchasers – “we know whether this is positive or negative rated BUT YOU DON’T! HAAHAHAHAHAH!”
5. e.g. why can’t we see the percent of refunds / complaints on this product?
6. e.g. why can’t we see which versions of Unity this is being successfully used with? (c.f. WordPress’s own VERY SIMPLE and yet better-than-Unity plugin-store which shows at a glance which versions are confirmed (by users! It would cost Unity nothing to collect this!) to work with the Asset
7. …etc

It’s my money, Unity, not yours

If you won’t give developers marketing support (and you don’t), and you’re saying devs are entirely responsible for marketing and promoting their own products … you don’t get to deny them the choice of who they give it to.

If developers want to give away 1,000 free versions of their software … why are you restricting them to 12 / year?

Every dev I know who has assets on the asset store gives loads of copies away by email – no DRM, nothing. Simply trust. None of them want to. But Unity won’t allow them to do it on the Asset Store!

This REDUCES footfall via the Asset Store, and ENCOURAGES off-store sales. That seems, from the outside, to be the opposite of what you want to be doing.

PS: thoughts

Let me be clear: this is a lot less than a complete list of improvements I’d make. These were merely the off-the-top-of-my-head-obvious things I was thinking about at the time.

When I emailed Unity, I offered (explicitly) to talk to them about others – even offered to meet in person (I live less than 5 minutes walk from one of their major offices!).

I got silence. Which reinforces my very first point, from January 2015:

@t_machine_org ..I suspect self-fufilling prophecy: they're not getting rich from it, so management refuses budget to fix it. Vicious circle

— Adam Martin (@t_machine_org) January 3, 2015

This post is an experiment: rather than write massive, heavily-edited articles, I’m writing “shallow” versions first, which takes me only an hour or so. Then I’m saving the in-depth, detailed versions of each topic for future subscribers to my own Unity3D Entity System. This way I can cover a lot more topics in the same amount of time, and I suspect most people will get all they need without the deep dives I used to do.

Let me know what you think – @t_machine_org

The Unity bug that deleted my game prototype

A few days ago, I fired up my Unity3d test project for the new Entity System. All the data was serialized into Unity’s scene, everything was fine. I was expecting to see all my “registered” components (that are saved directly into the scene) exactly as they were last time:

Instead … I got this. Why, Unity – WHY?

On further inspection, Unity’s serialization system had stabbed me in the back: it combined data from two different situations (which is blatantly wrong and should be impossible – although since Unity has failed to document it … who knows what contracts it promises to uphold internally?). I’d like to know why…but the Unity Editor won’t tell me (they don’t let us see this data).

But I don’t really know what happened. Even with extensive logging, Unity lacks a solid debugger – and most of Unity’s code here runs BEFORE your debugger starts or AFTER your debugger stops. Any Unity bugs here are happening inside the invisible, opaque, known-to-be-buggy, Unity startup/shutdown routines. ARGH!

Software … has BUGS! OMGWTFBBQ!

Unity has bugs. Lots of bugs. So does all software. So what?!

Some (many?) of Unity’s many bugs sit in mission-critical parts of the engine. Rumour suggests that’s not because the devs are unaware of them – quite the opposite! – but because they’re too hard to fix. Any mistake in the fix, and it might cause more harm than the original bug (because these systems are so core).

This in itself suggests Unity’s internal dev teams maybe lacked a culture of TDD in the early days. My impression was that they do significant TDD now (yes? no?) but if it only arrived recently, then much of their code might be weakly tested or even untestable. i.e.: I try not to be too hard on them here, even when I’m suffering and there’s no help to be had.

In particular with Serialization: Unity doesn’t allow anyone to see what the bugs are. The Serialization system (along with some other super-critical-data-corrupting-bastard-evil-features of Unity – like the Undo system) has no API to let people outside of Unity corp see WTF it’s doing.

And we know it has bugs. But we can only guess at them, and how to workaround them. Unless you have a million dollars spare and can afford to purchase source-code access…?

Incidentally, this is why it is standard in the games industry to demand source-code access to your game-engine. This is non-negotiable. It has always been a black mark against Unity in professional / experienced gamedev teams that they are so secretive about their source code. It would be fine if they had a high-quality, Automatically Tested, well-documented accurate API, etc – but they don’t.

I have an idea … a new feature for my Entity System

At this point, I’ve already accidentally built quite a lot of the pieces of a debugger for fixing Unity itself. I’m recording the exact data, I’m storing it in memory in raw bytes (which sidesteps all the bugs in Unity’s undocumented serialization layers), and I’m displaying live data-visualizations in human-readable pretty colours, etc.

Enter: the Entity Systems Journal.

What’s a Journal?

If you don’t know, and you care about programming that involves data or storage, read this:
http://en.wikipedia.org/wiki/Journaling_file_system.

In the event of a system crash or power failure, such file systems can be brought back online quicker with lower likelihood of becoming corrupted.

What’s an Entity System Journal?

As many people have noticed, while experimenting with Entity Systems for their games, an ES is very easy to integrate with Event-driven programming.

You’re changing raw data which has no side-effects; that makes it very easy to write generic code that automatically converts every “change” into an “Event object” that the rest of your app / game can programmatically inspect.

With an ES, we’re going to use a Journal to record exactly what happened to your entire game-state, at all times, and in all places.

Journals in AAA Gamedev

To be clear: in an abstract sense this is nothing new, games have been doing “journalling” (But not calling it that!) since the 1990’s, when it was discovered to be a very effective way of making multiplayer / internet games run reliably while sending minimal data over slow network connections. Read about the early RTS implementations (Anything from Patt Wyatt’s blog, or the old Ensemble Studios gamasutra piece about 10,000 archers IIRC).

What makes this a little different is that we’re going to be a lot more … explicit … about it. Our Entity Journal will come with its own cross-platform API that’s easy to write tools for.

Considerations

a.k.a. “lessons learned in software design and architecture over many years and from standing on the shoulders of giants”

1. The API itself might be best expressed using one of the API’s we’re already using to access and/or manage data elsewhere
   • aka: the “don’t screw-up like XML version 1 screwed up” rule; XML (a data langage) invented a second language to describe its data. Until they woke up one day and said WAIT A MINUTE … WE ALREADY HAVE A DATA LANGUAGE!
2. Whatever first-class objects exist in the API need to be few, simple, and generic
   • Journals are a bit like Entity Systems: the simpler the API, the more robust and easier to optimize performance – and re-use with all the world’s generic data
3. The Journal is a lot like Quake3’s networking compression; however we build it, it OUGHT to be compatible with that when finished
   • i.e. once this is implemented, it ought to be re-usable “in server mode” with almost no code changes to provide a multi-host non-uniform distributed event log and playback system. “ought to”.
4. From a tools perspective, we want to click on any Journal event and see the exact state of the entire Game at that point in time
   • Game Debugging … on steroids. BECAUSE WE CAN, THAT’S WHY
5. …which’ll destroy C#’s crappy Garbage Collector.
   • So we’d better be aggressive about using weak references and/or converting “old” data into “summary” data, and dumping the data itself
6. Just like an FS Journal, the ES Journal should allow us to reconstruct our entire game data at any point in time, so that we never, ever lose data, no matter how many bugs in Unity we encounter
   • Unity: your refusal to debug and TEST your own frickin’ “undo” implementation? Yeah. I’m looking at YOU!
   • Make a stupid mistake in your game-code and accidentally delete critical stuff while in Editor? Not done a git-commit recently? NO WORRIES! GO BACK IN TIME AND RELOAD IT! YEAH!
   • Find a bug in the Entity System itself? (shock! Horror! But also: guaranteed to happen) … well, we’ve got you covered ;)
   • …(which leads to the next point)
7. This absolutely unfailingly guaranteeably … must not have any bugs in it.
   • Unit Tests FTW
   • This is our equivalent to Unity’s Serialization: everything will rely upon the assumption that “the Journal will take care of it”, making the Journal our weakest link / most critical code
   • KISS: the simpler we keep the implementation AND the API, the more confident we can be that it works at all times in all situations

Building it

Yeah, well … that’s going to be a much longer article (or three!)

Want more? Want to support this ES in future?

…Sign up here to be kept up-to-date on the project’s upcoming Kickstarter / Patreon / whatever-it-ends-up-beign (if you’re already signed up, it won’t add you again)

Three parts:

1. First: introduction / overview of Entity Systems, and why you care (as a “person who makes games”)
2. Second: Progress so far: screenshots of the Unity Editor with explanation of the new features I’ve added
3. Third: Challenges and solutions I’ve encountered so far

Aliqua-progress-2015-BUUG-v3

WordPress, HTML, the web etc – don’t support “presentations” yet. No, I’m not creating a fake Slideshare account just so you can wait ages for a non-bookmarkable slide viewer to (slowly) load. Until then … we have PDF. Enjoy!

But …

C# doesn’t allow you to efficiently use structs nor objects

C# objects are a little inefficient in memory usage and iteration speed (when you compare to raw underlying data). That’s fine for many people, especially corporate programmers who never encounter performance issues. But it’s not fine for us.

But it’s cool; C# has structs that offer almost exactly the same behaviour as C structs: highly efficient memory and iteration.

But … but there are only four ways you can write code that uses (reads from, writes to) C# structs, and they all suck donkey.

C# sucks 1: Forget OOP, forget methods/procedures/functions

Pretend you got in a time machine and are living in 1965, before programmers started using “procedures”; write your app as ONE HUGE FILE WITH ONLY ONE METHOD. WHY AM I SHOUTING? WELL BACK THEN THEY DIDN’T HAVE LOWER CASE LETTERS ON THEIR KEYBOARDS EITHER, AND I’M BEING AUTHENTIC.

C# sucks 2: go ‘unsafe’

C# does not allow you to return a pointer-to-a-struct. This fundamentally undermines the concept of a struct. It’s particularly bad considering C# has an unhealthy obsession with copying things around in memory all the time, especially when it has no need to and is (literally) wasting CPU cycles at a very low level (significant impact on performance in large data applications – e.g. games).

But … well, I told a lie. C# does allow precisely that: except people at Microsoft decided normal people can’t cope with pointers as a concept (a lot of truth in that) and/or that making pointers “safe” would reduce the performance of them in extreme situations (a lot of truth there, too), and so … anything in C# that even thinks about a pointer won’t compile unless you convert your entire app into a “C# unsafe codebase”.

I normally am more than happy with C#’s ‘unsafe’ concept; it’s a nice idea. e.g. it’s a great way for me to see at a glance whether my team mates have gone and put some potentially ruinous code in our codebase and hence I have to be as cautious as a C programmer. I’m only unhappy at the moment because C# has less than universal support for executing unsafe-compiled code at runtime.

Unity can’t/won’t build in “unsafe”-mode: the Webplayer is incapable of running code compiled in this mode, so Unity (rightly so) disables it globally. You can re-enable it, but your game will crash on start on some platforms.

Other languages (*ahem*Java*ahem*) allow for both “competely unsafe” pointers and “protected against damaging Java, but up to you to protect your own code from itself” pointers in parallel. It would be nice if C# did too. There’s a lot of places where C# takes this “Well! if THAT’S what you want, you can HAVE IT! THERE! DO YOU LIKE THAT?? DO YOU!??” all-or-nothing binary option for the programmer. It would be nice if it recognized that real-world programming is a much more nuanced process.

C# sucks 3: destroy OOP: pass internal data structures back to callers

One of the tenets of OOP, one of its greatest benefits, is data-hiding: classes can (and nearly always do) take any internal state and mechanics that are NOT part of their contract with the outside world, and prevent the outside world from seeing them. Code is easier to write (classes have fewer things for you to read and think about when trying to use them), and maintenance and debugging is MUCH easier (there’s less to worry about; many little silos that can be independently tested and debugged).

Well, a workaround to C#’s little problem with structs is this:

1. When you want to read “struct for entity #1234”, you call “.GetStruct( 1234 )”
2. The callee does NOT return you that struct (C# won’t let it do this via pointer, unless you go unsafe)
3. Instead, it returns you the ENTIRE ARRAY that the struct lives in
4. …and the integer index into that array where your struct lives
5. …because C# DOES ALLOW you to return pointers-to-arrays that contain structs (just not directly to structs themselves. Ironic, that)
6. Caller now has to be intelligent enough to:
   1. Combine array + index to find what it wanted in the first place
   2. VERY EXPLICITLY IGNORE everything else in that array; one slip of the index, and all hell will break loose

Congratulations! You just hard-coded every piece of game-logic in your app to the specific set of arrays that you use to store the back-end data.

What’s that, Little Johnny? … You came up with a new data structure that’s 10x as efficient, and want to replace it? … Uh … forget it. You’d have to rewrite 90% of your codebase.

C# sucks 4: There’s a delegate, that delegates delegation. Delegatedly

All the above suck. There’s one more way out, one that doesn’t involve dropping good OOP principles (not exclusive to OOP – so good that they’re used all over the place, pre-date OOP by a decade or more). But … it’s tortuous. It’s so complex to use you’ll want to shoot yourself rather than write any more game code. Which removes one of the main benefits of Entity Systems in the first place (you get to keep “performance” but you lose “easy writing of new code / changing old code”).

C# won’t let you “return” a pointer to a struct – but it will let you “pass” a pointer to a struct as a parameter to a method. WTF? What the ACTUAL ****? Yep! No messing; it really does do this.

So…

1. Callee defines a C# delegate (google them if you haven’t used them; it’s a fancy/clean way of allowing pointer-to-function)
2. Caller says “Get( Component blah, EntityID blahblah, delegate DoThisToTheThingI’mGetting() )”
3. Callee gets the component, as expected, and then manually runs “DoThisToTheThing…()” on the object
4. Callee hopes nothing goes wrong, because it’s going to be a PITA to inform Caller of that fact in a sensible and efficient manner
5. Caller gets messy
6. Debugging makes you weep
7. Junior Programmers on your team look at what you’ve done and cry
   • WHY? WHY ARE YOU DOING THIS TO ME? I WAS AN INNOCENT!

Plz Fix C# nowz, KTHNXBYE

There’s a simple solution, and it’s proposed for the next official version of C#:

Make C# allow you to “return ref (struct)”

There’s plenty of people who hate the idea on principle (the principle being, apparently “I have no idea what this is for, but I don’t like structs, they’re something to do with C? I think? And I never use them – so you shouldn’t either!”. Yeah. Me, bitter? Noooooo…), so support for this going in isn’t universal.

I don’t blame those people: they’re happy living in their professional environment where they never have to marry high-performance code with mass-market deployment. But that doesn’t mean we should accept their stance. I encourage you to reach out to them and help them see the value of this minor tweak to the language, and do what you can to get it approved and added.

NB: I say “minor tweak” quite carefully; Eric Lippert (formerly of the C# language design team, IIRC?) has publically stated that the feature already exists in the runtime, but C# compiler is not allowed to use it, and that he’s personally tested and proved that it works fine to enable this in C# – the runtime works without needing changes. Technically (I’m no expert here, but it seems legit) it appears to be legal to go and hack your C# compiler to support the feature, compile some code, and then use it at runtime alongside “ordinary” C# code.

So, yeah – we should support this.

Also, future teachers will thank us for making the language just that little bit more consistent with itself (you can ref into a method, you should be able to ref out).

Moving on: let’s start copying memory!

Now that I’ve ranted and obsessed and spent more time than anyone should worrying about avoiding copying memory … I’m going to advocate copying memory!

Muahahahaha!

There’s an enormous difference though between what C# imposed and what we actually want to do deliberately: we’re only interested in batch copying. i.e.:

1. Copies are created infrequently (at most: once per frame. Ideally: only a few times per second)
2. We copy large blocks at once, not individual items
3. There are genuine benefits to having a copy rather than the original (i.e. this will NOT be appropriate for all algorithms; but it is for most that we care about)

A unity example: The Unity Editor OnGUI Refresh is 100 times per second

That’s a long subtitle; many many MANY Unity developers are blithely unaware of this fact. It’s right there in the Unity docs! (it didn’t used to be, but is now, so you no longer have any excuse). Unity’s Editor refreshes the screen at 100 FPS. Thats a heck of a lot of pointless wasted work if nothing’s changing – and even if it is, there’s very very little in an Editor GUI that needs updating so fast.

(There’s very little that needs updating more than once per second; even the smoothest of editor features will usually be fine at 10-30 FPS)

Editor GUI is often doing much harder work than the final game – it has to work with not-yet-optimized code and dynamically changing data that will be fixed, static, and made much more efficient by compiler/build process before it goes into the game. So … we’d really like to keep it nippy.

What we don’t want to do is this:

• 100 times / second:
  1. Fetch all entities
  2. Fetch their “name” component
  3. Construct strings for all of them to display
  4. Redraw window segments and background colours for each item

Now, all Unity devs should (these days) be well-educated in being conservative about OnGUI implementations – don’t recreate stuff that isn’t changing frame to frame (e.g. background texture references). But how do you avoid re-doing it when the set of data you’re rendering could change at any moment?

Enter … the COPIED list of entities (not pointer-to-…).

What would you actually want?

Something like this:

1. OnGUI:
   1. For each: cached entity-name / entity ID pair:
      1. Draw the name + entity ID to screen
      2. Allow mouse to click on any row
      3. Clicked row triggers an Editor event “Entity with ID = BLAH was selected”
   2. Refresh():
      1. Whenver called, this re-populates the cache of “entity name + entity ID”
   3. Only two arrays are stored at class level:
      1. int[] entityIDs
      2. EntityName[] entityNames

…although clicking a specific row will trigger the Entity Inspector window to load up the complete data on that entity, the main GUI doesn’t need that info.

i.e. the amount of data being duplicated in RAM is going to be tiny, even on a huge game with a vast number of entities.

If we get to – say – 100,000 live entities then the RAM numbers will no longer be “tiny”. For most platforms, they’ll still be small enough that we probably don’t care in this particular case – but more likely at that point we’d be using filters to reduce the number accessed at once.

e.g. in the GUI we’d only display “1000 most-recently changed” or “1000 entities at a time” – no GUI will meangingfully display 100,000 rows on screen at once anyway.

Copying in C#

This, at least, is easy. C# today (2015) is extremely efficient at direct array-to-array copy (as you’d hope!).

So fast that even if you try to get “clever” and go re-implement array-copying in “unsafe” mode, using raw pointers … you won’t make it much/any faster. You might even slow it down.

Allocation, Shmallocation

Naively, we’d do each copy by allocating a new array of appropiate size and copying into it.

“But allocations are slow!”

Yeah, yeah – not when you’re doing 1 of them per frame they’re not. They’re only slow when you’re re-allocating once for every entity in the game. We’re allocating once, in total. So we don’t care.

But potentially you might care, in which case you’d want to make the “copied array” store into an array of memory shared between the caller (game logic) and the callee (the entity/component store). That’s fine. Standard practice: optionally the caller passes-in a pre-allocated array, and takes responsibility for ensuring it’s “big enough” for the data that will go into it (and for not trying to read/write to it on another thread until after the callee has finished copying into it!).

Any colour you want, so long as it’s black

When do you want the copy, and when do you want the zero-allocation original?

Who gets to decide?

In the long-run, I want it to be non-optional: everyone gets a copy. But that will require some re-architecting of my thinking on standard algorithms I’m used to using (and re-thinking some libraries I already re-use). So, in the short term, I’m going for “caller gets to decide”.

[csharp]
public enum EntityListType
{
REFERENCE, CLONE
}

/** Returns a C# structure you can "foreach()" over.
Defaults to a zero-copy reference, but optionally will
clone it for you.

The foreach() structure can be re-iterated over multiple
times (as expected by C# spec). The cloned one can be
iterated as many times as you want – it’s your private
copy. The (default) referenced one you do need to be
careful about multi-threading, since other callers
may be reading/writing to the same areas of memory.
*/
public ArrayEnumerable<T> all<T>( EntityListType listType = EntityListType.REFERENCE );
[/csharp]

TL;DR

C# needs “return ref” added to the language; .NET already supports it explicitly; rant rant structs pointers unsafe-mode rant; sometimes, copying is a good idea.

Support me on Patreon, writing about Entity Systems and sharing tech demos and code examples

A minor epiphany

I’ve always known it felt like Writer’s Block, and blamed myself for the inactivity. Other people – from my teachers and parents onwards – accused me of rampant laziness, when the opposite was usually true: I was slogging away, exhausting myself, and nothing was happening.

This week, in the middle of broad range of these all at once, I noticed a pattern: the things that block me are decisions where I have literally no idea what the comparative impact is of the different alternatives. I have many ideas for what might happen each way – but no experience or information to tell me how (un)likely each one is, nor how severe (or insignificant).

Life experience has taught me over and over again that I have a high rate of making the “wrong” decision in such cases, and causing myself great loss. My perception of the cost of being wrong seems to increase each time I have to make these kinds of decisions; it only fades when I have a long string of “normal” decisions where I have even a small amount of information to go on.

Coping mechanisms

One of my learned behaviours in these situations is to look for some other high-value task to work on instead. It’s a kind of running-away, but one that produces strong results (albeit in a different area), and so the net outcome is usually positive.

Tasks I tend to jump on are:

1. New game-designs
2. New technologies that don’t exist but ought to
3. New tools that would speed up my workflow
4. New tools that transform our work: they make the impossible become possible
5. New products
6. Experiments on things I’ve previously run-into and concluded: “I really don’t understand this”

Now I’ve put that down on (metaphorical) paper, something screams at me that’s missing from that list:

There’s many good things on the list, but nothing that actively increases my knowledge of the different alternatives I’m being asked to decide upon in the first place

Arguably: I’m doing the exact opposite of Eric Ries’s practical interpretation of Lean Startups: Always be testing/gaining knowledge of the thing that you understand least or fear most.

By definition, in a startup (where you never know more than 1% of what normal businesses know about their environment) … that is always your highest reward / lowest cost option; that knowledge is worth more than anything else you could be doing right now.

Self deception of the Startup Founder

Is this a problem? Often: no.

Especially in a startup, where there’s always 10x as many “urgent” things to do as there is time/manpower to do them … the chances are that whatever random distraction you pick to work on will be just as valuable to the business as the thing you got blocked on.

But this is a deception: it’s only through random luck that the net outcomes are positive. The better you understand your business, the more likely you’re already working on the most important items. In which case, the things you choose to work on instead of being blocked … are lower value than the ones you’re avoiding.

Therefore, I believe this is a bad habit I need to eradicate. I’m sufficiently good at sufficiently many things that I’ve historically been able to make up for the damage this causes. If I could get rid of it, I would achieve much closer to my true potential. That’s a big win.

Cures for analysis paralysis

From Wikipedia’s article on Analysis Paralysis:

a choice is never made, rather than try something and change if a major problem arises

…and this is probably why I’ve always found zero value in the concept. Every one of my paralysed decisions are ones where there is no possibility of changing if any problem arises.

They are always decisions of finality.

Often, it’s because other people / other organizations are so incapable of changing once a decision has been made. Looking back, I’m very good at blasting through this kind of paralysis wherever I have a powerful position over the other actors I’m working with.

For instance, where the decision will affect a small sub-contractor who’s beholden to the large organization where I’m working … and I know that if I twist their arm, they’ll renege on any strategy we caused them to start upon. I know that if things go wrong, whether or not they want to change, I can make them do so (for their own good, and ours).

Digging deeper into Analysis Paralysis

AP situations are characterized by large amounts of research, planning, etc. 10 years ago, I used to do that; it was mostly because I was taught to do so, by Employers, Teachers, and Society. It was a bad lesson that is still widely taught today.

I escaped that trap many years ago. In my early 20’s I discovered that much of the received wisdom in how to run companies and products was – frankly – complete bullshit. Mostly it was wild extrapolation by people who’d benefited from others’ innovation, but never had to take the risks or do the work themelves. After that, Scrum was a huge help to me: it said “look, you were right: there are completely different ways of working and structuring work with other people. Here’s one of them – and it looks like nothing you’ve been taught, but a lot like the things you’ve been discovering by accident actually work“.

So … screw Analysis Paralysis. And scorn any individual who levels that accusation at you. They mean well, but they are peddling a neat-sounding phrase they don’t understand, applied to a situation they don’t know.

Seeking other ways forwards

Thinking back to my introduction to Scrum 10 years ago, I see a lot that might be applicable here. Nothing about Scrum itself, but instead the abstraction “discover new process that re-inforces and celebrates things that I know work, but was taught to avoid; proceed to embrace those things”.

Uninformed high-stake decisions are scary. I’m highly educated with an extremely creative background coupled with an extremely strong grasp of Mathematics and logic. Given any situation, even convoluted and intricate ones, I can rapidly and relatively easily extrapolate forwards and predict multiple outcomes, all in m head, with a high degree of accuracy.

TL;DR: I have a high success rate of predicting the unpredictable. As a result, when I have to make a difficult decision, I very nearly always pick a “winning” route. I estimate I pick a better than average (“good or great”) route approximately 90% of the time.

I also have an insanely high rate of predicting low-probability events. If something is only 1% likely to happen, and I declare it’ll happen, I’m right perhaps 50% of the time or more. If I’m unsure, and say I think it’s a high possibility, I’m right about 20% of the time. This is not luck: it’s intuition and prediction.

Let’s compare them:

Paralysed decision: Random unpredictable (50/50) outcome, no possibility of adapting after the decision

vs.

Standard “Difficult” decision: Highly predictable (90/10) outcome, and/or many opportunities to adapt to poor/unlucky decision

Oh. Right. Now I see why I get stuck. Why I’m paralysed. It’s nothing to do with over-analysing (as others sometimes believe). It’s simple risk/reward. I’m like a 20/20 vision knife-thrower being asked to work blindfold in the dark with unfamiliar knives in a venue I’ve never been before. Ouch.

Conclusions and practical steps

Writing this has given me two concrete ideas. One is intuitive, the other is a self-suggestion from noticing that I was doing the opposite of chanelling Eric Ries.

1. Blast it with repetition

Shy geeks who struggle with dating are given a recurring piece of advice when too scared to approach potential dates: Do it 100x times more often than you are right now. Fail over and over and over again.

Fail until failure itself becomes meaningless. Until you start to seek out failure instinctively, and have to stop yourself, because it’s become so natural to you to “fail” – you’ve rewired your previous instinct that you ought to avoid failure.

In practice: Pro-actively seek out these kinds of decisions. There are probably lots of them lurking in my week-to-week work and life, but not important enough to bubble to the surface. Normally I’m happy with that – they’re like sharks, and I’m subconsciously ignoring them hoping that by the time I am forced to confront them, the situation has changed and they’ve become cuddly dolphins instead. But I could seek them out aggressively, throw myself at them. Better to do that when they AREN’T (yet) critical!

2. Channel Eric Ries: kill it with data

Paralysed by a decision whose outcomes you don’t understand, or can’t evaluate? The answer is simple: think of an action you can take that would give you some extra information about one (or more) of the outcomes – any information, no matter how small, for any outcomes, no matter how few.

In practice: With people, be bold in asking them what outcomes they see, and how they would be affected. In my experience, this will only work if done promptly and very briefly.

In practice: With commitments, invent a smaller version of the commitment and try that. Try multiple smaller versions, and commit in different decisions – evaluate what happens and then return to the Big One.

In practice: With organizational strategies, outsource resources to attempt one or more strategies at once on a small scale, as “tests”. Monitor what happens, do NOT use the outcomes to predict what to do (your team is not the same as the outsourced team). But use your observations of what happened to the outsourced teams to predict and evaluate what might happen to your team. Critically: this requires you have a deep exposure to the day to day challenges and outcomes faced by the outsourcer; having them go silent and deliver a Fait Accomplit is entirely useless to you here.

It’s a year and a half since I wrote about choosing Data Structures for high-performance Entity Systems in A-AAA games. I always had a followup post in mind, but never wrote it down (thanks largely to the demise of #AltDevBlog). These days I’m too busy to write such big articles, but it’s long overdue … This post is a shorter version of what I had planned, but should have enough to get you going in the right directions.

Recap … what we concluded last time

If you haven’t already, then you should read the previous post on Data Structures. Diagrams and everything! But to save time, here’s a recap:

1. A medium/large desktop game will have:
   • 100’s of Component types
   • 10,000’s of pre-made templates for game-objects
   • 100,0000’s of entities in live game
   • 100’s of bytes storage per Component
2. Contiguous memory storage is the holy grail
3. Processors usually read MULTIPLE Components at once, per-Entity
4. It’s easy to make memory optimal for any one set of Components, but almost impossible for all the different combinations of Components that you see on your Entities
5. We can achieve a lot by messing around with only small differences in how we fill / layout our Arrays in memory
6. Versioning (keeping multiple copies of the same variable at once) was completely ignored, other than to say “we’ll need it, and none of these approaches help at all”
7. Fragmentation is a recurrent nightmare

That article focussed on “core” / basic questions of memory-management for Entity Systems; this one will focus on the networking and multithreading issues issues for memory-management. These features are a huge advantage whether or not you do any networking, but it gives me a source of concrete examples for how/why/where you’d want them in-game.

Data needs: going beyond a single thread

…Networking

How do you implement good quality real-time multiplayer networking in a computer game? I used to be an expert on this … a decade ago. How it’s done today? I’ve no idea; I get the impression it’s much the same: the main limitations 10 years ago were “the internet isn’t perfect” and “nothing can go faster than the speed of light”. I don’t think those have changed?

So I’m going to point you at one seminal work if you’ve not read it: Google: Quake 3 networking architecture, with a very short summary of key elements here.

Networking: takeaways (not just from Q3)

I used to be a Network Programmer in a AAA studio. Off the top of my head, these are the generic requirements that most/all game-networking subsystems have of their data / memory management:

• Changes to game-state are stored efficiently (less RAM = fewer bytes over internet = faster responsiveness)
• Game-state (and changes to game-state) are easy to serialize/deserialize at low CPU time, and work for all current and future game-logic/game-classes, without ever rewriting the code
• Server and Client easily hold many different copies of the complete game-state at any one time
• All changes to game-state are tracked, no matter which code in which thread on which CPU made the actual change (so you can diff it, both client and server)
• The networking layer knows the “true” game-state; all other parts of game (rendering, physics, AI) are using multiple, different, deliberately incorrect copies of the game-state. This e.g. lets rendering hide rubber-banding by faking on-screen positions of players.
• …TBA: probably several others I’ve forgotten…

Threading: takeaways

For threading, we want:

• As much data as possible is read-only. Ideally complete data-structures.
  • With read-only data, many CPU’s can access at once at full speed without having to write any MT code
• Mistakes in MT code are some of the most expensive to debug in programmer-time. You can waste literally months solving simple problems – months you couldn’t afford!
  • Our MT code needs to be idiot-proof.
  • As much as possible, our MT structures and methods should be “invisible”: they happen automatically, without us ever having to “remember” special rules when writing game-logic
• Different subsystems can and should run at different frequencies.
  • Rendering at 60FPS? Cool! But your AI shouldn’t, your Physics doesn’t have to, etc
  • You can buy a lot of performance (when you’re having trouble optimizing your frame rate) simply by running some things slower
  • When debugging, it can be a huge advantage to slow down (or stop/pause) some systems around the key point, while others keep running. The volume of debug data you’re watching becomes smaller and more (humanly) manageable.
• Unity sucks at MT code
  • If you ever wonder “does Unity have a weak/crappy core architecture?” look no further than this: Unity3D in 2015 still cannot run on multiple threads
  • You can work around it; we will work around it. But it’s likely to cause recurring challenges.

Solution 1: Ctrl-D the Universe

Long story short: one interesting possible approach is to combine all the above and re-think our arrangement of memory at a more abstract level. Instead of “storing our data in a (set of) data structures”, let’s “store multiple overlapping copies of the same data in different places in memory”.

Key benefits:

1. When you spin-up a new thread/CPU core: Duplicate the current game-state, give it to that thread, … Profit! (no MT code to worry about, it can get running immediately)
2. Networking can hold different copies of the game-state based on “time” and “ACKnowledged server/client state”
3. BONUS: you can cache frequently-used Component-lookups (e.g. “all entities with a Physics Component and a Render Component”), especially read-only ones, into tightly-packed, highly optimized data-structures

(That last one should be ringing some bells from the previous post … best of all worlds, yes?)

Using it: API for the data-structures

Originally, our Data Structures were really simple – just an array. The average programmer could easily remember how to use it. Then it became a set of similar arrays. Then a bit more funky array with internal state. Now … now, it’s getting complicated. To keep it idiot-proof (and let’s be honest: all programmers do something idiotic, sooner or later. Where do you think bugs come from? :))

Quick and dirty needs for our API:

• Get me a (set of) data structures that represent a new Copy of the Universe
• Give me a customized Copy
  1. …give me only specific Components, from specific Entities
  2. …give me the Copy as at a specific moment in time
• Merge my changed Copy of the Universe with other people’s cop(ies)
  1. Update mine by applying changes from N specific copies with mine
  2. Update all of theirs by sending my changes out to N different other copies

In practice, this forces into a couple of architecture-design activities. We’ll have to codify our main Data Structure for lists-of-components, we’ll have to define our filtering/search parameters – and the algorithms we’ll support for filtering. We’ll also need a representation of “which” copy of the universe is which, and some concept of a “master” copy that all others merge into / update from.

Thinking ahead, the easiest implementation strategy will be to break this down into “deltas”. Each Copy will be stored / defined as “how it is different from a reference/base Copy”. This makes a lot of the operations above much easier to implement, and it’s also a highly efficient way to store, debug, and act upon the complex data.

Start thinking about your favourite SCM (Git? Mercurial? SVN?), and how it’s implemented; such knowledge will come in useful

Basic implementation 1: Events

Conceptually, the easiest way to implement this is for every change to any piece of data to be stored as an Event. Your storage of data is simply storage of lists of events.

This is grossly inefficient. To find out “what’s the Position of object X?” your CPU has to iterate over every change that has ever happened to X’s position, and apply each change, one by one … all to find out one single value.

You could do it this way; let’s not even go there.

Implementation 2: Copy on Write

Another simple approach is for each Data Structure to wrap two internal DS’s:

1. Base copy (All Components for all Entities)
2. Changed subset (Only the Components that have changed, only for the Entities that have change)

This has a few benefits:

1. Fetching “the current value of variable V on Component C” is a single lookup: directly access that Component from the Changed subset
2. Merging this back onto the original you copied from is fairly efficient: iterate across the Changed set and clobber the original’s Components, via direct RAM copy / array-copy
   • It’s not hugely optimal: you’re copying probably tiny pieces of RAM at once, rather than big, contiguous sections
3. Assessing “how much” has changed is trivial and fast: count the size of the Changed set
4. Memory usage is at worst twice the original, three times in total, but on average a lot less
   • …unless your use-case for this particular Copy is to change EVERYTHING (e.g. the Movement Processor looping over every Position Component and changing every single one of them, adding their .velocity to their .position)
5. We can safely delete Entities and Components in one thread, and it won’t cause any dangling-pointers or memory leaks elsewhere
   • …but merging two Copies where one has deleted the Component and the other hasn’t … will require some careful design, and careful coding

There’s still a notable weakness: if you want to store many Copies that differ by a small amount – e.g. a Server storing the ACKnowledged game-state for each Client – you’ll end up wasting huge amounts of RAM for the spammed “Base” copies.

Other implementations…

There are plenty. I leave them as an exercise for the reader ;). Feel free to suggest in the Comments below (as noted at the top, this post isn’t ideal – I don’t have time to do an exhaustive look at the topic. But this should have got you started…)

Next Steps

I’m off to try this out in C#, and see what challenges arise. In the meantime …

Support me on Patreon, writing about Entity Systems and sharing tech demos and code examples

How to store game data: GameObject? MonoBehaviour? ScriptableObject?

Those three pillars of Unity’s architecture are the curse of game implementation and performance. Architecturally, they’re great: they’re a big part of what makes Unity easy for newcomers to pick up and understand within hours, instead of taking weeks.

On large Unity game projects, they’re hated for being slow and hard to work with when you get to hundreds of thousands (or millions, tens of millions, …) in a single scene. Unity provides zero tools and support for this situation – it just gets harder and harder to work with, and slower and slower to run.

In Entity Systems world, we hate them because they are inherently slow and buggy – no matter how great Unity’s coders, they’ll never make them work as well as our preferred approach (See below).

But … replacing them forces you to replace most of the Unity Editor!

Most of the features of our Entity System need new Editor GUI anyway. If we’re going to be adding big chunks to the editor, replacing GO/MB/SO is going to be much cheaper than normal. And it potentially has huge benefits that are independent of the Entity System.

If we’re going to replace them, what will we replace them with? Custom versions that have almost the same name and work the same way? Or something very different?

What is Unity’s ‘GameObject’ anyway?

As far as I can tell, the real meaning of GameObject is:

def. GameObject: Something that exists inside a Scene, and has a Position, Rotation, and Scale. It can be “embedded” inside any other GameObject, meaning that any change to the other object’s Position, Rotation, or Scale gets merged onto this one. It’s the ONLY thing that can have Unity “Components” (MonoBehaviours) attached to it. Anything that is not a GameObject, and is not attached to a GO, gets deleted every time you load/reload/play/resume a Scene.

From a code perspective, looking at the backend systems, there’s a lot more to it. The GameObject (GO) has a slightly weird name, when you think about it. You use it so much during Unity dev that you stop noticing it. “Game … Object” … wha?

Other purposes GameObject serves

Here’s a few obvious ones (I’ll edit later if I think of more):

1. Guarantees everything has the GetInstanceID() method
   1. Needed for Unity’s Serialization system to work (because of how it’s been designed, not because serializing requires this – C# has built-ins that would have done the same job)
   2. Enables the Editor to “select” anything in any tab/window, and that thing is ALSO selected in all other tabs/windows (e.g. click in Scene, and the Inspector updates to show the components on that thing)
   3. …probably loads of other things. It’s so commonly used I hardly notice it
2. When doing in-Editor things, Unity can often “ignore” classes that are “not part of the game, because they don’t extend GameObject”
   1. Reading between the lines of official docs, and simplifying vastly, this is what happens behind the scenes. Especially with Serialization, I suspect.
   2. This can be a huge pain. It’s hard to debug code when “GameObject subclasses” magically behave differently to “all other classes” with no indication of why
3. Since every GO has a Transform … you can do automatic, general-purpose, high-quality, Occlusion Culling
   1. NB: for this to work perfectly, you’d also want every GameObject to have a .bounds variable. Why did Unity’s original architects leave that out? Dunno, sorry.

How to store game-data: the Entity Systems ideal way

We know this, it’s been discussed to death: if your programming language supports it, use structs.

By definition, structs are the most memory-efficient, CPU-efficient, multi-thread-safe, typesafe way of storing data, bar none. There is no better way to do this in mainstream languages. C# and C++ both support structs; I think we have a winner!

There are probably some awesomely clever advanced Math ways of doing things better, or by using raw assembler and code optimized for each individual CPU on the market. Or, or … but: in terms of what’s ‘normal’, and commonly used, this is the best you’re going to get

But how will this work in practice? What about all the “other” roles of GO etc in Unity?

Structs in … Identity (GetInstanceID)

Simple ECS implementations often hand-around raw pointers to their Components; that gets messy with Identity.

But most (all?) advanced implementations have some kind of indirection – a smart pointer, or an integer “index” that the Component Storage / Manager maps internally to the actual point in memory where that lives.

If we turn that “advanced” feature into a requirement, we should be fine.

Structs in … Serialization

1. Start writing your own version of the Unity Serialization system that only uses structs
2. Finish it the same day
3. Discover it runs 10 times faster than Unity’s built-in one
4. …with fewer bugs
5. PROFIT!

Structs are the easiest thing you could possibly try to serialize and deserialize. Unity coders probably wish that they could restrict us all to structs – it would make their live much easier in some ways.

User-written structs: special rules?

Do we need to add special “rules” to user-written structs that appear in the game?

Nope! It turns out that C#’s built-in Reflection system is able to inspect every struct, shows us every field/property/etc, and lets us easily read and write to them. Both private and public.

CAVEAT: structs break C# .SetValue()

Yeah, this sucks – and it’s nothing to do with Unity, it’s core C#.

A little care is needed when we implement the Entity System internals. But it has no effect on user code / game code.

Structs in … SceneView (Transforms)

No! Just … NO!

This is one of the architectural mistakes of Unity we’re going to fix in passing: we won’t require everything to have a Transform.

However, it foreshadows a more subtle problem that we’ll eventually have to deal with:

Entity Systems are a table-based/Relational/RDBMS way to store and access data; such systems are very inefficient at storing and retrieving tree-structured data (e.g. OOP classes + objects)

The transform hierarchy in a Unity scene is a massive tree. As it turns out, it’s bigger than it needs to be (because of that law of Unity that everything must have a Transform) – but we uses trees all the damn time in game-development. So it’s a problem we’ll have to come back to.

Bigger storage: where do the structs live?

Fine; at the lowest level, the individual ECS Components, we’ll use structs.

But how do we store those?

Choosing the right aggregate data-structures for your ECS is a major topic in itself. C# gives us (almost) total control of how we’d like to do it – plenty of rope to hang ourselves with.

At this point: I’m not sure.

As a temporary solution, I’m going to focus on making the storage-system swappable, so that I can implement a crappy version quickly, and then easily swap-it-out with something much better – without having to rewrite anything else.

Does it work?

Yes. I tried it – I wrote a complete replacement for the Unity Inspector tab that only works on Entities-with-Components, where “Component” is any struct. Ugly, but it works:

Everything there is auto-generated (including the colour; every struct gets a globally unique background colour, which I find makes it much easier when you have hundreds or thousands of Component types).

The only tricky bit was the problem with C# FieldInfo.SetValue(…), as mentioned above.

Further Reading

…some things I might want to pick up on in future posts:

• Worked example of converting struct to immutable struct, and why/how to do it
• Guidelines for implementing immutable structs

Unity is a great 3D engine and a good editor – but the programming environment is 10-15 years behind the curve. Entity Systems are a much better way of writing games, but they are surprisingly difficult to add to Unity.

I’ll bring the latest in modern ES techniques to Unity, turning parts of it from a “weak” programming environment into “one of the best”. In game-engine terms, this will put it far ahead of the pack.

This blog post is testing the waters:

1. You can give me direct feedback on the proposed contents/scope
2. I can start to see how much interest there is in making this

First round of feedback

A lot of people read this and got the impression I was going to charge them extra for the final product, and provide a library with no tutorials. Big confusion and misunderstanding! So, I’ve reworded those bits to be clearer.

Kickstarter: planning the campaign

Target Audiences (Expected)

I think I have four target audiences:

1. Newbie devs, and non-programmers (artists, designers), who find the “coding” parts of Unity overwhelmingly difficult today
2. Unity devs who’ve never used an Entity System on a real game project, and don’t know what they’re missing. They may have a lot of experience (shipped multiple games), or none (University/College students).
3. Small Indie teams / sole coders who’ve used Entity Systems elsewhere, and feel that coding in Unity is slow, error-prone, boring, frustrating, and time-wasting by comparison
4. Large Indie teams whose games won’t work in Unity because Unity is so bad at scaling to large projects. They’ve already re-written or replaced substantial chunks of Unity’s core so that it’ll work fast enough / reliably enough.

Types of Reward

Reward type 1: Discounted License

Everyone who backs the KS gets a copy of the library / license to use it. By backing the KS (at any level) you’re getting a substantially cheaper purchase compared to the final launch pricing on the Asset Store.

There might be some options here for different team sizes, different levels of support, etc.

Reward type 2: Expert Knowledge

When you have non-trivial questions about ES design and usage, it’s hard to get the attention of experts. They’re usually experienced, older, programmers with young families, or working in senior jobs. They have little free time.

Big developers fix this by hiring experts for a few days at a time. But small teams/individuals can’t afford the “entry” cost – as a Consultant, you need to charge at least $5,000 per engagement to cover all the admin overhead and hidden costs.

So, we have some options here to give everyone this kind of access.

Reward type 3: Source Code

In mainstream IT, when you purchase a library you rarely (if ever) get the source code. If you find bugs, or missing features, the vendor works hard and fast to fix them for you.

In the games industry, it’s the other way around: vendors take no responsibility for the code they’ve sold you, and in return … they give you full source access. “Fix it yourself, dude!”

If I let everyone have source, it raises my support costs. With each change, it won’t work for some people – because they’ve modified their copy – and I’ll have to help them update it.

On the flip side: Source code is your “Plan B” in case I get sick, or sell-out, or lose interest in the project, etc. It also gives you an easy way to add features of your own and send them back to me (which I then take on responsibility for maintaining).

I’m offering this, but it’ll be a high-cost. The teams that really need it should have no problem justifying the cost.

Types of Stretch Goal

To clear up confusion: these are things that would be present in the core product (e.g. the GUI is going to be a major part of the library!), but stretch goals would allow me to add extras to each of them.

Goal type 1: Editor GUI

In my experience the biggest effect on programming speed – once you get past your innate ability + level of experience – is the quality and “friction” of your tools.

As soon as you go beyond the simple stuff it’s damn hard to extend the Unity editor. But I’ve been hacking the Editor for a few years now, and I’m willing to do pretty much anything. Especially if it makes it easier to make games with!

Goal type 2: Example Games

The core will have some form of tutorials, but it probably won’t have a complete demo game.

Writing a game just to demonstrate an API is extremely time-consuming, and it’s not what you’re paying for when you buy the library.

But … it’s also a great idea: it improves the quality of the API, by giving me a reference product to check everything is as easy-to-use as intended. So I’d like to write one (or several), but I can’t do that on the base funding.

(Aside: If I ran the technology division at Unity corp, they’d be writing and publishing games every quarter)

Goal type 3: Tutorials

There will be tutorials with the core library. They’ll cover the basics of how to use it.

But … I’d like to go further, and do tutorials for every aspect. I’d like to do a written tutorial for everything, and I’d like to ALSO do a video tutorial for everything (some people only use written tutorials, other people only use videos. I’d like to make it great for both groups).

With a new library, tutorials are extremely expensive to write. Minor changes to the API – bug fixes, refactorings, feature additions – invalidate whole pages of tutorial at one stroke.

Pricing and Funding levels

Tier costs

These are approximate based on extrapolations of cost and expected “version 1.0” feature-set.

• License: $50-$150 (after launch, general public can buy at $200-$400 in Asset Store)
• Source code: $300-$1000 (various amounts of support)
• Access to experts: $150-$750 (various levels of privacy + interaction)

UPDATE: One person has stated they would “never pay these prices”. That’s fine – they’re way outside my target audience. I’m more likely to increase these prices than decrease them. If you know what an ECS is, and understand the value, this is probably too cheap already.

Funding targets

This is what it’s going to cost to build:

1. Minimal version that’s usable in most game-dev: approx. $15,000
2. My preferred v1.0: approx. $75,000
3. High-quality version for large games: approx. $200,000

I can write-off about 50% of the cost as this is a project that I need and will use myself – and it’s a labour of love. I can also add a %age in expected additional sales that happen naturally after the campaign has ended (from the Asset Store, etc).

But Kickstarter takes a cut, and the government takes a cut, and Amazon takes a cut. In the end, I need a KS campaign to raise something like:

1. Minimal funding: $5,000
2. Preferred funding: $30,000
3. High-quality funding: $75,000

My situation

Who are you, anyway?

In case you don’t know … I’ve run Technology/Development for a couple of game companies (e.g. Mindcandy, NCsoft Europe). My StackOverflow score is somewhere north of 20,000. I’ve contributed to a few open-source projects, but the one I’m most active on is the SVG rendering library for iOS and Mac, where I’m the project lead and one of the top 3 contributors.

I started writing about Entity Systems back in 2007, mostly because I was frustrated that so many game studios were “doing it wrong”.

What I’m doing now

I teach non-technical people how to program. I work with schools, teachers, and directly with children/adults. I invented a new system of programming using physical objects and toys.

Working with a local school, I’m making a new course where I’ll be teaching children “how to make games with Unity3D”. I’m particularly interested in what I can do to the Unity Editor to make it more user-friendly and better for use in the classroom.

Depending on how this goes, I have a few people in mind I’ll hire to share the burden of writing this library. It’s something I need both in my day-job and in all my personal game projects. Doing it as a Kickstarter gives me the excuse to spend 100x as much time and effort on it as I would otherwise, and gives me a much better library than I’d get on my own.

Why Kickstarter?

I suck at Marketing. The biggest risk factor to this project is that I fail to make enough noise, and hence there’s too little money coming in to pay for the ongoing development and support. As a result, dev gets sidelined while I pay the bills.

A Kickstarter is my way of testing “can I find a critical mass of people who need this project, and get them to put their money where their mouth is?”.

It’s going to be hard – I suck at marketing – but to be honest I’m leaning heavily on the idea that this is something people want badly enough they’ll help me market and promote it. With KS, there’s no risk to you for helping here … if the campaign fails, you pay nothing. If it succeeds, I get enough cash (and enough users!) to guarantee development through to a production-ready version.

Are you in?

Support me on Patreon, writing about Entity Systems and sharing tech demos and code examples

NB: a few weeks ago I made a small Editor Plugin that used Reflection to upgrade and fix some of the core Unity Editor code/GUI. That was practice for what I’m doing here. It’ll hopefully appear on the Asset Store at some point (pending review right now!) – it has the full source unobfuscated, so you can see for yourself both what and how I got it to do its clever bits.

References

Some things to read if you haven’t already:

• Sampsa’s post on the missing documentation for Unity’s ScriptableObject (follow him @snlehton)
• Mockups of GUI we might want in Unity3D for managing an Entity System
• High-performance, low-level memory management for Entity System implementation – we won’t be doing this immediately, but it’s a precursor to some of the things I’ll end up doing here.
• A single worked-example of where Unity’s built-in architecture makes it much harder to write games than if you were using a modern Entity System
• Lucas Meijer’s (@lucasmeijer) post on official Unity blog aboutSerialization in Unity – what is it, how it works under the hood, and how you fix it when it breaks/has missing features

(that last one is particularly important; working around Unity’s broken Serialization system is a whole mega topic in its own right, and I’ll be largely assuming you already have read up on it. If you don’t know Unity Serialization yet (enough to fear it!) go read that article)

Initial thoughts/plans

There’s been one thought in particular nagging away at me for a while now:

If we’re going to really, truly, genuinely replace Unity’s core scripting architecture (which sucks for game development) with a modern ECS one, then we MUST create a new custom panel for the GUI Editor.

…until / unless we do that, it’s just a Programmers’ Circle Jerk: it loses 90%+ of the audience of Unity developers, people who chose Unity because of the Editor. 1st-class Editor integration is more important than anything else (certainly a lot more important than – say – performance).

Core Unity bugs that got in the way

Unity never repaints windows when Scene changes

If the scene changes, we’ll be looking at a new Entity System (different entities, different components). You would naturally expect that Unity automatically repaints all windows when Unity changes the Scene, right?

Wrong.

(incidentally, this is why it’s also very hard to be sure that a scene has actually loaded when you double-click on it – Unity gives no indication to the user that anything changed, if the Hierarchy for the two Scenes was the same)

Workaround to Unity bug

The undocumented method “EditorWindow.OnDidOpenScene()” which you can override. Amusingly, in Unity 4.5 they “fixed” the “bug” that this was documented; now your only way of discovering it is by finding a Mystical Unity Guru who knows The Secrets of Unity.

ScriptableObject: fundamentally broken

This isn’t even funny any more…

ScriptableObject System.Guid properties are wiped by Unity Serialization

public class EntityID : ScriptableObject
{
public System.Guid GUID = System.Guid.Empty; // this will NEVER be saved by Unity
}

… you have to manually write a serializer and deserializer for System.Guid. Because C# built-in structs weren’t considered important enough to be supported by Unity. WTF!!!??!??

ScriptableObject breaks C#: no constructors allowed, no initialization allowed

We know why: it’s because Unity Serialization is crap.

Unity Serialization requires every class to use a zero-argument constructor and has a bizarre array of hacks to try and restore state.

If – for instance – you need to create a ScriptableObject and guarantee that it gets an internal globally unique ID … you can’t. C# supports it, but Unity removes that support. Joy!

ScriptableObject data loss

New discoveries:

1. SerializedObjects saved into your scene are automatically deleted whenever you change Scene.
   • …Unity staff apparently felt that developers are too stupid to write code; an info message tells you you “leaked” memory (no, no you didn’t. Unity incorrectly DELETED your non-leaking data)
   • …probably they’re too embarassed to admit that their failure to include Editor UI to show “SerializedObjects in current scene” was causing many projects to accidentally build up masses of invisible objects.
   • …there was a fix for that bug. It would have taken them MINUTES to code it up (I’ve done it myself, seems to work fine?). Or … they could break Unity further. Which option did they go with?
     • (this was probably due to some time pressure at the time; but that’s what CTO’s and Tech Directors are for: to make sure such hacks are then fixed properly shortly afterwards, not brushed under the carpet)
2. If you mark a SerializedObject as “DontDestroyOnLoad” you discover that bug is even worse. It’s really, really bad:
   1. When you try to change Scene, Unity correctly asks “do you want to save? You have unsaved changes”
   2. …and then whatever you do, Unity deletes your SAVED DATA, using the first bug above.
   3. …looks like the bug isn’t just “deleting data when it shouldn’t”, but “incorrectly implemented DELETE that overrides Unity’s built-in data and scene management”

From Unity forums, this has been around for a good 4 years.

Some Classes

EntityID – with workarounds for core Unity bugs

Here’s the fixed EntityID class from above, with the hacks needed to make up for Unity’s “oh, let’s take C# core features, and break them” attitude.

You need to do this a lot if you work with Unity, sadly…

[csharp]
/**
NOTE: this class is really only 1 line long. Unity problems add 10 lines to it!
*/
public class EntityID : ScriptableObject, ISerializationCallbackReceiver
{
public System.Guid GUID = System.Guid.Empty;

private string _UnityWorkaroundProperty_GUID = System.Guid.Empty.ToString();
public void OnBeforeSerialize()
{
_UnityWorkaroundProperty_GUID = GUID.ToString();
}

public void OnAfterDeserialize()
{
GUID = new System.Guid (_UnityWorkaroundProperty_GUID );
}
}
[/csharp]

Conclusions

I got a basic self-managing EditorWindow interacting, and duplicating the most basic behaviour of the Hierarchy window, but I wasted so much time trying to kick Unity’s awful ScriptableObject into working shape that I got no further than that. Very frustrating.

Here’s a video:

And you can’t do any of this from the keyboard. Even though you’re fully in keyboard mode and about to write the name of the New Thing (required!) and if it’s a script: type in the source code.

Screw that.

UPDATE: Now available in Asset Store – get the source

For a mere $2, I will Intelligent New you long time:

Source is included. If you want to see how I did it, knock yourselves out…

My context-sensitive New for Unity

So, what I’ve made today:

intelligent-new-demo-1

• Select any folder or object in the Project window
• Hit “shift-N” (because Unity sucks and steals Ctrl-N and refuses to let you choose a better one. Stupid stupid stupid.)
• A popup appears pre-filled with a sensible new file name OR folder name
  1. If you were on a folder, it prepares to auto-create a new folder
  2. If you were on a script file, it prepares to auto-create a new script
  3. The name is pre-selected and editable, exactly as with Unity built-in
• Sometimes that intelligent guess above will be wrong, so … hit Tab, and it switches type, while keeping the text selected and editable

Net result: super-fast workflow for creating new scripts and organizing your project.

(This required an ungodly amount of hacking and trial and error to work around bugs, bad documentation, and obvious missing core features from Unity APIs. But it works, and seems to be pretty seamless now)

Implementation Notes

A subset of the things I discovered / re-discovered on the journey to this one small fix / improvement:

1. AssetDatabase.CreateAsset is basically broken: can’t create C# scripts at all. Don’t try.
2. ScriptableWizard is unusable in Unity less than 5.0, because they made a core method private / non-overridable. Don’t bother.
3. You can find the Project window and others by doing a reflection on the Assembly to find the magic C# Type of known Unity private classes (that SHOULD BE public!) and comparing at runtime. Hoops? Jumping through? Because an API has something private that should have always been public? Welcome to Unity customization! :)
4. You can find the exact position of the selected row by adding yourself as a callback on Unity’s own row-by-row rendering of their built-in windows, and saving the data every frame. Sounds scary; works great (one of the few bits here that is a perfect hack with no downsides)
5. Popups need you to create a new class, and that class MUST BE in file of its own or you will break Unity (internal bugs in Unity window management that trigger when you reload/restart Unity)
6. …if you trigger that bug (or in any way end up with floating, non-closeable windows), go to the Layout menu and re-select the layout you’re already using. It will kill any unexpected windows. Phew!
7. Unity still hasn’t made the Indent width (in pixels) public. The documentation insults you by saying that when you hardcode the number 20 this will break your code in future. YES, WE KNOW. SO MAKE THE DAMN NUMBER PUBLIC, YOU BASTARDS.
8. There is a 2 pixel top and bottom padding needed to surround textfields in 1-line popups. I hardcoded this, it may have a number somewhere in the API. Good frickin’ luck trying to find it. Given the taunt about indents above, I very much doubt it is public.
9. If you have a button or non-editable textfield with a changeable title, or anything that can be changed by a keypress during rendering, it is critical that in OnGUI you read Event.current.type and switch() on it. As far as I can tell, this has never been documented except in forum threads and blog posts by Unity staff. Once you know about it, you can sort of guess it from reading the undocumented bits of the API, but it’s damn hard to find references to it online. (I found it years ago by trial and error and blind luck). Until you do this you get race conditions when changing GUI based on keypresses. Ugh.

   Compatibility

   Critically, this (should) work no matter how much I customized Unity elsewhere. It’s peeking into the actual window and render areas to decide what to popup and where on screen.

   The only conflict I expect is one that – thanks to some brainfart design at Unity corp – we can’t workaround: I had to hardcode “shift N” as the keyboard shortcut :(.

   Want it yourself?

   I thought it would take me about 10-20 minutes to do. HAHAHAHAHAHAAHAH! If I’d done this as a client project, I worked out it cost almost $1500 in billable hours. Ugh.

   I’m going to use this in production for a while. If it continues not to break or corrupt anything, I’ll put it on the Asset Store.

   Next up…

   …I’m going to do some context-sensitive New for the Hierarchy window, I think. Now that I have these hacks working, that’ll be quite a lot easier.

   ]]> https://new.t-machine.org/index.php/2015/04/07/intelligent-new-thing-control-for-unity3d/feed/ 2