When we want to start talking in the game, we first need to decide what you want to include in that conversation. You can include the following things:

The more you look at it, the more you can dream about what you want to include. You just need to remember the KISS principle (Keep it simple, stupid), that is, start small and then build on it.

So, create a new C# script, name it ConversationEntry in ScriptsClasses, and populate it with the following code:

using UnityEngine;

[System.Serializable]
public class ConversationEntry {
  public string SpeakingCharacterName;
  public string ConversationText;
  public Sprite DisplayPic;
}

This gives us just the basics for our conversation system with regards to who's speaking, an optional picture that can be displayed in the conversation, and most importantly, the conversation text to be displayed.

We also tag this class with the System.Serializable code attribute so that the Unity serializer knows what to do with it.

With our core conversation entry object generated, we can start to store the conversations in the .asset files for use in our game and also make it possible to create the conversations outside of Unity if you wish.

As a conversation is (usually) more than just an opening line, we need a management object that will support several lines/entries of the conversation and a couple of switches to denote whether the conversation has already been played. This way, if you have multiple conversations configured for a character, it will simply play the next conversation and not repeat itself. You could just track this on the object where you attach the conversations to, but this is cleaner.

So, create another C# class in ScriptsClasses named Conversation and populate it with the following code:

using UnityEngine;

public class Conversation : ScriptableObject {

  public ConversationEntry[] ConversationLines;   
}

Now the first thing you will note is that this class is derived from a scriptable object class. As described earlier, this is what enables us to use Unity's serialization methods and store them as a .asset file.

We are not done yet as we need that final hook to enable us to create these (at least initially) in the editor.

Earlier, I showed you all of the code needed to create the asset for serialization, but this is rather a lot of code to be generated all the time. So, it's better to place that logic in a separate helper class that we can reuse rather than repeat ourselves all the time.

Earlier, with the PositionManager example, we created assets in the editor and reused them. You can reuse that code if you wish, but to simplify things, I added a little helper script to the example project in AssetsScriptsClasses. The CustomAssetUtility class does all the work that the preceding code does. It also uses the C# generics so that it can be reused for any type of SerializableObject you want to throw at it. You don't have to use the class I provided; you can just use the code earlier instead if you wish, just replace the code where the helper function is used.

To show how we use this, let's create our editor script, which will create the conversation assets for us. Create a new folder in AssetsScripts named Editor. In this folder, create a new script named ConversationAssetCreator in the Editor folder under AssetsScripts and then replace its contents with the following code:

using UnityEditor;
using UnityEngine;

public class ConversationAssetCreator : MonoBehaviour {

  [MenuItem("Assets/Create/Conversation")]
  public static void CreateAsset()
  {
    CustomAssetUtility.CreateAsset<Conversation>();
  }
}

So, by using the helper function, instead of all the tangle of code to first generate our asset and then save it, we simply call our utility, tell it the type of asset we want to create (in angle brackets), and away it goes. I have crated the utility as well so that it can also take a string parameter if you want to force the folder you want to create the asset in; otherwise, it will take whatever is currently selected in the editor.

To test this out, create a new folder in the Asset folder named Resources (so we can call assets directly from the code if we so wish) and then create another folder in Resources named Conversations. This just keeps all our conversations in one place and doesn't clutter up the hierarchy. If you so wish, you could create further subfolders to identify characters, places, or whatever else you fancy. It won't have an impact on the running of the game; it will just keep it tidy.

With the Conversation folder under AssetsResources selected, click on Create in the Project menu and you should see a new option named Conversation (as you can see in the script earlier, this is what we named it as). When you click on it, a new Conversation asset should appear, as shown in the following screenshot, which is ready for you to start configuring:

Feel free to set up your new conversation in whichever way you like or check the sample in the project I've created for Greybeard. Name the conversation GreybeardWarning and give it the lines shown in the following screenshot:

The last thing we need is a simple component to be able to attach conversations to a character or other game object in keeping with the Unity-component-based way of building games.

So, create a new class in the Classes folder under AssetsScripts named ConversationComponent and replace its contents with the following code:

using UnityEngine;

public class ConversationComponent : MonoBehaviour {

  public Conversation[] Conversations;

}

Nothing's complicated for now; the preceding code just holds an array of the possible conversations that the game object can have. Ideally, you would want to expand on this for a fuller conversation system, such as a pointer to the next conversation, or a way to track how many conversations have taken place, and so on.

If we create our conversation manager as we did before with the messaging manager, we start with the simple singleton framework. However, we will lean on one of the great examples from Unity Wiki as our base.

In the sample project under AssetsScriptsClasses, you will find a Singleton class that was sourced from http://wiki.unity3d.com/index.php/Singleton. This simply saves us time and code while creating singleton objects for use in our games and ensures they always have the same consistency.

With this in place, we can define our Conversation manager quite simply. Create a new C# script in AssetsScripts named ConversationManager and replace its contents with the following code:

using System.Collections;
using UnityEngine;

public class ConversationManager : Singleton<ConversationManager >
{
  //Guarantee this will always be a singleton only – 
  //can't use the constructor!
  protected ConversationManager () {} 

}

Now that we have our manager, we can start adding functionalities to it.

We want it to take a conversation item we have and do something with it because we have a manager. So, create a new function as follows:

public void StartConversation(Conversation conversation)
{}

This enables us to start a new conversation anywhere in the code by using the following code:

ConversationManager.Instance.StartConversation(conversation);

The manager is in place and we have a method to start a conversation, but it's not doing much right now. So, let's add some simple logic to display the text of the conversation on the screen. We will keep it simple since we are going to look into more complex GUI-related functionalities in Chapter 8, Shopping for Weapons.

