I went wandering. — Johnny Cash

Unity developers, this post is for you. Because you’re cool and I want to be your friend.

Let’s say you have an NPC. You could animate that bad boy and make it stroll around in suspiciously straight lines, but that’s boring and predictable. Personally I never stroll, I meander. As aggravating mall shoppers prove, random movement is always more interesting than the linear sort, so let’s make your NPCs move in this manner.

First step: toss a CharacterController on your character game object. You want to be constantly recalculating a new direction for them, so bust out a coroutine and set it to change the target direction every second or so. The Update function constantly rotates the character towards this target direction, with the end result being an NPC that doesn’t seem intent on making it to a specific location. Such behaviour is great for patrolling guards, farm animals, and the shoppers in that totally sweet mall simulation you’re building (SimMall 3000!).

Here’s the script that does this (also available in Gist form). Toss it on a game object, tweak the inspector values, and watch the magic happen.

I also chucked in some code in the OnControllerColliderHit that changes the character’s direction when it stupidly runs into a wall. The final result is an AI character that wanders aimlessly around the level, going wherever its small mind desires.

So many nerds. — Montague Redgrave

Unite 2011 left me exhausted and my voice decimated. It was awesome.

We (Brad Keys and myself) were there on business, pitching Lumos and game analytics to developers with flair that even Billy Mays can’t top. We also sat in the sessions offered throughout the three days. Being the code lovers we are, we mostly attended the presentations related to programming. A common theme throughout was the difficulty of handling massive amounts of assets and the workflows that larger companies use for collaboration and testing. For someone whose games typically stay in the graybox phase, this insight into how studios manage their gigabytes of data was fascinating. The takeaway was that the current release of Unity has difficulty coping with tons of assets, an issue that the keynote promised to alleviate with additions like the cache server and text-based scene files. The latter feature was met with loud cheers by the audience, so there’s no doubt that Unity 3.5 will be a welcome update.

The most interesting session I attended was Unity in the Wild, a showcase of projects using Unity for non-game purposes, among them nature simulations and augmented reality for advertising. Candy Stations, a company producing live visualizations and performance art, was particularly fascinating. Unity is just one application of many that they employ to achieve their visually stunning displays. It opened my eyes to the possibility of piping video generated by an application like Quartz Composer or Max/Jitter directly into a Unity movie texture (a key component of this setup, by the way, is a tool called Syphon that allows OS X applications to share video frames in realtime). I’ve always had the notion that Unity’s powerful physics engine, lighting system, and 3D environment could be effectively used beyond games, and this session showed me that people are doing just that with incredible results. Just watch the Sufjan Stevens video on Candy Stations’ website — that’s one psychedelic performance.

Something that impressed me about Unity as a company was their transparency. On the second day they hosted an off the record view into their roadmap, providing details about the current and future state of the engine. Developers were encouraged to voice their concerns and ask questions, which were answered frankly and honestly by the people calling the shots. As built-in analytics was one of the features announced during the keynote, we were eager to talk to Unity’s engineers about where Lumos, our own game analytics platform, fits in. Everyone we spoke with, from their CEO David Helgason to the programmers who will be working on the system, was available for discussion and refreshingly honest about their plans. In the tech industry where so many companies guard their words and give statements as useful as Confucius’, I appreciated Unity’s willingness to give us the lowdown without the bullshit.

The three days of the conference was packed, and other than the exhausting uphill walk to the conference centre we were unable to see much of San Francisco during those days. Fortunately we spent an extra day in SF to be camera-toting tourists. It’s a beautiful place that reminded me of Vancouver, a city which I lived in for several years and loved. I’d definitely jump at the opportunity to return to California and take in more of the metropolis. Unite 2012 perhaps?

Let’s meet up and talk shop. I’ll bring my skateboard. — Eugene Belford

This week, accompanied by hotshot game designer Brad Keys, I’ll be attending Unite 2011 in San Francisco. Along with nerding out on topics as exhilarating as physics engines and particle effects, we’ll be busting out Lumos for anyone interested in checking out the bee’s knees of game analytics services. We have a couple sweet updates ready to ship, so it’s guaranteed not to disappoint. I promise.

I’m jazzed to be attending the conference, it’s been on my to-do list since the first one was put together years back. I don’t know if my game design skills have improved since Unite 2007, but the engine sure has and I’m pumped to see what magic is unveiled this time around. According to my (deadly accurate) crystal ball, we’re going to see announced the Apple II as a deployment platform in addition to a pink editor skin to complement the current pro “vampire” theme.

If you’d like to meet up with us to chat about Lumos, or about any other topic that strikes your fancy, send me a message at matthew@matthewminer.com. I look forward to meeting my fellow Unity aficionados.

