The Music Manager is intended for playing music. Many games have background music that plays independently of sounds. Some games may want music to persist from scene to scene or stop and then restart where it left off. The Music Manager is a singleton persistent game object intended to ease in the production of this.

MusicManager.cs

http://pastebin.com/cB89jPtD

Usage

MusicManager.cs should be added to an empty game object in the splash scene, this way it persists from scene to scene.

The Music Manager is capable of automatically fading in music when it loads, making for nicer transitions into a scene. The Fade Duration can be set in the inspector.

The Music Manager is best used with Music Playlists. A Music Playlist is an empty game object with the MusicPlaylist.cs script attached. MusicPlaylist.cs takes an array of audio clips. I recommend leaving the ‘Play On Awake’ option checked, this way the Music Manager will begin playing the playlist as soon as the scene is loaded. Each playlist should be set in the first scene in which the playlist is to be played.

The Music Manager automatically keeps playing the current playlist when the scene changes, unless the new scene has a playlist object. When a new playlist object is encountered, all other playlist objects are destroyed and the Music Manager loads the new playlist and begins playing it, possibly with a fade-out and fade-in if the Fade Duration is set in the Music Manager.

It is assumed each scene requiring a new playlist will have only one MusicPlaylist object. As of this post, there is no error handling if a scene has multiple playlist objects in the hierarchy.

I highly recommend watching the YouTube overview to understand how the music manager and music playlist systems work.

YouTube Overview and Demonstration

Next Up: Sound Manager

The sound manager is in charge of playing sound clips such as explosions, projectiles, etc. It is independent of the Music Manager so that sound effects can be controlled separately from background music. Read about the Sound Manager here: https://www.zesix.com/2015/02/unity-soundmanager-c/

This is a basic mouse input class to be customized for a particular game’s needs and loaded depending on device. Note that unlike the Keyboard_Input class, this requires tweaking the Input Manager in the project settings since the default are not fully compatible with this (in my opinion) more optimized script.

Mouse_Input.cs

using UnityEngine;
using System.Collections;

public class Mouse_Input : BaseInputController {
    private Vector2 prevMousePos;
    private Vector2 mouseDelta;
    
    private float speedX = 0.05f;
    private float speedY = 0.1f;
    
    public void Start () {
        prevMousePos= Input.mousePosition;
    }
    
    public override void CheckInput () {
        // get input data from vertical and horizontal axis and store them internally in vert and horz so we don't
        // have to access them every time we need to relay input data out
        
        // calculate a percentage amount to use per pixel
        float scalerX = 100f / Screen.width;
        float scalerY = 100f / Screen.height;
        
        // calculate and use deltas
        float mouseDeltaY =  Input.mousePosition.y - prevMousePos.y;
        float mouseDeltaX =  Input.mousePosition.x - prevMousePos.x;
        
        // scale based on screen size
        vert += ( mouseDeltaY * speedY ) * scalerY;
        horz += ( mouseDeltaX * speedX ) * scalerX;
        
        // store this mouse position for the next time we're here
        prevMousePos= Input.mousePosition;
        
        // set up some boolean values for up, down, left and right
        Up    = ( vert>0 );
        Down    = ( vert<0 );
        Left    = ( horz<0 );
        Right    = ( horz>0 );    
        
        // get fire / action buttons
        Fire1= Input.GetButton( "Fire1" );
    }
    
    public void LateUpdate() {
        // check inputs each LateUpdate() ready for the next tick
        CheckInput();
    }
}

Next Up: MusicManager.cs

Many games have background music. The Music Manager is a singleton in charge of making sure music loads and is played when needed.

This is a basic keyboard input class to be customized for a particular game’s needs and loaded depending on device.

Keyboard_Input.cs

using UnityEngine;
using System.Collections;

public class Keyboard_Input : BaseInputController {
    