Starting things off, we need some new properties in ConversationManager to control what needs to be displayed. So, open up the ConversationManager script and add the following properties to it:

//Is there a conversation going on
bool talking = false;

//The current line of text being displayed
ConversationEntry currentConversationLine;

//Estimated width of characters in the font
int fontSpacing = 7;

//How wide does the dialog window need to be
int conversationTextWidth;

//How high does the dialog window need to be
int dialogHeight = 70;

Each property explains its use, but everything will become clear as we add the rest of the functionality. Next, we'll add a Coroutine that will take a Conversation object and loop through all the lines to be displayed. Add the following function to the ConversationManager script:

IEnumerator DisplayConversation(Conversation conversation)
{
  talking = true;
  foreach (var conversationLine in conversation.ConversationLines)
  {
    currentConversationLine = conversationLine;
    conversationTextWidth = currentConversationLine.ConversationText.Length * fontSpacing;
    yield return new WaitForSeconds(3);
  }
  talking = false;
}

This simple Coroutine takes the conversation passed to it and loops through each of the individual lines of the conversation's text. Before we start, we set the talking flag to denote that a conversation is in progress; then, for each conversation line, we perform the following tasks:

So, we have a Coroutine looping through the text. The next thing to do is to use this information to display it on the screen. For this, we need an OnGUI method in our script as follows:

void OnGUI()
{
  if (talking)
  {
    //Layout start
    GUI.BeginGroup(new Rect(Screen.width / 2 - conversationTextWidth / 2, 50, conversationTextWidth + 10, dialogHeight));

    //The background box
    GUI.Box(new Rect(0, 0, conversationTextWidth + 10, dialogHeight), "");

    //The character name
    GUI.Label(new Rect(10, 10, conversationTextWidth + 30, 20), currentConversationLine.SpeakingCharacterName);

    //The conversation text
    GUI.Label(new Rect(10, 30, conversationTextWidth + 30, 20), currentConversationLine.ConversationText);

    //Layout end
    GUI.EndGroup();
  }
}

Like the navigation prompt in the previous chapter, we simply draw a GUI region, give it a background texture with the box using the default style, and then show two labels: one for the character who is speaking and one for the text of the conversation.

So, when the talking flag is set, Unity will know that it has to start drawing our conversation GUI on the screen.

To finish this off, we need to call the Coroutine from our public method, which other scripts can use to start a conversation:

public void StartConversation(Conversation conversation)
{
  //Start displaying the supplied conversation
  if (!talking)
  {
    StartCoroutine(DisplayConversation(conversation));
  }
}

There are two simple areas where we can take this further. We can use the sprite image and the style that we specified in the conversation item.

Adding the image is fairly simple; we just need to create enough space to display the image and then draw it.

Sadly, one of the areas that the new sprite system has not been merged with is the existing GUI system. It still relies on textures and not sprites. We can still work with it, but it means we have to select the sprite's texture from the spritesheet manually while drawing images. To do this, we use the DrawTextureWithTexCoords GUI function.

First, add a couple of properties to display the image using the following code:

//Offset space needed for character image
public int displayTextureOffset = 70;

//Scaled image rectangle for displaying character image
Rect scaledTextureRect;

The offset is to create space within our display region for the image, whereas the other property is to hold the scaling information to indicate that we need to pick our sprite from the spritesheet since the Unity system doesn't handle sprites.

Next, we need to calculate the scaling factor for the image for each conversation line, just in case we are using different sizes of textures for each character in the conversation. So, update the DisplayConversation Coroutine method with the following code:

IEnumerator DisplayConversation(Conversation conversation)
{
  talking = true;
  foreach (var conversationLine in conversation.ConversationLines)
  {
    currentConversationLine = conversationLine;
    conversationTextWidth = currentConversationLine.ConversationText.Length * fontSpacing;

    scalledTextureRect = new Rect( currentConversationLine.DisplayPic.textureRect.x / currentConversationLine.DisplayPic.texture.width,

      currentConversationLine.DisplayPic.textureRect.y / currentConversationLine.DisplayPic.texture.height,

      currentConversationLine.DisplayPic.textureRect.width / currentConversationLine.DisplayPic.texture.width,

      currentConversationLine.DisplayPic.textureRect.height / currentConversationLine.DisplayPic.texture.height);

    yield return new WaitForSeconds(3);
  }
  talking = false;
  yield return null;
}

Lastly, we just need to update the OnGUI method to make space for the image using the offset method and then add it to the draw list as follows:

void OnGUI()
{
  if (talking)
  {
    //Layout start
    GUI.BeginGroup(new Rect(Screen.width / 2 - conversationTextWidth / 2, 50, conversationTextWidth + displayTextureOffset + 10,dialogHeight));

    //The background box
    GUI.Box(new Rect(0, 0, conversationTextWidth + displayTextureOffset + 10,dialogHeight), "");

    //The character name
    GUI.Label(new Rect(displayTextureOffset, 10, conversationTextWidth + 30, 20), currentConversationLine.SpeakingCharacterName);

    //The conversation text
    GUI.Label(new Rect(displayTextureOffset, 30, conversationTextWidth + 30, 20), currentConversationLine.ConversationText);

    //The character image
    GUI.DrawTextureWithTexCoords(new Rect(10, 10, 50, 50), currentConversationLine.DisplayPic.texture, scalledTextureRect);

    //Layout end
    GUI.EndGroup(); 
  }
}

Note that the use of the DrawTextureWithTexCoords function and not the standard DrawTexture function is normally preferred in GUI drawing. This is because we are selecting the texture to be drawn from our spritesheet and we have to use scaled coordinates to pick the image as that is what the function uses. The Rect coordinates used in the Sprite object's textureRect property (the picking coordinates) are unscaled.