Sunday, February 26, 2017

Oculus Rift Unity3d Battle Game

BattleToys

BattleToys is a mini game (and tech demo) that uses the Oculus Rift and the Myo armband to fight evil sock animals in a twisted child's bedroom.
BattleToys is based on an existing game designed by Unity for tutorial purposes. The tutorial game, "Survival Shooter", is a game designed in 2014 to teach potential Unity users how to design games in the Unity engine. We adapted this game and added enhanced Oculus Rift support, added our own hammer weapon, and added the Myo armband support to control our weapon!

Download

You can find a pre-built release here:
https://github.com/alberthdev/battletoys/releases

Building

To build the game, download the source code here:
https://github.com/alberthdev/battletoys/archive/master.zip
Open the downloaded source code folder in Unity 5.x, and build it from there!

AR Vuforia Unity3d

ar-vuforia-unity-demo

Augmented Reality demo made with Vuforia and Unity 5.
I have used one of my books cover as target image to show a 3D model.
See the demo here: https://vimeo.com/164908588
gif

Images

Image target
http://imgur.com/R0LuWyV.png
Screenshots
png png

Vuforia with OpenCV for Unity Example

Vuforia with OpenCV for Unity Example

Demo Video


Environment

Windows 8.1
Unity 5.5.1f1
vuforia-unity-6-2-6.unitypackage
SD_UnityChan-1.unitypackage
OpenCV for Unity 2.1.3
In Unity 4.6, It seems the black screen problem occurs while using the combination of Vuforia and OpenCVForUnity. I am investigating the cause.Unfortunately, please use the Unity5 at the moment.

Setup

  • Import vuforia-unity-6-2-6.unitypackage
  • Import SD_UnityChan-1.unitypackage
  • Setup Vuforia (How To Setup a Simple Unity Project)
  • Import OpenCVForUnity2.1.3 from AssetStore
  • Import VuforiaWithOpenCVForUnityExample.unitypackage
screenshot.png

Examples

CameraImageToMatExample.cs
Conversion from CameraImage(without augmentation) of "Vuforia" to Mat of "OpenCV for Unity".
PostRenderToMatExample.cs
Conversion from PostRenderTexture(ARCamera) of "Vuforia" to Mat of "OpenCV for Unity".
Attach "PostRenderToMatExample.cs" to "ARCamera/Camera".
Light_Frame.png

Unity3d Mecanim Effects


MecanimEffects

Bind visual effects to Mecanim (Unity 3D animation system) states in the editor.

What is effect

We define effect here as a GameObject prefab. It can contain animated textures, particle emitters, audio sources, anything you want. Follow next few steps to create a sample effect.
  1. Create an empty GameObject with Game Object > Create empty menu command.
  2. In the Inspector window click Add Component button and select Effects > Particle system.
  3. Drag that game object from Hierarchy to Project window to create a new prefab.
  4. That's it!

Using effects with Unity Editor

To try out mecanim effects you'll need a scene with any object animated with mecanim. Open that scene in Unity Editor and prepare the sample effect like the one defined before.
  1. In scene view select any object animated with Mecanim. It must have Animator component attached and a state machine with two or more states.
  2. In the Inspector window click Add Component button and select EffectsController.
  3. In the EffectsController inspector select animator, add one binding to the Bindings list, and expand it.
  4. In the Binding inspector set State Name property to any of existing states by typing "." without quotes.
  5. Expand the Effects property and add 1 (one) effect and expand it.
  6. In the Effect inspector set the Prefab property to previously created sample effect prefab.
  7. Done!
Now you can run the scene and see effect appears when object goes into selected state and disappears when state is changing.

Additional editor features

  • By default effects appears as transform children of the object EffectsController is attached to. You can change this behavior by setting the Subject property in the Effect inspector.
  • You can use Animator component from any GameObject in the scene.
  • Use Reset On Replay flag in the Effect inspector to send Reset message to effect every time it is played.

Scripting effects

Mecanim Effects utilizes Unity 3D messaging system to introduce the custom scripting feature. Also state information and timer values are precalculated every frame and can be used in your scripts.

Messages