    public override void CheckInput () {    
        // get input data from vertical and horizontal axis and store them internally in vert and horz so we don't
        // have to access them every time we need to relay input data.
        vert = Input.GetAxis ("Vertical");
        horz = Input.GetAxis ("Horizontal");
        
        // set up some boolean values for up, down, left and right
        Up      = (vert > 0);
        Down    = (vert < 0);
        Left    = (horz < 0);
        Right   = (horz > 0);    
        
        // get fire / action keys
        Fire1 = Input.GetButton ("Fire1");
        shouldRespawn = Input.GetButton ("Fire3");
    }
    
    public void LateUpdate () {
        // check inputs each LateUpdate() ready for the next tick
        CheckInput ();
    }
}

The reason why we check for input in LateUpdate() is to ensure all physics handling to have resolved by the time we handle new input. This is particularly important when physics may impact the position of the camera and player object.

Up Next: Mouse_Input

Along the same lines as keyboard input, most developers coding on desktops will have access to a mouse and choose to use it as part of the game’s desktop controls if that is the target platform. Find the Mouse_Input script here: https://www.zesix.com/2015/02/unity-mouse_input-c/

BaseInputController is an extendable class for building input-specific controllers such as keyboard and touch controllers. This script is not intended to be used directly but instead extended, with an extended script loaded based on what platform and/or inputs the project is currently targeting. Later on, I will provide a generic keyboard input controller that extends BaseInputController. This will be the script you will use most in this framework for handling keyboard input. For now, this script is provided as a reference in case you want to build your own input controllers.

BaseInputController.cs

using UnityEngine;
using System.Collections;

public class BaseInputController : MonoBehaviour {
    
    // directional buttons
    public bool Up;
    public bool Down;
    public bool Left;
    public bool Right;
    
    // fire / action buttons
    public bool Fire1;
    
    // weapon slots
    public bool Slot1;
    public bool Slot2;
    public bool Slot3;
    public bool Slot4;
    public bool Slot5;
    public bool Slot6;
    public bool Slot7;
    public bool Slot8;
    public bool Slot9;
    
    public float vert;
    public float horz;
    public bool shouldRespawn;
    
    public Vector3 TEMPVec3;
    private Vector3 zeroVector = new Vector3(0,0,0);
    
    public virtual void CheckInput () {    
        // override with your own code to deal with input
        horz=Input.GetAxis ("Horizontal");
        vert=Input.GetAxis ("Vertical");
    }
    
    public virtual float GetHorizontal() {
        // returns our cached horizontal input axis value
        return horz;
    }
    
    public virtual float GetVertical() {
        // returns our cached vertical input axis value
        return vert;
    }
    
    public virtual bool GetFire() {
        return Fire1;
    }
    
    public bool GetRespawn() {
        return shouldRespawn;    
    }
    
    public virtual Vector3 GetMovementDirectionVector() {
        // temp vector for movement dir gets set to the value of an otherwise unused vector that always have the value of 0,0,0
        TEMPVec3=zeroVector;
        
        TEMPVec3.x=horz;
        TEMPVec3.y=vert;

        // return the movement vector
        return TEMPVec3;
    }

}

Usage

All input scripts use CheckInput() as their default update function. This is intended to be called by the player class (since enemies generally don’t move to player input). This function just takes the axis input from Unity’s default Input class, which already sets up a horizontal and vertical axis. To return a specific axis, the GetHorizontal() and GetVertical() functions can be used. Both of these are virtual in case the developer wants to add additional information depending on the device.

The script assumes the game will utilize some kind of firing input. The GetFire() function is handy for this.

GetRespawn() returns the bool of the variable shouldRespawn. Not every game will have lives, but most games nowadays have a respawn system (meaning shouldRespawn will always be true), so we provide it here for convenience.

Note that GetFire() and GetRespawn() currently are just empty virtual functions – these should be built upon based on game requirements.

GetMovementDirectionVector() will return a Vector3 type based on the current state of input, which is useful for processing movement without having to check individual horizontal and vertical components.

Up Next: Keyboard_Input

The BaseInputController is great for creating specific input controllers, but since most developers will be working on a device with a keyboard, it is handy to have a default keyboard input controller for testing and possibly production use. Read about Keyboard_Input here: https://www.zesix.com/2015/02/unity-keyboard_input-c/