Hi Harmony here…

Check out this feature character for our new game Endless Elevator.

He’s “The Law Man” and he’s bringing Justice to the small screen.

He’s a chunky little guy and dependably dapper.

Look at that moustache!

He comes complete with accessorised bullet proof vest and fast blasting six gun action.

Bad Guys look out! He’s coming soon.

Xander here.

For our new game Endless Elevator I’ve been working on finding the best method of moving the character through the scenes.

At it’s most basic our character needs to move left and right across the screen and forwards and backwards on a couple of limited parallel z axis.

The only way he can move up or down is by an escalator or an elevator so we have to take control away from the user in that case and handover to another controller.  Then once we were done moving we can hand control back to the user.

But it was mostly the left-right, forwards-backwards movements I was concerned about for this set of tests.

I wanted a really simple set of controls and didn’t want to hand them over to the Physics Engine with Rigidbodies and Colliders.  But the character movement couldn’t feel stiff or mechanical. We wanted a bit of slack in the movement and bounce

.

I scripted up three different methods of controlling the character with flip switches to move between them during testing so we could decide on the best looking movement.

Method One was the most simple basic Vector move.

Method Two was a damped Vector move using mathf.DampSmooth.

Method Three was to implement the Character Controller and use Object.Move.

I’ll put the script down the bottom of the post. Right now I want to look the actual movement controllers and the Input into those commands.

Let’s start with the Basic Move controller.

We define our speed as a float and get the x and z values from our Vertical and Horizontal Input Axis (WASD or Arrow Keys on the computer).

public float speed = 10f;
var x = Input.GetAxis(“Horizontal”);     // this is a float value between -1 and 1 that tracks left and right input from the left and right controller.  If it’s under 0 we move left. If it’s over 0 we move right. Simple easy to understand and doesn’t factor into the movement at all except to define which way we go.

var z = Input.GetAxis(“Vertical”);  // We do the same for the z value which governs character depth on the screen (forwards and backwards).

if (x < 0) {
transform.position -= new Vector3(speed * Time.deltaTime, 0, 0);  // Move Left the value of speed and normalised for frame rate differences with the deltaTime function.
}
if (x > 0) {
transform.position += new Vector3(speed * Time.deltaTime, 0, 0);  // Right
}
if (z < 0) {
transform.position -= new Vector3(0, 0, speed * Time.deltaTime);  // Towards the camera
}
if (z > 0)
{
transform.position += new Vector3(0, 0, speed * Time.deltaTime);  // Away from the camera
}
Every Update we move our character in the desired direction at a speed of 10.

This is fine. It works. But it looks kind of static.  The character hits full speed straight away and stops on a dime.  It’s not particularly realistic looking (and maybe you want your game to have this look) and not what I really wanted.  But it’s a great comparison to judge the other two methods by.

Let’s look at the Smooth Damp method next.

We use the same kind of input:  eg. x = Input.GetAxis(“Horizontal”);

speed = 1f;  //  This method is much faster so we need to reduce the speed to keep all the methods at roughly the same rate.

We set some variables that control the “bounciness” of the smoothing.

public float forwardVelocity = 0;
public float sidewaysVelocity = 10;

// These Velocity floats hold the value of the velocity between Updates (I only wanted some on the left right movement)

public float movementSmoothing = 0.15f;  // the higher the number the slower it get’s to top speed.

Mathf.SmoothDamp takes the current position and the raw input from the Input keys. That means that those values between -1 and 1 amp up or down over a small amount of time (depending on the direction) . This is is factored together with the current velocity
movementInput.x = Mathf.SmoothDamp(movementInput.x, Input.GetAxisRaw(“Horizontal”), ref forwardVelocity, movementSmoothing);
movementInput.y = Mathf.SmoothDamp(movementInput.y, Input.GetAxisRaw(“Vertical”), ref sidewaysVelocity, movementSmoothing);
transform.position += new Vector3(movementInput.x * speed, 0, movementInput.y * speed);

//transform.position += new Vector3(movementInput.x * speed * Time.deltaTime, 0, movementInput.y* speed * Time.deltaTime);  // I had that last line with the deltaTime in it as well but it looked “moochy” if that’s a word and did the opposite of smoothing the transitions so it ended up looking like this:

movementInput.x = Mathf.SmoothDamp(movementInput.x, Input.GetAxisRaw(“Horizontal”), ref forwardVelocity, movementSmoothing);

Mathf.SmoothDamp
Gradually changes a value towards a desired goal over time.

public static float SmoothDamp(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed = Mathf.Infinity, float deltaTime = Time.deltaTime);

Input.GetAxisRaw(“Horizontal”) goes straight from -1 on left arrow back to 0 when off and +1 on right arrow – no smoothing.
Input.GetAxis(“Horizontal”); does the same thing but increments gradually over a short time so that it goes from 0 to 1 in a few microseconds.

Sooo using the Raw one and pumping it into the SmoothDamp function does pretty much the same thing. In the Editor I cannot tell the difference between them.

This controller took a bit more playing with but was really looking good.  It picks up speed incrementally when you start moving and there is a controllable amount of exaggerated overshooting when you change direction. If you set the smoothing or velocity too high it gets really bouncy and a little crazy but at low levels it looks cartoony and mimics the  stretch and squash of that genre.

Lastly I looked at the character controller. It’s part of the system so really easy to set up in a simple move script to get a feel for it.

speed = 20f;  // Once again the speed was modified to get a realistic similarity between the three methods.

The character direction comes straight from the input controllers and the cc.Move method handles everything else.

direction = new Vector3((Input.GetAxis(“Vertical”)), 0, (-(Input.GetAxis(“Horizontal”))));
direction1 = transform.TransformDirection(-direction);
cc.Move(direction1 * speed * Time.deltaTime);

Initially this looked really good. But the more I played with it to try and limit the way it was moving the character and the amount of radians it could turn it quickly got way too complicated and I started getting weird movement behaviour.  So if you want a character controller that you can just plug in and go with then this is good. But if you want more control be prepared for a longer haul.

As with everything this was a greats study into character control methods and one step in the path of looking for a smooth moving character but in the end following a massive redesign of the level system of my game I ended up going with a physics based collider system for the levels and a physics controller.

Not all my time wasted though as I had a better understanding of what I wanted and used elements of both the Smooth Move method and the Basic method in my final Character Control script.

This is the final edit of the script I was using if you want to play with it.  Just attach it to a player and add a character controller.  Use the tick boxes on the bools in the editor to switch between methods while playing.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SmoothMove : MonoBehaviour
{

public bool basicMove;
public bool smoothDampMove;
public bool CCMove;

public Vector2 movementInput = Vector2.zero;
public float forwardVelocity = 0;
public float sidewaysVelocity = 10;

public float movementSmoothing = 0.15f; // the higher the number the slower it get’s to top speed
public float speed;

public CharacterController cc;
public Vector3 direction = Vector3.zero;
public Vector3 direction1; // used for debugging in the editor
float smooth = 50.0f;

// Update is called once per frame
void Update()
{
if (basicMove)
{
speed = 10f;
var x = Input.GetAxis(“Horizontal”);
var z = Input.GetAxis(“Vertical”);

if (x < 0)
{
transform.position -= new Vector3(speed * Time.deltaTime, 0, 0);
}
if (x > 0)
{
transform.position += new Vector3(speed * Time.deltaTime, 0, 0);
}

if (z < 0)
{
transform.position -= new Vector3(0, 0, speed * Time.deltaTime);
}
if (z > 0)
{
transform.position += new Vector3(0, 0, speed * Time.deltaTime);
}
}

if (smoothDampMove)
{
speed = 1f;
movementInput.x = Mathf.SmoothDamp(movementInput.x, Input.GetAxisRaw(“Horizontal”), ref forwardVelocity, movementSmoothing);
movementInput.y = Mathf.SmoothDamp(movementInput.y, Input.GetAxisRaw(“Vertical”), ref sidewaysVelocity, movementSmoothing);
//transform.position += new Vector3(movementInput.x * speed * Time.deltaTime, 0, movementInput.y* speed * Time.deltaTime);
transform.position += new Vector3(movementInput.x * speed, 0, movementInput.y * speed);
}

if (CCMove)
{
speed = 20f;
direction = new Vector3((Input.GetAxis(“Vertical”)), 0, (-(Input.GetAxis(“Horizontal”))));
//direction = new Vector3(0, 0, (-Input.GetAxis(“Horizontal”)));
direction1 = transform.TransformDirection(direction);
//direction1 *= speed;
cc.Move(direction1 * speed * Time.deltaTime);
}
}
}