EffectsController can send three types of messages to the game object it is attached to.
  • Enter Message is sent in Update cycle in the first frame of the selected animator state;
  • Update Message is sent in Update cycle every frame the selected animator state remains active;
  • Timer Message is sent in Update cycle when timer reaches the timer treshold and only if timer treshold is more than zero;
  • Exit Message is sent in Update cycle in the frame following the last frame of the selected animator state.
Messages are sent only if name is explicitly specified in the Inspector window. When appopriate field is blank no message is sent to the object. Messages are sent using SendMessageOptions.RequireReceiver option value, so there will be a warning about unhandled messages.
At the moment an update message is sent along with enter message in the same update cycle. However this behavior is under question and may be changed in the future.
Example of message handler in C#:
void OnBaseLayerMoveEnter(EffectUpdateEventArgs e) {
   // your logic here
}

Timers and states

Current state and transition information is provided with EffectUpdateEventArgs class instace. Here is the EffectUpdateEventArgs class definition:
public class EffectUpdateEventArgs : System.EventArgs {
  public EffectsController controller;
  public int layerIndex;
}
Using controller.layerState array along with layerIndex value you can query and manipulate the handled animator's state or transition information. EffectUpdateEventArgs instance is sent along with every message.
Timings are essential for building game effects and animations. MecanimEffects provides you with Timer Message and the animator state timer values are calculated each Update call. You can use them within your messsage handlers. MecanimEffects provides following values:
  1. State seconds - state time in seconds from the beginning of current iteration.
  2. State seconds total - state time in seconds from the beginning of the first iteration.
  3. Loop count - state iteration count.
Example of getting a value:
void OnMyStateUpdate(EffectUpdateEventArgs e) {
   var stateSeconds = e.controller.layerState[e.layerIndex].stateSeconds;
}
You are not expected to store the reference to the instance of EffectUpdateEventArgs between calls or change its fields values. You are not expected to use layerState array outside of EffectController's message hadlers. This is because Unity 3D does not determine the order of calling Update on GameObject and therefore you can accidentaly get data from previous frame or uninitialized references in the first frame.

License

WTFPL – Do What the Fuck You Want to Public License
See license.txt for full license text.

Roadmap

  • Custom inspector UI - default inspector looks creepy and unintuintive, a new cool Inspector UI is coming soon!
  • Cross-state effects caching - states with same effect bound can share cachedInstance.
  • Continious effects - effects do not disappear in transition if the next state have similar effect attached. This is possible only with cross-state caching.

Planet Unity sample for doing an image search and putting the results in a PUGridTable

Image Search Example

Built with Planet Unity

This is a moderate example of how to build Unity UI using Planet Unity; it creates an application which allows you to perform an image by entering some text in an input field, pressing the search button, performing some asynchronous web requests and populating a grid table with the resulting images.
kittens!

Reconstructing from scratch

While having access to the completed project is nice, it can be much more informative to build it yourself from scratch. Here are the step-by-step instructions on how to duplicate this project on your own:

Creating and preparing the Unity project

  • Open Unity and create a new project
  • Create a Assets/Resources/Search folder
  • Create a Assets/Code folder
  • Create a Assets/Scenes folder
  • Create a new scene and save it as Assets/Scenes/Search.unity
  • Follow the Planet Unity integration instructions. I git-submoduled PlanetUnity to Assets/PlanetUnity2