See you there.

Stop having boring tuna. Stop having a boring life. — Vince Offer

Now available in the Unity Asset Store: the frighteningly useful Methodic. This super cool mack daddy is a tool for graphically executing functions in the editor, providing an easy way to test new code and trigger actions that would otherwise be tedious to invoke. If this doesn’t get your heart racing then few things will.

Let’s bust out some example usage to increase the thrill level. Suppose you have a game object with a script attached. In this script you just wrote a new function ImmenseBlast and you want to give it a whirl. Unfortunately you need to lay down some code to execute the function, whether that be a GUI button or a trigger or a hotkey. With Methodic, no such shenanigans are necessary. On play, simply click the game object, select “ImmenseBlast” from Methodic’s dropdown menu, and hit Invoke. The function executes. Boom.

Maybe your function takes some parameters? No problem friend. A form appears where you can enter values to be passed upon execution. If one of the parameters is a Color struct, the colour picker appears. If the function accepts a GameObject, drag and drop one from the Hierarchy pane. A Transform? Same deal. If it was any easier I’d hire Vince Offer to pitch it.

You can pick up Methodic for $10 here. As always, feedback and suggestions are appreciated, particularly as this is my first foray into the wild world of the Asset Store.

Goodbye weird hackish Google Analytics solution! — John Graunt

Recently myself and other suave folks have been building a game analytics service called Lumos. Frustrated by the lack of analytic tools geared specifically towards the needs of game developers, we took up the task of building one ourselves. The result of our efforts is now in public beta, and I encourage you to take it for a spin. Currently we only offer support for the outrageously awesome Unity engine, but support for other game engines is coming soon. We love you regardless of your tool choice.

“Tell me good sir,” you might demand, “what does Lumos offer an enterprising chap like myself?” First off, remote debugging. Lumos automatically records runtime errors and warnings thrown by your game and sends them to our servers for later perusal. When a player triggers a dastardly NullReferenceException in level three that you were unaware of, you’ll see the problem immediately and be able to fix it. This is particularly useful in the beta testing phase of your game; errors happen, but unless you discover into them yourself while developing it can be difficult to know where they might occur.

Second feature: system info recording. When a player first fires up your game, specs such as their computer’s RAM and operating system are sent to Lumos. This information is valuable when deciding what class of machine your game should target. If most of your players are rocking integrated graphics cards with 64 MB VRAM (don’t laugh, that’s what my old workhorse has), you might want to dial down the particle effects. It’s also valuable when deciding what your next game should target.

Another feature we built was a feedback system. This allows players to report bugs or give suggestions, to which you can respond if desired. In the Unity package we supply there’s an optional GUI that makes it a breeze to solicit feedback from your players, or you can write your own sexy interface to do the job.

Now, besides the features mentioned above there are many new ones currently in the works. As time goes on Lumos will be expanded to fulfill the needs of game developers large and small. If you have features you’d like to see that aren’t currently offered, we’d love to hear them (you can use the form here or contact me directly). Many of us on the Lumos team are game developers ourselves, but obviously you’ll desire features we haven’t even thought of yet. We looked into hiring a telepath, but decent ones are few and far between.

The website for Lumos is www.uselumos.com. Sign up, make an app, add the Lumos Unity package to your game and get those stats flowing! We’ve designed the service to operate as automatically as possible — for most functionality you don’t have to take any action at all. Simply drop the Lumos game object into your scene and you’re ready to laugh at the days when game analytics was a far-off fantasy. If that’s not the definition of the American Dream (or Canadian, in my case), I don’t know what is.

I would have named it Orbital Fun Time. — Friedrich Drumpf

This is slightly old news, but recently a game I built for the Great Canadian Appathon — hastily named Trajectory at 5 am on a Sunday morning — took home the “Wild Card” prize. The criteria for this category was originality, creativity, fun and cool factor. Like the Global Game Jam and similar hackathons I’ve participated in, the game had to be built in under 48 hours. A key difference of the Appathon was that the game, like the event’s title suggests, had to be targeted towards mobile deployment. This was my first time developing for a phone, but as I wasn’t exactly pushing the boundaries of graphical realism this proved to be easier than I anticipated. As burnt out as I was by the end of the competition, I was very pleased with the resulting app.

By design, the gameplay is simple. You play a spaceship, which for no apparent reason must collect stars (I’ll be the first to admit that the story lacks panache). To move about the level, you orbit around planets then slingshot yourself off, avoiding those mysterious black cinder blocks in the process. There’s only one control: tapping the screen attaches yourself to the closest planet, or releases you if you’re already in orbit around one. Traveling through a wormhole transports you to a sibling wormhole, which can be beneficial or detrimental depending on your randomly chosen destination. Completing a level requires that you collect all the stars in it, after which the next level begins. The time it takes to finish the level determines how well you do; like golf, a low score is desirable. Completing all ten levels lands you back at the main menu, where you eagerly scramble to play again.