Oh My DOG! Playing with MagicalVoxel is fun! I don’t know what made me open it up. A little bit of frustration with my Dog Run game that’s not really going anywhere that I was happy with. If you feel like doing some beta testing and telling me where I’ve got it all wrong subscribe and I’ll add you into the Alpha Testers group.

You know when you get into that development funk and you can’t seem to get anything to work?

Anyway I was doing some animation research and saw that Magical Voxel had a new upgrade that enabled little animations and that kind of excited me. So I downloaded it and started playing around then BOOM. Inspiration strikes and in a couple of hours I got ten level objects and a new idea for a game and another project building in Unity already.

The voxel editor isn’t that great for porting colored objects into unity cause it creates a new vector for every color and does something a bit funky with the poly count. No problem. I did everything in one color to reduce the number of crazy vectors and imported it into Blender.  Then I added a decimation modifier to lower the poly count and merged a few faces. But then I just started importing models directly into Unity with simple walls and floors and doors and it was awesome.  There was no need to reduce the poly count with such simple meshes. Such a quick workflow!  I could make a doorway or a lift and the actual door or lift box would just fit inside the door frame or lift shaft with no modifications! Awesome. Everything to the same scale.

Import all that into unity and add a dummy character and some basic lighting and here you go…….

Looks great huh?

Unity projects need to be backed up.

There’s a lot of options and lot’s of questions to ask yourself.

The big question is…could you recreate your project from scratch if something happened to it?

Does your Design or Build documentation cover off every tweak and setting of all your scenes, objects, and prefabs?

What about using a Unity Plug In?
Or Custom Scripts?
Also what do you neeed to Backup?

If you’re using Source Control like SVN or GIT what do you exclude in your exclude file?
What does Unity say?
What about Unity users in the forums what is their advice?

Backup Options

Let’s start with some options for backing up Unity Projects.
I’ll list the one’s I’ve looked at here:
1. Manual backup of your Unity Project Folder
– That’s right. Just copy the whole root project folder somewhere else.
It’s quick and dirty but reliable. Even better if you copy to another location off your workstation.

2. Your project can be placed under source control.
– The Unity Manual says that Unity supports version control integration with Perforce and Plastic SCM.
– I’ve tried Perforce and it was a little difficult to set up and I can’t say I really got some of the key concepts behind the product but it looks like standard source control and seems to work.
– I didn’t try Plastic SCM as it didn’t seem as well integrated or supported
– GIT is an easier beast to work with I found.
– Unity have advice on using external source control software like SVN for your project files and code.

3. You can use the Unity Editor to work in the Cloud
– There is a button called Collaborate! Just click it.

When you open up your Projects page in Unity you can see the one’s in Cloud storage here:

The features of the Cloud storage are here: https://unity3d.com/unity/features/collaborate
You don’t get much for a free account – but it’s not that expensive and if you have a good internet connection it’s very reliable.

4. In the Asset Store there is (or at least used to be) a Unity Asset Repository product.
– It seems to be discontinued so I won’t dwell on that.

5. There is also a whole slew of Tools and Products up there in the store to help with managing Version Control. There are Backup Products in the Asset Store like Zip Backup and Backup Project.

I’ve never used any of these so I won’t comment on that either. There are plenty of reviews on the Asset Store so I guess if you’re interested you can read them.

6. If you want automatic regular backups on a Mac you could use Time Machine.
On a Windows box you could also schedule backups with File History and/or Windows Backup and Restore.
Another alternative that works on anything is DropBox.

7. Finally – there are of course dedicated Backup Solutions ( think NetBackup ) out there – maybe you are already using one.

What to Backup?

