We're super excited to announce that we're running another Live Online Training with O'Reilly Media! We'll be teaching game development with Unity, live online, on January 17 and 18 (6PM to 9PM, AEDT).
Later, in February, we're also running another Live Online Training covering Practical AI on iOS. This session will give you a solid introduction to Apple's CoreML and Vision frameworks, and runs February 27 (5AM to 7AM, AEDT).
We recently announced that we're building Night in the Woods for mobile! We're super excited about this, so we thought that we'd share a bunch of technical behind-the-scenes stuff on our blog over the coming weeks and months. This is the first of those posts!
Yarn Spinner is the dialogue engine that we wrote, and was used in Night in the Woods. It’s open source, freely available, and we think it’s pretty powerful.
One of the reasons why we think Yarn Spinner is powerful is that it’s designed to focus on as little as possible. There’s literally only three things that Yarn Spinner can do with your game: it can send lines of dialogue, ask for a selection among a group of options, and send a command for your game to interpret.
The idea behind this is that your game can add what it needs to on top, rather than being forced to fit inside the ideas that we had when we first wrote the system. There are several excellent dialogue systems that are designed to be very good at operating within the structure of a role-playing game, or a choose-your-own-adventure system (Twine is a great example of this last one), but for Yarn Spinner, we wanted the system to be more generalised, and able to be applied to a wide variety of games systems.
The consequence of doing that, however, is that a game needs to do more work to add the features that it needs. While we built Yarn Spinner with NITW in mind, there are several features that are quite specific to the game.
In this post, we’ll highlight some of the cooler things that Alec Holowka, the lead developer of Night in the Woods, built on top of the Yarn Spinner system to support its needs.
Here’s an example of the kind of dialogue that exists in Night in the Woods. Here’s Mae and Gregg, planning on going to Donut Wolf:
Gregg: They got pancakes now! :)
<<close>>
//angus walks across the screen and off the left//
<<walk Angus AngusOffLeft>>
<<wait 3>>
Angus: fine.
<<lookUp Mae>>
<<lookUp Gregg>>
Gregg: \o/ D:
Gregg: RIDE THE CHARIOT!
<<dilate Mae .85 .5>>
Mae: TO DONUT HELL!!! \o/
<<runNextLinesTogether 2>>
Mae: {width=8}[shake=.05]AWOOOOOOOOOOOOOOOOO!![/shake]
Gregg: {width=8}[shake=.05]AWOOOOOOOOOOOOOOOOO!![/shake]
This dialogue is part of the raw source code of Night in the Woods. When the scene loads, the dialogue attached to the characters is parsed; first, it’s parsed into a data structure called a parse tree, which is then converted into a simple binary representation. This process is quite similar to how other code gets compiled into a binary that can be run on a machine.
At the end of this process, the resulting bytecode for the above dialogue snippet is this:
Node GreggFQ4Intro:
0 L0:
RunLine GreggFQ4Intro-0
RunCommand close
RunCommand walk Angus AngusOffLeft
RunCommand wait 3
5 RunLine GreggFQ4Intro-1
RunCommand lookUp Mae
RunCommand lookUp Gregg
RunLine GreggFQ4Intro-2
RunLine GreggFQ4Intro-3
10 RunCommand dilate Mae .85 .5
RunLine GreggFQ4Intro-4
RunCommand runNextLinesTogether 2
RunLine GreggFQ4Intro-5
RunLine GreggFQ4Intro-6
15 RunCommand close
RunCommand irisOut 1 wait
RunCommand sectionTitle GreggFQ4Intro BeaCar
18 Stop
String table:
GreggFQ4Intro-0:
Gregg: They got pancakes now! :) (GreggFQ4Intro:1)
GreggFQ4Intro-1:
Angus: fine. (GreggFQ4Intro:6)
GreggFQ4Intro-2:
Gregg: \o/ D: (GreggFQ4Intro:9)
GreggFQ4Intro-3:
Gregg: RIDE THE CHARIOT! (GreggFQ4Intro:10)
GreggFQ4Intro-4:
Mae: TO DONUT HELL!!! \o/ (GreggFQ4Intro:12)
GreggFQ4Intro-5:
Mae: {width=8}[shake=.05]AWOOOOOOOOOOOOOOOOOOOOOO!![/shake] (GreggFQ4Intro:14)
GreggFQ4Intro-6:
Gregg: {width=8}[shake=.05]AWOOOOOOOOOOOOOOOOOOOOOO!![/shake] (GreggFQ4Intro:15)Each line of this bytecode is then executed, one after another, by Yarn Spinner, which sends along the lines, options and commands that it encounters. This is part of the standard behaviour of how Yarn Spinner works in any game; where Night in the Woods differs is what it does with its lines.
Night in the Woods shows its dialogue in speech balloons that are attached to the characters. In order to correctly position them, NITW needs to know which character a line should be shown attached to; to figure that out, NITW looks at the start of each line, and figures out if it begins with a name followed by a colon.
If it does, then the game checks to see if that character is in the scene; if they are, the speech balloon for the line is attached to that character.
Emoticons, or “what we used to use before emoji were a thing”, are those little faces that are composed out of plain text - stuff like :) and :(. Night in the Woods uses these to control player expressions, by looking for any emoticons that it recognises. When it encounters one, it triggers a corresponding animation action, such as animating from the neutral expression to a smile.
There are several different kinds of emoticons. In addition to the smileys that control facial expressions, the game also includes several gestures as well; for example, whenever Mae puts her hands on her hips, it’s because the line included the emoticon “<o>”; when she throws her hands up into the air, it’s triggered by “\o/“.
This is true for other characters as well. When Gregg starts flailing his arms after Mae meets him in the Snack Falcon at the start of the game, it’s the result of using the emoticon sequence “:) \o/“
Night in the Woods responds to custom syntax within lines that let a writer mark up the dialog for visual effects. For example, when a character needs to shout, the line contains markup like this:
Mae: {width=8}[shake=.05]AWOOOOOOOOOOOOOOOOO!![/shake]This causes the specific range of letters to be delivered in a shaky style. The markup also supports effects like character size, color, and balloon position, as well as fun effects like making a line of text wave.
Finally, Night in the Woods makes extensive use of commands. In Yarn Spinner, if you wrap some text in <<angle brackets>>, it won’t be sent to the game like a line of dialogue. Instead, it’s delivered as a command; the intent is that the game will manually parse its contents, and perform some action in the game.
Every time you see a character do anything besides talk, it’s the result of an action. There are a huge number of possible commands in the game; on top of the usually expected actions like sit, stand, walk, and jump, commands can also be used to control where and how a character is looking, the dilation of their eyes, and whether they’re visible or not. This last command is extremely important, since it’s used to control whether a character is present in a scene on a given day.
What’s interesting about NITW is that just about all of the gameplay logic is driven through Yarn Spinner. The language wasn’t designed to be a general game logic control system but it turns out it’s pretty good at this. That’s cool.
Several of these are very specific to NITW and its systems, while others are things that could probably apply to most games. As we continue to work on Yarn Spinner, we’re looking forward to making the project the best dialogue system it can be. For more information on Yarn Spinner, visit the project’s page on GitHub at https://github.com/thesecretlab/YarnSpinner.
If you're interested in more information on how we made Night in the Woods better with our open source software, check out Jon's talk from GDC 2017 on YouTube.
Follow us on Twitter for more news and updates: @thesecretlab
Night in the Woods is coming to iOS in 2018!
We're thrilled to announce that we've partnered with Infinite Fall and Finji in porting Night in the Woods to iOS. We've been working on it for a while now, and we're incredibly excited to say that it's coming in 2018.
Porting a game like NITW to mobile devices is interesting for two reasons. First, a mobile phone often has much less memory than PCs or consoles, and a less powerful graphics chip, so we need to do all kinds of things to make the game fit. Second, bringing any game that was designed for controllers or keyboards to a touchscreen means you've got to completely re-design the game to account for stuff like the player's hands covering up the screen, and the fact that you can't physically feel your controls.
You might have seen Jon posting about his work over the last several months on a tool for compressing sprites. This tool is part of the set of technologies we've been developing to support the port, and we'll be sharing more about it in the near future.
NITW also uses Yarn Spinner, our open source tool for creating and managing interactive dialogue in games. We're thrilled with the community response to Yarn Spinner, and improvements that result from our porting work will be merged into the main project.
If you're going to GCAP 2017, come and see Jon talk about the port in more detail at 3PM on Tuesday, October 24th (TODAY!), where he'll also be sharing tips and tricks on how to make your game the best possible experience on iOS devices.
For more info, be sure to follow us on Twitter, at @thesecretlab, @parisba and @desplesda. We share lots of interesting behind the scenes stuff!
Talk more soon. This is going to be fun. For questions or inquiries, please email lab@secretlab.com.au
We’ve been working with some awesome folks to build a great library of training material for game development with Unity.
These videos, soon to be joined by a series on game promotion, are designed to accompany and support our upcoming book, Mobile Game Development with Unity (also on Amazon and Safari).
Here’s what we’ve been working on:
We’ve also got some new “Learning Path” videos, exclusively out on O’Reilly’s Safari platform:
Our newest books are also available now:
One of the best ways to look at all the training we write is on O’Reilly’s Safari platform (which has a free trial). It’s like Netflix for technical training and books.
This year, we gave a talk at GDC called “Making Night in the Woods Better with Open Source”. In it, we talked about how Night in the Woods, which came out last month and you should totally go buy, used the open source process in its development.
Unlike most of our other talks, we did something a little ridiculous with this one - we built an entire presentation system, from scratch, into Night in the Woods. We’re actually pretty proud of this, and so we put together a video showing how it was done. Check it out!
The talk from GDC is also available online, and we've embedded it below:
At Linux.conf.au 2016, in Geelong, we presented a talk on our experiences building video games at open data hackathons, such as GovHack. The video and slides are now available! The video is available on YouTube, and embedded below, and the slides are available on SpeakerDeck.
Paris Buttfield-Addison https://linux.conf.au/schedule/30351/view_talk Open data is cool, especially when it comes from government. What's even cooler than open data? Games. Games are cool. So why not combine them? This talk explores the potential for spreading the word about open data, as well as providing for deeper engagement with data, through game development.