Creating the basic UI of the Search scene

  • Create a new XML file Assets/Resources/Search/Search.xml
  • Add the following XML to Search.xml. This will provide a basic Canvas and a white square set to cover the entire screen.
      <?xml version="1.0" encoding="utf-8" ?>
      <Canvas renderMode="ScreenSpaceCamera" xmlns="http://schema.smallplanet.com/PlanetUnity2.xsd" >
          <Color color="#FFFFFFFF" anchor="stretch,stretch" />
      </Canvas>
    
  • In the Search.unity scene, you should have created a Game Object and attached the Planet Unity Game Object component to it. In the XmlPath field, add the path "Search/Search" (that's the Assets/Resources/Search/Search.xml path)
  • At this point, you should be able to play the Unity Editor and see the canvas and white square in the object hierarchy.

Creating a class to provide project specific overrides to Planet Unity

  • Planet Unity provides a lot of overrides and customizations to help fit your project needs. For this project, we need to override the default image loading optimization to allow Planet Unity to load Sprites.
  • Create a new C# script in Assets/Code/PlanetUnityOverrides.cs, add the following code to the file:
      using UnityEngine;
      public class PlanetUnityOverrides : MonoBehaviour, IPUCode {
    
          public void Awake() {
              PlanetUnityOverride.ForceActualSprites = true;
          }
      }
    
  • When setting overrides, it is important to set them in the Awake method. The Planet Unity Game Object component will load everything in the Start method, so this will ensure your overrides are properly set before any of the UI is loaded.
  • Add this new component to your the game object which contains your the Planet Unity Game Object component (technically it can be on any game object).

Creating the search field and search button

  • Add the following images ( searchButton.png, searchIcon.png, and inputFieldBackground.png ) to the Assets/Resources/Search folder
  • For the searchButton.png and the inputFieldBackground.png we want them to be Sprites and their border values set to 31,31,31,31 (this will allow them nicely to 9-point stretch to fill the space)
  • In Search.xml, add the the input field after the background color:
      <!-- This is a gray bar going along the top of the screen ; this will eventually cover the grid of images when they scroll up under the input field -->
      <Color color="#DDDDDDFF" bounds="@eval(0,0,w,68)" pivot="0,1" anchor="top,stretch" />
      <!-- This is the background images for the input field -->
      <Image resourcePath="Search/inputFieldBackground" bounds="10,-10,700,48" pivot="0,1" anchor="top,stretch">
          <!-- This is the actual input field component -->
          <InputField title="SearchField" onValueChanged="PerformSearch" sizeToFit="true" maxFontSize="28" alignment="middleLeft" bounds="@eval(10,10,w-20,h-20)" anchor="stretch,stretch" />
          <!-- This is the blue search button, attached to the right side of the text field -->
          <ImageButton resourcePath="Search/searchButton" onTouchUp="PerformSearch" bounds="@eval(0,0,48,48)" pivot="0,0.5" anchor="middle,right">
              <Image resourcePath="Search/searchIcon" pivot="0.5,0.5" bounds="@eval(0,0,w-20,h-20)" anchor="middle,center" />
          </ImageButton>
      </Image>
    
  • At this point, you should be able to Play the editor and see the gray bar along the top, the input field, and the blue search button

Adding the grid table and the controller class

  • When the results of the image search requests comes in, we will place those results in a nice scrolling table for the user to browse through. Add the following to Search.xml, right above the gray bar entity.
    <GridTable title="ImageResultsTable" expandToFill="false" bounds="@eval(0,0,w,h-68)" anchor="stretch,stretch" />
    
  • Before we write a C# script to control this scene, we want to attach it to this scene using a Code entity. Add the following lines to the bottom of Search.xml. When Planet Unity loads the XML, it will create an instance of the SearchController class, and link any titled entities to that classes member variables.
      <Code class="SearchController">
          <Notification name="PerformSearch" />
      </Code>
    
  • Now that the grid table and the input field is in place, we need to write some controller code to take the input from the text field, run the image search, and output the resulting images into the grid table. Create a C# script file at Assets/Code/SearchController.cs and put the following script into it:
    SearchController.cs
  • The public member variables which match the names and types of the titled entities will be populated automatically on creation of the controller class instance.
  • This code relies on litjson for the JSON parsing; you should include litjson or another JSON parser to handle this.
  • This is a standard Unity MonoBehaviour subclass, and it added as a comoponent to the game object which gets created by the Code entity
  • When you end editing on the input field, or press the search button, a code notification is sent named PerformSearch. In the previous step in our Code entity we have a Notification entity, whose name is PerformSearch. This tells the code entity that it should listen for notifications of PerformSearch and when they happen, call the PerformSearch() method on the SearchController class.

Code to support using PUTables

  • To use any variant of PUTable (PUTable, PUGridTable, or PUSimpleTable) we need to do a little bit more work; we need to create table cell classes for each type of table cell class we want to the table to be able to hold
  • These classes, along with some image downloading code which uses Unity's WWW class and coroutine to download the images asynchronously, are in the ImageTableSupport.cs
    ImageTableSupport.cs
  • To use PUTable, you supply a list of objects ( List<object>() ) to the entity by calling SetObjectList().
  • The list should be a list of data classes which contain the data for each cell (in our example, the ImageResult class )
  • We need to create a subclass of PUTableCell named the same name as our data class + TableCell (in our example ImageResultTableCell). This class is responsible to creating the view of each cell (either programmatically or by loading a table cell XML file), and being the controller for this cell (putting the actual data for each cell in the cell's views).

All done

At this point you should be able to play the Unity Editor, enter a search text in the input field, press the search button, and see the image search results populate the grid table.

License

PlanetUnity is free software distributed under the terms of the MIT license, reproduced below. PlanetUnity may be used for any purpose, including commercial purposes, at absolutely no cost. No paperwork, no royalties, no GNU-like "copyleft" restrictions. Just download and enjoy.
Copyright (c) 2014 Small Planet Digital, LLC
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

About Small Planet

Small Planet is a mobile agency in Brooklyn, NY that creates lovely experiences for smartphones and tablets. PlanetUnity has made our lives a lot easier and we hope it does the same for you. You can find us at www.smallplanet.com.

ETS2-Data-Viewer-Unity

ETS2-Data-Viewer-Unity

A simple software to connect the the ETS2 Telemetry Server, and view data such as Cargo, Distance to delivery, ETA (in game time) and estimated Real Time ETA (based on the calculated game Time Scale). It also displays the speed limit and you can toggle between NOK support (Norwegian currency) for ETS2 Scandinavian DLC support.
It runs on 10 fps, as not more is needed for a nice steady update of information. It connects to @Funbit's Telemetry Server and fetches the JSON and parses it with NewtonSoft.
Screenshot:
Imgur

Unity RTS Game

Unity RTS Game

Unity Real Time Strategy Game following the tutorial:
Noobtuts - RTS

Prerequires

  1. Unity 5.3+

Game


References

  1. Noobtuts - RTS

Simple Tilemap Unity3d

SimpleTilemap v1.0

Import Settings Import Settings
Developed for @isotacticsgame
SimpleTilemap is a totally free library for generating tilemaps in Unity at runtime. It provides users with a single script that, when used with a tilemap sprite, will generate a custom textured mesh with tilemap-indexed tiles, using a single GameObject. Its intended use is for 2D pixelart games with orthographic cameras, and has not been tested or verified with 3D assets.

Usage

All functionality is contained in the single SimpleTilemap script, with an example of full functionality in the two included example Unity scenes and in the APIDemo.cs script. The biggest thing to note with this library is that this script assumes certain import settings on tilemap sprties to work properly, which you can see below.
Import Settings
The big thing to note is that this script assumes that the texture is set to Sprite with a one pixel per unit PPU setting, Point filter mode, and no compression. "Sprite Mode" is also set to "Single", even for tilemaps. I recgonize this is somewhat of a limitation, but I also know this is somewhat standard practice for pixelart games in Unity. If anybody has any ideas/opinions around this, please let me know!
This is also why you need to fill in the tilemap parameters on the script. For more info on the component, see below.

Component parameters

Component Parameters
The component is relatively barebones, but displays core parameters to get the script working. In order:
Map Render Type allows you to choose between a Standard Grid map and an Isometric map. The main difference here is that Isometric maps are rendered in a slightly different way than standard maps, which is reflected in the appearance of the "Tile Art Height Fraction" and "Tile Pivot Y" parameters when Isometric is selected.
Map Size allows you to select how wide/tall you map is. Worth noting is that in standard maps, (0,0) is the bottom left corner, and in Isometric maps it is the leftmost corner. The max map size is currently limited to 100 only because that runs up againsts Unity's max vert number for a single mesh. I have ideas about how to make bigger maps, but I'll wait and see if it is a thing people are interested in.
Tile Width/Height is the width/height of a single tile in the tilemap, in Unity units. Note that this isn't how tall the art is in a given tile, but the actual tile dimensions. This should normally be your PPU import setting dimension in pixels of your tile, but changing these values while maintaining the same ratio between them will result in a small or large *rendered tilemap.
Tile Art Height Fraction is only relevant for Isometric maps and determines how to properly draw the map by defining what fraction of your total tile height your tile art occupies. A value of '2' would indicate that the tile base of your art is 1/2 the total height of your tile.
Tile Pivot Y determines where the leftmost point on a given tile in your isometric tilemap is in Y (X is assumed to be 0). This assumes that a given tile's (0,0) is in the bottom left corner, so this should be a positive value, with a maximum at your Tile Height.
Render Spacing controls how much space there is in Z between tiles on different "layers". This setting defaults to 1 and should be fine for most games. This is how the library sorts depth.
Tilemap Material this is the default material used to render the tilemap. It shouldn't be changed, but in actuality is just the Unity default Unlit/Transparent Cutout shader.
Tilemap is your actual tilemap sprite.
Tile Columns/Rows is how many columns/rows are in your provided tilemap.

Where to go from here

I'd love to hear feedback (issues/pull requests/DMs/etc.) on this library! I can be reached on Twitter through @kkukshtel or through my game @isotacticsgame). The intention is to keep the library as barebones as possible, so if you can think of features almost everyone would want, let me know, or submit a pull request.

License

Do whatever.

Voozix 2D game made using Unity

Voozix

Voozix is a 2D game made using Unity. The basic premise revolves around a player controlling a ball and collect stars in order to gain points. However, the more stars the player collects, the harder the game gets by spawning more enemies. Additional game modes and challenges are available as well.
The main development goal is to have a playground to lean more about shader effects and animations. Instead of implementing various effects on standalone applications, I decided implement them as part of a game.

Documentation

Unity Size Explorer

Build status
Unity Size Explorer example

Quick Start

Just want to run the tool using a pre-compiled binary?
Download Unity Size Explorer

Background

While developing Tumblestone for mobile devices I needed to greatly reduce the amount of disk space the game required. For iOS in particular games must be at or below 100 mb. Players must be on wifi in order to download games above 100 mb -- initially, Tumblestone was over 1 gb! I developed this tool to help reduce Tumblestone from 1 gb to 100 mb.
Normally, you can view Unity Editor's log after building to see some stats on a game's file size. This is what it looks like:
Textures      33.1 mb     54.1% 
Meshes        0.0 kb     0.0% 
Animations    0.0 kb     0.0% 
Sounds        8.3 mb     13.6% 
Shaders       172.8 kb     0.3% 
Other Assets  8.2 mb     13.4% 
Levels        82.1 kb     0.1% 
Scripts       4.7 mb     7.7% 
Included DLLs 6.4 mb     10.5% 
File headers  201.5 kb     0.3% 
Complete size 61.3 mb     100.0% 

Used Assets and files from the Resources folder, sorted by uncompressed size:
 2.1 mb     3.4% Assets/Spritesheets/v2/Spritesheet1.png
 2.1 mb     3.4% Assets/Spritesheets/v2/Spritesheet2.png
 2.0 mb     3.3% Assets/Spritesheets/v2/Spritesheet3.png
 2.0 mb     3.3% Assets/Spritesheets/v2/Spritesheet4.png
 // list continues for every file included in the game
This is quite helpful. It tells you how big your game is and breaks things down by high level categories. You can even look through the list of assets that follows to find the worst offendors. When first starting to optimize file size this is sufficient as oftentimes the largest files (listed at the top) can be optimized yielding big improvements.
Howvever in the quest to fit under 100 mb I reached a point where the list of files was no longer very useful. That's because there was no longer one or two big files to optimize. Everything non-essential was already quite small, and if I wanted to carve off another 10 or 15 mb I needed to strike at whole folders or class of files. Unity's log file, which lists every file sorted by size, makes it very hard to see the bigger picture.
Further aggravating things is the fact that Unity only generates the above after building. In my case building for iOS often took 5 to 10 minutes. This meant that my workflow was drawn out as I made a change, built, then compared the old and new log files. Sometimes the results worked as expected and I could continue. Other times the changes had a smaller impact and were discarded. I needed a way to more quickly and accurately gauge what impact an optimization would have without having to spend 10 minutes per an iteration.
That's where this tool comes in. It reads the log file and generates a tree view and pie chart. The tree view lists every file grouped by folder -- just like in the file system. You can expand or collapse folders to view sub-folders and files. You can check on or off a given file or folder, excluding the corresponding size from the projected game file size. Plus there's a nice pie chart visually showing how much space everything uses relative to the rest of the project.

Questions, Bug Reports or Feature Requests?

Do you have feature requests, questions or would you like to report a bug? Please post them on the issue list.

Contributing

As this projected is maintained by one person, I cannot fix every bug or implement every feature on my own. So contributions are really appreciated!
A good way to get started:
  1. Fork the Unity Size Explorer repo.
  2. Create a new branch in you current repo from the 'master' branch.
  3. 'Check out' the code with Git or GitHub Desktop
  4. Push commits and create a Pull Request (PR)

License

Unity Size Explorer is open source software, licensed under the terms of MIT license. See License.txt for details.

How to Build

Unity Size Explorer is a WPF program written for Windows. It requires .NET 4.5.2. Use Visual Studio and open solution file under Source. You may need to restore Nuget packages on first run.

How to Run

  1. Double-click UnitySizeExplorer.exe
  2. Go to File > Open
  3. Navigate to Unity Editor's log file. (Typically under $HOME\AppData\Local\Unity\Editor)
  4. Check or uncheck items in the tree view to add/remove them from the pie chart and estimated file size. Expand folders to work with their children directly.
  5. It helps if you first filter out very small files as they clutter the UI and can make the tool sluggish. Go to Filter > Small. These items will still be counted in the final size, but will be hidden from the tree view and pie chart.
  6. Note that you must clear the contents of the log file before building in Unity to ensure that there is only one size entry.

Unity3d Yarn Spinner


Yarn Spinner

Yarn Spinner logo
Yarn Spinner is an interpreter for the Yarn language, written in C#.
Yarn is a language that's designed to make it super easy to create interactive dialogue for games. Yarn's very similar in style to Twine, so if you already know that, you'll be right at home! If you don't, that's cool - Yarn's syntax is extremely minimal, and there's not much there to learn. The Yarn language is used in a number of cool games, including Night In The Woods and Knights and Bikes.
Important: Yarn Spinner is still under development, and we haven't made our 1.0 release yet. It's probably fine to use right now, but there are a few bits and pieces that might change between now and first release.
Build Status

(Image from "Night in the Woods" by Scott Benson, Bethany Hockenberry and Alec Holowka. Used with permission.)
Yarn Spinner is designed to be easy to add to Unity games, but it's also intended for use in other contexts as well.

Quick Start

  1. Download the Yarn editor, so that you can create and edit Yarn files.
  2. Create a new project in Unity.
  3. Download the latest release's Unity package.
  4. Import the package.
  5. Go to the Yarn Spinner/Examples/ folder in Unity, and open one of the demo scenes.
  6. Run the game, and poke around!

What To Do Next

License

Yarn Spinner is available under the MIT License. This means that you can use it in any commercial or noncommercial project. The only requirement is that you need to include attribution in your game's docs. A credit would be very, very nice, too, but isn't required.

Made by Secret Lab!

Yarn Spinner was originally created by Secret Lab, an Australian game dev studio! Come say hi! You can visit the Yarn Spinner page on the Secret Lab website for a little more info, and to donate to Yarn Spinner open source development at Secret Lab.
The awesome logo was made by the excellent Rex Smeal, and is under the Creative Commons Attribution-ShareAlike 4.0 International License.

Help Us Make Yarn Spinner!

Yarn Spinner needs your help to be as awesome as it can be! You don't have to be a coder to help out - we'd love to have your help in improving our documentation, in spreading the word, and in finding bugs.
  • Our issues page contains a list of things we'd love your help in improving.
  • Hop into our IRC channel, which is #yarnspinner on Freenode, to chat to the team, lend a hand, or ask questions.
If you want to contribute to Yarn Spinner (!!), go read our contributor's guide!