So the next question is what in your Unity Project Folder do you need to back up?
The short answer is the Assets and Project Settings only.
The Library, Temp, Obj, .SLNs and .Proj will be regenerated.

But the long answer has a few other folders that you might have created for your project.

The base folders that all projects get when initiated are: Assets, Library, & Project Settings.

Assets is where the majority of your work will go but you could also use any number of other special folders like:
Editor
Editor Default Resources
Gizmos
Plug-ins
Resources
Standard Assets
StreamingAssets
Hidden Assets

There is also a Temp folder which sometimes has it’s uses to keep a copy of.
(See my blog post on recovering a corrupted scene – DO NOT RESTART UNITY before taking a backup!)

So what folders need to be backed up?
Assets definitely – but everything in there? What about .meta files.
Meta files are created for every asset and are visible in the explorer of your operating system but not by default visible in the Unity Editor.
The Meta file has a reference to the Unity ID code assigned to the object. If you lose your meta file you lose all the references to your objects in the editor and have to relink everything.

The Library folder is analagous to the Unity cache. It’s a dynamically loaded set of data that Unity creates for your project. Each asset in your Asset’s folder is converted into a Unit Readable data format in this folder so that it can be dynamically played with in the editor. Normally as a user you would not need to do anything with the contents of this folder and it’s not necessary to back it up as it’s able to be regenerated every time Unity starts up your project.

The Unity Manual says:
When backing up a project, or adding a project to a Version Control Repository, you should include the main Unity project folder, containing both the Assets and ProjectSettings folders. All the information in these folders is crucial to the way Unity works. You should omit the Library and Temp folders for backup purposes.

I guess one of the bottom lines of this post is: Use Version Control.
But are version control and back ups two different things? I say yes.

Version Control is a point in time file based recovery of your work but Backups are a whole system recovery for when things really go boom! Like when your laptop gets dropped off the balcony.

So if you are using Version Control you also need to use an ignore file so you don’t have to backup stuff that you don’t need to back up.

There are some really awesome flame wars in all sorts of forums arguing for and against .gitignore files. This reddit link is really funny if you like reading passionate people and idiots talking to each other on the internet.
https://www.reddit.com/r/Unity3D/comments/557bhh/version_control_is_important_and_wed_like_your/

A .gitignore file tells Git which files/folders should not be in the repository. It is usually used to avoid committing transient files or files that can be reproduced (like those in the Library folder).

When you create a new repository on GitHub. There is a dropdown that lets you choose a .gitignore file and they just happen to have a Unity one available. Just grab a copy of it and stick it in the main folder of your Unity project.

I commit to the repository every time I have made a big change. This lets me revert to any previous commit if necessary. The downside is that unless you feel like paying, your repository will need to be public, meaning anyone can see your project.

If you don’t want to use the terminal, you can also download Github desktop which gives you a simple and clear interface to handle your repositories.

The GitHub.app is the easiest way to work with Git. It is simple to create a repository by draging your Unity folder into the GitHub.app and add your .gitignore file. It only takes seconds and will save your butt.

There are other choices for a source control browser:
Gitkraken
SourceTree

Before checking your project in, you have to tell Unity to modify the project structure slightly to make it compatible with storing assets in an external version control system. This is done by selecting Edit->Project Settings->Editor in the application menu and enabling External Version Control support by selecting Visible Meta Files in the dropdown for Version Contr

I’ve read from various forums that people have been backing up by creating an empty game object and parenting all other objects under it. Then they will create a prefab out of this and export the object and scenes at the same time. It kind of makes sense for an easy restore of your objects as all you have to do is import that prefab into a project to do a restore.
Obviously this is no good if you got lots (like thousands) of objects and assets. You will lose things like layer names, tags, and other Project settings. Plus you might as well just copy the Project folder. Exporting packages is useful thing, but it’s not a substitute for a proper backup.

When you do backup make sure you get all the metafiles. The files are used to keep track of everything in the project and their locations. They are hidden by default, but can be made visible by going into Edit | Project Settings | Editor Settings | switch Version Control Mode to Visible Meta Files.

That’s about it for backups – I guess the bottom line is – if you are not backing up…

Please do!