Admittedly the orbiting mechanic feels more like you’re swinging, particularly so with the unexplained gravity that constantly pulls you to the bottom of the screen. For this reason a monkey character in a jungle environment would have been more appropriate, but a space theme was chosen as something my feeble 3D modelling skills could pull off. Pixar might not be pleading for me to design their next adorable protagonist, but when it comes to sculpting blocky planets I’m second to none.

Overall the Great Canadian Appathon was a bang-up affair. Organized by mobile game studio XMG, the prizes were impressive — the team behind the dashing Super Punch walked away with $25,000 — and we were kept well nourished throughout. I look forward to participating again when the next Appathon rolls around, before which you will hopefully see Trajectory up for sale in your local app store. All I need to do now is hire/kidnap an artist with 3D modelling skills superior to my own; which, to be honest, could be just about anyone.

These make my life easier. Perhaps even more than the Slap Chop. — Captain William Henry Stuart

A feature that appeared briefly in a beta release of Unity 3.0, but which has since disappeared, is editor macros. The reason for the feature’s withdrawal is unclear. Presumably it’s simply unready for primetime, and will appear in a future version of Unity. Fortunately the ability to evaluate arbitrary code snippets in the editor is still available in the UnityEditor.Macros namespace, and taking advantage of it is easier than racing a sloth.

Macros are little snippets of code that help speed up repetitive tasks in the editor. The same functionality can be achieved by writing an editor script, but for simple tasks — particularly ones that you only intend to run once — doing so can be a chore greater than the action itself. Perhaps you want to duplicate the selected game object a thousand times, or you want to perform a batch rename. For such tasks, and even for more complex ones, a few lines of code will often suffice.

I’ve written a simple editor window script (also available at the Unify Community Wiki) that allows you to input any code and execute it. Place the file in the /Assets/Editor directory and navigate to the Window → Macros menu. To get the ball rolling, here’s a few basic examples of how it might use be used. Note that the MacroEvaluator.Eval method only accepts JavaScript and not the manlier C#.

An obvious enhancement to make is the ability to save and reuse code snippets. I assume this is what Unity Technologies has in the labs, and I leave the implementation of such functionality as an exercise for the reader.

The usual warnings about using undocumented APIs apply. Just don’t do anything too ridiculous.

That’s the title of my favourite film! — André Bazin

A quick update regarding the Unity Cutscene Editor.

The project’s version control has moved from Subversion to Git, and is now hosted on GitHub rather than Google Code. You can check out the latest source from http://github.com/mminer/silverscreen. Once again, you’re encouraged to report issues as you find them. It’s an open source project, so everyone is welcome to contribute.

With the impending release of Unity 3, support will be dropped for Unity 2. Version 0.1 will always be available to download for those hesitant to upgrade to the latest and greatest. We’ve got your back.

This script literally rocks my raincoat. — Mary Baker Allen

At the request of fellow code conjuror Brad Keys, I wrote a simple editor script for Unity that creates a prefab containing the contents of the currently selected game object. The new prefab bears the name of the selected game object and is placed in the project’s root directory. This function is accessed from the GameObject → Create Prefab From Selected menu.

While setting up prefabs is a trivial task, this menu item simplifies the process somewhat. It’s not perfect — the selected game object doesn’t become an instance of the newly created prefab, and an existing prefab with the same name is replaced — but perhaps you’ll find it useful if excess clicking isn’t your game of golf.

Download the script here or contribute your own improvements at the Unify Wiki.

I am neither a geek nor a tool. — Joe Camel

Yesterday I mentioned how terribly inconvenient having to fire up OS X’s Console.app to view Unity’s web player debug log is. The in-game console script I supplied eases some of that pain, but there are still times when I find myself wanting to view Unity’s logs and dreaming of a fantasy land where this is easier to do. Propitiously, that fantasy land exists in a free utility named GeekTool, which through careful calculation I’ve determined kicks severe amounts of ass.

According to its website, GeekTool allows you to “display on your desktop different kind of informations.” Indeed it does. It can display images, the results of shell scripts, or in my case, the contents of text files. This is especially useful when the Unity editor crashes and I need to know why. At a glance I can see any errors that have occurred and all sorts of other funky information that gets sent to the Unity logs. When I’m not in development mode and don’t want lines of cryptic text cluttering my desktop, I simply turn off the “Unity” group from GeekTool’s menu bar dropdown.

Highly recommended.