To start with, we will need a C# script.

Perform the following steps:

The SceneBackground file will hold four sprites. Each of these sprites will have their own movement speed and movement distance (speed being how fast they move and distance is how far forward and backward they can move).

Add the following code to the SceneBackground file before the Start function:

    // Struct to hold data for Background Element
    [System.Serializable]
    public struct BackgroundElement
    {
      public Sprite BackgroundSprite;
      public float MovementSpeed;
      public float MovementDistance; 
      public Vector3 SpriteLocation;
      public Vector3 SpriteScale;

      [System.NonSerialized]
      public Vector3 ObjectStartLocation;
      [System.NonSerialized]
      public GameObject ChildObject;
      [System.NonSerialized]
      public bool bMoveBackwards;
    };

    // Array to store backgrounds for scene
    public BackgroundElement[ ] SceneBackgroundElement;

The BackgroundElement struct is a way for us to create a sprite and manage its MovementSpeed and MovementDirection without having to create individual variables for all of them. This way, we can compartmentalize the data into a single struct object and assign the values we need with less code clutter. Then, with the SceneBackgroundElement array, we can create and assign the background images with unique settings to handle them correctly.

[System.Serializable] allows you to edit these variables in the editor. Without this, the variables will not be shown in the Inspector window when you select the GameObject from the Hierarchy or Project folder(s).

Save the SceneBackground code file and go back to Unity. Right-click on Hierarchy and then select Create Empty. Name this SceneBackground.

In the Inspector window, with the new SceneBackground GameObject selected in Hierarchy, click on Add Component. Search for SceneBackground and select SceneBackground.

You should see a drop-down list for Scene Background Element with zero elements. Set the number of elements to four. You should now see the empty elements for Scene Background Element:

In order to set all of these, we need to import the art for them. In the Assets folder, right-click and select Create and then Folder. Name this Background.

Open the Background folder and right-click on it. Then, click on Import New Asset…. Navigate to the book art files and find the folder named ChapterFive_Background. Import all the four images.

This includes:

Select all the four images in the Assets/Background folder. Then, in the Inspector window, perform the following steps:

With the SceneBackground GameObject selected in Hierarchy, click on the drop-down list for the 0 element of the SceneBackground script component.

In the Sprite object slot, click on the small circle with a dot. When the window opens, select the sprite object, search for Background_00 and then select Background_00. Change the Sprite Location to 0X, 0Y, and 0Z; then, set the Sprite Scale to 1X, 1Y, and 1Z. Leave Movement Speed and Movement Distance as zero.

Next, we want to set the second element: clouds. Again, with the SceneBackground GameObject selected, take at look at the Inspector tab and click on the 1or 2 element drop-down list so that you change the settings as follows:

Next element is smaller mountains:

Finally, for the bigger mountains:

The following is screenshot showing the settings for all the elements:

We will update the Movement Speed and Movement Distance values after we write the code that handles these values.

For now, let's write the code that will create and place the GameObjects and sprites based on the settings we just created. In the Start function of the SceneBackground class, write the following code:

  // Use this for initialization
  void Start ( )
  {
    SpriteRenderer backgroundRenderer;
    GameObject backgroundObj;

    for (int i = 0; i < SceneBackgroundElement.Length; i++)
    {
      // new GameObject
      backgroundObj = new GameObject( );

      // Parent it, set its position, and scale
      backgroundObj.transform.SetParent( transform );
      backgroundObj.transform.position = SceneBackgroundElement[i].SpriteLocation;
      backgroundObj.transform.localScale = SceneBackgroundElement[i].SpriteScale;

      // Keep reference of new object and its start location
      SceneBackgroundElement[ i ].ChildObject = backgroundObj;
      SceneBackgroundElement[ i ].ObjectStartLocation = backgroundObj.transform.position;

      // Create Renderer and set Sprite
      backgroundRenderer = backgroundObj.AddComponent<SpriteRenderer>();
      backgroundRenderer.sprite = SceneBackgroundElement[ i ].BackgroundSprite;
    }
  }

As we only have values to use and are not using any direct reference to other GameObjects in the scene for these, we have to create them. To do this, we need a SpriteRenderer and a GameObject to hold it.

We know by the number of elements created by us (or if you were on a bigger team, the designer) in the GameObject SceneBackground script component that we have to create a certain number of GameObjects to hold the BackgroundSprite for each of the SceneBackgroundElement objects. In order to create all of them efficiently, we will use a for loop that will loop the number of created SceneBackgroundElement objects.

In each loop, we can create a new GameObject and set its parent using the SetParent function to transform the GameObject that holds this SceneBackground script component. We will then set its local position and scale, relative to the parent transform location, to the settings we entered. Then, we will store the new GameObject that was created to the SceneBackgroundElement of that loop and its location.

After this, add a SpriteRenderer component to the newly created GameObject and assign the sprite from the settings we entered to the sprite for SpriteRenderer.

If you run the game now, you should see a background with some mountains. The clouds will be out of the field of view of the camera. We will fix this by having them move across the screen.

    // Update is called once per frame
    void Update ( ) 
    {
      for (int i = 0; i < SceneBackgroundElement.Length; i++) 
      {
        // Does the SceneBackgroundElement move
        if (SceneBackgroundElement[i].MovementSpeed > 0)
        {
          // Get current location and offset it by movement speed, based on bMoveBackwards
          Vector3 newSceneBackgroundLoc = SceneBackgroundElement[ i ].ChildObject.transform.position;
          newSceneBackgroundLoc.x += (SceneBackgroundElement[i].bMoveBackwards) 
          ? -SceneBackgroundElement[i].MovementSpeed * Time.deltaTime
          : SceneBackgroundElement[i].MovementSpeed * Time.deltaTime;

          // Set location based on movement speed offset
          SceneBackgroundElement[ i ].ChildObject.transform.position = newSceneBackgroundLoc;

          // If ChildObject has moved farther than move distance, have it move the other way.
          if (Vector3.Distance(SceneBackgroundElement[i].ChildObject.transform.position, SceneBackgroundElement[i].ObjectStartLocation) >=
          SceneBackgroundElement[i].MovementDistance)
          {
            // Change the direction of the SceneBackgroundElement
            SceneBackgroundElement[ i ].bMoveBackwards = !SceneBackgroundElement[ i ].bMoveBackwards;
          }

        }
      }
    }