Recorded Video Session: Text Adventure Game Part 1

Tutorial

·

Beginner

·

+0XP

·

80 mins

·

(393)

Unity Technologies

Recorded Video Session: Text Adventure Game Part 1

In this session we will learn how to program a text based adventure game in which the player explores a series of rooms by reading text and inputting commands via the keyboard.

Materials

Languages available:

1. Introduction and Goals

In this session we will learn how to program a text based adventure game in which the player explores a series of rooms by reading text and inputting commands via the keyboard.

Creating a Text Based Adventure - Introduction and Goals [1/8] Live 2017/3/22

Room

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

[CreateAssetMenu(menuName = "TextAdventure/Room")]
public class Room : ScriptableObject 
{
    [TextArea]
    public string description;
    public string roomName;
    public Exit[] exits;


}

GameController

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

public class GameController : MonoBehaviour {

    public Text displayText;
    public InputAction[] inputActions;

    [HideInInspector] public RoomNavigation roomNavigation;
    [HideInInspector] public List<string> interactionDescriptionsInRoom = new List<string> ();

    List<string> actionLog = new List<string>();

    // Use this for initialization
    void Awake () 
    {
        roomNavigation = GetComponent<RoomNavigation> ();    
    }

    void Start()
    {
        DisplayRoomText ();
        DisplayLoggedText ();
    }

    public void DisplayLoggedText()
    {
        string logAsText = string.Join ("\n", actionLog.ToArray ());

        displayText.text = logAsText;
    }

    public void DisplayRoomText()
    {
        ClearCollectionsForNewRoom ();

        UnpackRoom ();

        string joinedInteractionDescriptions = string.Join ("\n", interactionDescriptionsInRoom.ToArray ());

        string combinedText = roomNavigation.currentRoom.description + "\n" + joinedInteractionDescriptions;

        LogStringWithReturn (combinedText);
    }

    void UnpackRoom()
    {
        roomNavigation.UnpackExitsInRoom ();
    }

    void ClearCollectionsForNewRoom()
    {
        interactionDescriptionsInRoom.Clear ();
        roomNavigation.ClearExits ();
    }

    public void LogStringWithReturn(string stringToAdd)
    {
        actionLog.Add (stringToAdd + "\n");
    }

    // Update is called once per frame
    void Update () {

    }
}

RoomNavigation

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

public class RoomNavigation : MonoBehaviour {

    public Room currentRoom;


    Dictionary<string, Room> exitDictionary = new Dictionary<string, Room> ();
    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
    }

    public void UnpackExitsInRoom()
    {
        for (int i = 0; i < currentRoom.exits.Length; i++) 
        {
            exitDictionary.Add (currentRoom.exits [i].keyString, currentRoom.exits [i].valueRoom);
            controller.interactionDescriptionsInRoom.Add (currentRoom.exits [i].exitDescription);
        }
    }

    public void AttemptToChangeRooms(string directionNoun)
    {
        if (exitDictionary.ContainsKey (directionNoun)) {
            currentRoom = exitDictionary [directionNoun];
            controller.LogStringWithReturn ("You head off to the " + directionNoun);
            controller.DisplayRoomText ();
        } else 
        {
            controller.LogStringWithReturn ("There is no path to the " + directionNoun);
        }

    }

    public void ClearExits()
    {
        exitDictionary.Clear ();
    }
}

Exit

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

[System.Serializable]
public class Exit
{
    public string keyString;
    public string exitDescription;
    public Room valueRoom;
}

TextInput

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

public class TextInput : MonoBehaviour 
{
    public InputField inputField;

    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
        inputField.onEndEdit.AddListener (AcceptStringInput);
    }

    void AcceptStringInput(string userInput)
    {
        userInput = userInput.ToLower ();
        controller.LogStringWithReturn (userInput);

        char[] delimiterCharacters = { ' ' };
        string[] separatedInputWords = userInput.Split (delimiterCharacters);

        for (int i = 0; i < controller.inputActions.Length; i++) 
        {
            InputAction inputAction = controller.inputActions [i];
            if (inputAction.keyWord == separatedInputWords [0]) 
            {
                inputAction.RespondToInput (controller, separatedInputWords);
            }
        }

        InputComplete ();

    }

    void InputComplete()
    {
        controller.DisplayLoggedText ();
        inputField.ActivateInputField ();
        inputField.text = null;
    }

}

InputAction

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

public abstract class InputAction : ScriptableObject 
{
    public string keyWord;

    public abstract void RespondToInput (GameController controller, string[] separatedInputWords);
}

Go

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

[CreateAssetMenu(menuName= "TextAdventure/InputActions/Go")]
public class Go : InputAction
{
    public override void RespondToInput (GameController controller, string[] separatedInputWords)
    {
        controller.roomNavigation.AttemptToChangeRooms (separatedInputWords [1]);
    }
}

2. Project Architecture Overview

In this session we will learn how to program a text based adventure game in which the player explores a series of rooms by reading text and inputting commands via the keyboard.

Creating a Text Based Adventure - Project Architecture Overview [2/8] Live 2017/3/22

Room

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

[CreateAssetMenu(menuName = "TextAdventure/Room")]
public class Room : ScriptableObject 
{
    [TextArea]
    public string description;
    public string roomName;
    public Exit[] exits;


}

GameController

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

public class GameController : MonoBehaviour {

    public Text displayText;
    public InputAction[] inputActions;

    [HideInInspector] public RoomNavigation roomNavigation;
    [HideInInspector] public List<string> interactionDescriptionsInRoom = new List<string> ();

    List<string> actionLog = new List<string>();

    // Use this for initialization
    void Awake () 
    {
        roomNavigation = GetComponent<RoomNavigation> ();    
    }

    void Start()
    {
        DisplayRoomText ();
        DisplayLoggedText ();
    }

    public void DisplayLoggedText()
    {
        string logAsText = string.Join ("\n", actionLog.ToArray ());

        displayText.text = logAsText;
    }

    public void DisplayRoomText()
    {
        ClearCollectionsForNewRoom ();

        UnpackRoom ();

        string joinedInteractionDescriptions = string.Join ("\n", interactionDescriptionsInRoom.ToArray ());

        string combinedText = roomNavigation.currentRoom.description + "\n" + joinedInteractionDescriptions;

        LogStringWithReturn (combinedText);
    }

    void UnpackRoom()
    {
        roomNavigation.UnpackExitsInRoom ();
    }

    void ClearCollectionsForNewRoom()
    {
        interactionDescriptionsInRoom.Clear ();
        roomNavigation.ClearExits ();
    }

    public void LogStringWithReturn(string stringToAdd)
    {
        actionLog.Add (stringToAdd + "\n");
    }

    // Update is called once per frame
    void Update () {

    }
}

RoomNavigation

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

public class RoomNavigation : MonoBehaviour {

    public Room currentRoom;


    Dictionary<string, Room> exitDictionary = new Dictionary<string, Room> ();
    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
    }

    public void UnpackExitsInRoom()
    {
        for (int i = 0; i < currentRoom.exits.Length; i++) 
        {
            exitDictionary.Add (currentRoom.exits [i].keyString, currentRoom.exits [i].valueRoom);
            controller.interactionDescriptionsInRoom.Add (currentRoom.exits [i].exitDescription);
        }
    }

    public void AttemptToChangeRooms(string directionNoun)
    {
        if (exitDictionary.ContainsKey (directionNoun)) {
            currentRoom = exitDictionary [directionNoun];
            controller.LogStringWithReturn ("You head off to the " + directionNoun);
            controller.DisplayRoomText ();
        } else 
        {
            controller.LogStringWithReturn ("There is no path to the " + directionNoun);
        }

    }

    public void ClearExits()
    {
        exitDictionary.Clear ();
    }
}

Exit

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

[System.Serializable]
public class Exit
{
    public string keyString;
    public string exitDescription;
    public Room valueRoom;
}

TextInput

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

public class TextInput : MonoBehaviour 
{
    public InputField inputField;

    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
        inputField.onEndEdit.AddListener (AcceptStringInput);
    }

    void AcceptStringInput(string userInput)
    {
        userInput = userInput.ToLower ();
        controller.LogStringWithReturn (userInput);

        char[] delimiterCharacters = { ' ' };
        string[] separatedInputWords = userInput.Split (delimiterCharacters);

        for (int i = 0; i < controller.inputActions.Length; i++) 
        {
            InputAction inputAction = controller.inputActions [i];
            if (inputAction.keyWord == separatedInputWords [0]) 
            {
                inputAction.RespondToInput (controller, separatedInputWords);
            }
        }

        InputComplete ();

    }

    void InputComplete()
    {
        controller.DisplayLoggedText ();
        inputField.ActivateInputField ();
        inputField.text = null;
    }

}

InputAction

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

public abstract class InputAction : ScriptableObject 
{
    public string keyWord;

    public abstract void RespondToInput (GameController controller, string[] separatedInputWords);
}

Go

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

[CreateAssetMenu(menuName= "TextAdventure/InputActions/Go")]
public class Go : InputAction
{
    public override void RespondToInput (GameController controller, string[] separatedInputWords)
    {
        controller.roomNavigation.AttemptToChangeRooms (separatedInputWords [1]);
    }
}

3. Creating Rooms

In this session we will learn how to program a text based adventure game in which the player explores a series of rooms by reading text and inputting commands via the keyboard.

Creating a Text Based Adventure - Creating Rooms [3/8] Live 2017/3/22

Room

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

[CreateAssetMenu(menuName = "TextAdventure/Room")]
public class Room : ScriptableObject 
{
    [TextArea]
    public string description;
    public string roomName;
    public Exit[] exits;


}

GameController

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

public class GameController : MonoBehaviour {

    public Text displayText;
    public InputAction[] inputActions;

    [HideInInspector] public RoomNavigation roomNavigation;
    [HideInInspector] public List<string> interactionDescriptionsInRoom = new List<string> ();

    List<string> actionLog = new List<string>();

    // Use this for initialization
    void Awake () 
    {
        roomNavigation = GetComponent<RoomNavigation> ();    
    }

    void Start()
    {
        DisplayRoomText ();
        DisplayLoggedText ();
    }

    public void DisplayLoggedText()
    {
        string logAsText = string.Join ("\n", actionLog.ToArray ());

        displayText.text = logAsText;
    }

    public void DisplayRoomText()
    {
        ClearCollectionsForNewRoom ();

        UnpackRoom ();

        string joinedInteractionDescriptions = string.Join ("\n", interactionDescriptionsInRoom.ToArray ());

        string combinedText = roomNavigation.currentRoom.description + "\n" + joinedInteractionDescriptions;

        LogStringWithReturn (combinedText);
    }

    void UnpackRoom()
    {
        roomNavigation.UnpackExitsInRoom ();
    }

    void ClearCollectionsForNewRoom()
    {
        interactionDescriptionsInRoom.Clear ();
        roomNavigation.ClearExits ();
    }

    public void LogStringWithReturn(string stringToAdd)
    {
        actionLog.Add (stringToAdd + "\n");
    }

    // Update is called once per frame
    void Update () {

    }
}

RoomNavigation

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

public class RoomNavigation : MonoBehaviour {

    public Room currentRoom;


    Dictionary<string, Room> exitDictionary = new Dictionary<string, Room> ();
    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
    }

    public void UnpackExitsInRoom()
    {
        for (int i = 0; i < currentRoom.exits.Length; i++) 
        {
            exitDictionary.Add (currentRoom.exits [i].keyString, currentRoom.exits [i].valueRoom);
            controller.interactionDescriptionsInRoom.Add (currentRoom.exits [i].exitDescription);
        }
    }

    public void AttemptToChangeRooms(string directionNoun)
    {
        if (exitDictionary.ContainsKey (directionNoun)) {
            currentRoom = exitDictionary [directionNoun];
            controller.LogStringWithReturn ("You head off to the " + directionNoun);
            controller.DisplayRoomText ();
        } else 
        {
            controller.LogStringWithReturn ("There is no path to the " + directionNoun);
        }

    }

    public void ClearExits()
    {
        exitDictionary.Clear ();
    }
}

Exit

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

[System.Serializable]
public class Exit
{
    public string keyString;
    public string exitDescription;
    public Room valueRoom;
}

TextInput

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

public class TextInput : MonoBehaviour 
{
    public InputField inputField;

    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
        inputField.onEndEdit.AddListener (AcceptStringInput);
    }

    void AcceptStringInput(string userInput)
    {
        userInput = userInput.ToLower ();
        controller.LogStringWithReturn (userInput);

        char[] delimiterCharacters = { ' ' };
        string[] separatedInputWords = userInput.Split (delimiterCharacters);

        for (int i = 0; i < controller.inputActions.Length; i++) 
        {
            InputAction inputAction = controller.inputActions [i];
            if (inputAction.keyWord == separatedInputWords [0]) 
            {
                inputAction.RespondToInput (controller, separatedInputWords);
            }
        }

        InputComplete ();

    }

    void InputComplete()
    {
        controller.DisplayLoggedText ();
        inputField.ActivateInputField ();
        inputField.text = null;
    }

}

InputAction

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

public abstract class InputAction : ScriptableObject 
{
    public string keyWord;

    public abstract void RespondToInput (GameController controller, string[] separatedInputWords);
}

Go

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

[CreateAssetMenu(menuName= "TextAdventure/InputActions/Go")]
public class Go : InputAction
{
    public override void RespondToInput (GameController controller, string[] separatedInputWords)
    {
        controller.roomNavigation.AttemptToChangeRooms (separatedInputWords [1]);
    }
}

4. Creating Exits

In this session we will learn how to program a text based adventure game in which the player explores a series of rooms by reading text and inputting commands via the keyboard.

Creating a Text Based Adventure - Creating Exits [4/8] Live 2017/3/22

Room

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

[CreateAssetMenu(menuName = "TextAdventure/Room")]
public class Room : ScriptableObject 
{
    [TextArea]
    public string description;
    public string roomName;
    public Exit[] exits;


}

GameController

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

public class GameController : MonoBehaviour {

    public Text displayText;
    public InputAction[] inputActions;

    [HideInInspector] public RoomNavigation roomNavigation;
    [HideInInspector] public List<string> interactionDescriptionsInRoom = new List<string> ();

    List<string> actionLog = new List<string>();

    // Use this for initialization
    void Awake () 
    {
        roomNavigation = GetComponent<RoomNavigation> ();    
    }

    void Start()
    {
        DisplayRoomText ();
        DisplayLoggedText ();
    }

    public void DisplayLoggedText()
    {
        string logAsText = string.Join ("\n", actionLog.ToArray ());

        displayText.text = logAsText;
    }

    public void DisplayRoomText()
    {
        ClearCollectionsForNewRoom ();

        UnpackRoom ();

        string joinedInteractionDescriptions = string.Join ("\n", interactionDescriptionsInRoom.ToArray ());

        string combinedText = roomNavigation.currentRoom.description + "\n" + joinedInteractionDescriptions;

        LogStringWithReturn (combinedText);
    }

    void UnpackRoom()
    {
        roomNavigation.UnpackExitsInRoom ();
    }

    void ClearCollectionsForNewRoom()
    {
        interactionDescriptionsInRoom.Clear ();
        roomNavigation.ClearExits ();
    }

    public void LogStringWithReturn(string stringToAdd)
    {
        actionLog.Add (stringToAdd + "\n");
    }

    // Update is called once per frame
    void Update () {

    }
}

RoomNavigation

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

public class RoomNavigation : MonoBehaviour {

    public Room currentRoom;


    Dictionary<string, Room> exitDictionary = new Dictionary<string, Room> ();
    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
    }

    public void UnpackExitsInRoom()
    {
        for (int i = 0; i < currentRoom.exits.Length; i++) 
        {
            exitDictionary.Add (currentRoom.exits [i].keyString, currentRoom.exits [i].valueRoom);
            controller.interactionDescriptionsInRoom.Add (currentRoom.exits [i].exitDescription);
        }
    }

    public void AttemptToChangeRooms(string directionNoun)
    {
        if (exitDictionary.ContainsKey (directionNoun)) {
            currentRoom = exitDictionary [directionNoun];
            controller.LogStringWithReturn ("You head off to the " + directionNoun);
            controller.DisplayRoomText ();
        } else 
        {
            controller.LogStringWithReturn ("There is no path to the " + directionNoun);
        }

    }

    public void ClearExits()
    {
        exitDictionary.Clear ();
    }
}

Exit

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

[System.Serializable]
public class Exit
{
    public string keyString;
    public string exitDescription;
    public Room valueRoom;
}

TextInput

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

public class TextInput : MonoBehaviour 
{
    public InputField inputField;

    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
        inputField.onEndEdit.AddListener (AcceptStringInput);
    }

    void AcceptStringInput(string userInput)
    {
        userInput = userInput.ToLower ();
        controller.LogStringWithReturn (userInput);

        char[] delimiterCharacters = { ' ' };
        string[] separatedInputWords = userInput.Split (delimiterCharacters);

        for (int i = 0; i < controller.inputActions.Length; i++) 
        {
            InputAction inputAction = controller.inputActions [i];
            if (inputAction.keyWord == separatedInputWords [0]) 
            {
                inputAction.RespondToInput (controller, separatedInputWords);
            }
        }

        InputComplete ();

    }

    void InputComplete()
    {
        controller.DisplayLoggedText ();
        inputField.ActivateInputField ();
        inputField.text = null;
    }

}

InputAction

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

public abstract class InputAction : ScriptableObject 
{
    public string keyWord;

    public abstract void RespondToInput (GameController controller, string[] separatedInputWords);
}

Go

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

[CreateAssetMenu(menuName= "TextAdventure/InputActions/Go")]
public class Go : InputAction
{
    public override void RespondToInput (GameController controller, string[] separatedInputWords)
    {
        controller.roomNavigation.AttemptToChangeRooms (separatedInputWords [1]);
    }
}

5. Text Input

In this session we will learn how to program a text based adventure game in which the player explores a series of rooms by reading text and inputting commands via the keyboard.

Creating a Text Based Adventure - Text Input [5/8] Live 2017/3/22

Room

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

[CreateAssetMenu(menuName = "TextAdventure/Room")]
public class Room : ScriptableObject 
{
    [TextArea]
    public string description;
    public string roomName;
    public Exit[] exits;


}

GameController

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

public class GameController : MonoBehaviour {

    public Text displayText;
    public InputAction[] inputActions;

    [HideInInspector] public RoomNavigation roomNavigation;
    [HideInInspector] public List<string> interactionDescriptionsInRoom = new List<string> ();

    List<string> actionLog = new List<string>();

    // Use this for initialization
    void Awake () 
    {
        roomNavigation = GetComponent<RoomNavigation> ();    
    }

    void Start()
    {
        DisplayRoomText ();
        DisplayLoggedText ();
    }

    public void DisplayLoggedText()
    {
        string logAsText = string.Join ("\n", actionLog.ToArray ());

        displayText.text = logAsText;
    }

    public void DisplayRoomText()
    {
        ClearCollectionsForNewRoom ();

        UnpackRoom ();

        string joinedInteractionDescriptions = string.Join ("\n", interactionDescriptionsInRoom.ToArray ());

        string combinedText = roomNavigation.currentRoom.description + "\n" + joinedInteractionDescriptions;

        LogStringWithReturn (combinedText);
    }

    void UnpackRoom()
    {
        roomNavigation.UnpackExitsInRoom ();
    }

    void ClearCollectionsForNewRoom()
    {
        interactionDescriptionsInRoom.Clear ();
        roomNavigation.ClearExits ();
    }

    public void LogStringWithReturn(string stringToAdd)
    {
        actionLog.Add (stringToAdd + "\n");
    }

    // Update is called once per frame
    void Update () {

    }
}

RoomNavigation

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

public class RoomNavigation : MonoBehaviour {

    public Room currentRoom;


    Dictionary<string, Room> exitDictionary = new Dictionary<string, Room> ();
    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
    }

    public void UnpackExitsInRoom()
    {
        for (int i = 0; i < currentRoom.exits.Length; i++) 
        {
            exitDictionary.Add (currentRoom.exits [i].keyString, currentRoom.exits [i].valueRoom);
            controller.interactionDescriptionsInRoom.Add (currentRoom.exits [i].exitDescription);
        }
    }

    public void AttemptToChangeRooms(string directionNoun)
    {
        if (exitDictionary.ContainsKey (directionNoun)) {
            currentRoom = exitDictionary [directionNoun];
            controller.LogStringWithReturn ("You head off to the " + directionNoun);
            controller.DisplayRoomText ();
        } else 
        {
            controller.LogStringWithReturn ("There is no path to the " + directionNoun);
        }

    }

    public void ClearExits()
    {
        exitDictionary.Clear ();
    }
}

Exit

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

[System.Serializable]
public class Exit
{
    public string keyString;
    public string exitDescription;
    public Room valueRoom;
}

TextInput

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

public class TextInput : MonoBehaviour 
{
    public InputField inputField;

    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
        inputField.onEndEdit.AddListener (AcceptStringInput);
    }

    void AcceptStringInput(string userInput)
    {
        userInput = userInput.ToLower ();
        controller.LogStringWithReturn (userInput);

        char[] delimiterCharacters = { ' ' };
        string[] separatedInputWords = userInput.Split (delimiterCharacters);

        for (int i = 0; i < controller.inputActions.Length; i++) 
        {
            InputAction inputAction = controller.inputActions [i];
            if (inputAction.keyWord == separatedInputWords [0]) 
            {
                inputAction.RespondToInput (controller, separatedInputWords);
            }
        }

        InputComplete ();

    }

    void InputComplete()
    {
        controller.DisplayLoggedText ();
        inputField.ActivateInputField ();
        inputField.text = null;
    }

}

InputAction

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

public abstract class InputAction : ScriptableObject 
{
    public string keyWord;

    public abstract void RespondToInput (GameController controller, string[] separatedInputWords);
}

Go

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

[CreateAssetMenu(menuName= "TextAdventure/InputActions/Go")]
public class Go : InputAction
{
    public override void RespondToInput (GameController controller, string[] separatedInputWords)
    {
        controller.roomNavigation.AttemptToChangeRooms (separatedInputWords [1]);
    }
}

6. Reacting To String Input

In this session we will learn how to program a text based adventure game in which the player explores a series of rooms by reading text and inputting commands via the keyboard.

Creating a Text Based Adventure - Reacting To String Input [6/8] Live 2017/3/22

Room

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

[CreateAssetMenu(menuName = "TextAdventure/Room")]
public class Room : ScriptableObject 
{
    [TextArea]
    public string description;
    public string roomName;
    public Exit[] exits;


}

GameController

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

public class GameController : MonoBehaviour {

    public Text displayText;
    public InputAction[] inputActions;

    [HideInInspector] public RoomNavigation roomNavigation;
    [HideInInspector] public List<string> interactionDescriptionsInRoom = new List<string> ();

    List<string> actionLog = new List<string>();

    // Use this for initialization
    void Awake () 
    {
        roomNavigation = GetComponent<RoomNavigation> ();    
    }

    void Start()
    {
        DisplayRoomText ();
        DisplayLoggedText ();
    }

    public void DisplayLoggedText()
    {
        string logAsText = string.Join ("\n", actionLog.ToArray ());

        displayText.text = logAsText;
    }

    public void DisplayRoomText()
    {
        ClearCollectionsForNewRoom ();

        UnpackRoom ();

        string joinedInteractionDescriptions = string.Join ("\n", interactionDescriptionsInRoom.ToArray ());

        string combinedText = roomNavigation.currentRoom.description + "\n" + joinedInteractionDescriptions;

        LogStringWithReturn (combinedText);
    }

    void UnpackRoom()
    {
        roomNavigation.UnpackExitsInRoom ();
    }

    void ClearCollectionsForNewRoom()
    {
        interactionDescriptionsInRoom.Clear ();
        roomNavigation.ClearExits ();
    }

    public void LogStringWithReturn(string stringToAdd)
    {
        actionLog.Add (stringToAdd + "\n");
    }

    // Update is called once per frame
    void Update () {

    }
}

RoomNavigation

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

public class RoomNavigation : MonoBehaviour {

    public Room currentRoom;


    Dictionary<string, Room> exitDictionary = new Dictionary<string, Room> ();
    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
    }

    public void UnpackExitsInRoom()
    {
        for (int i = 0; i < currentRoom.exits.Length; i++) 
        {
            exitDictionary.Add (currentRoom.exits [i].keyString, currentRoom.exits [i].valueRoom);
            controller.interactionDescriptionsInRoom.Add (currentRoom.exits [i].exitDescription);
        }
    }

    public void AttemptToChangeRooms(string directionNoun)
    {
        if (exitDictionary.ContainsKey (directionNoun)) {
            currentRoom = exitDictionary [directionNoun];
            controller.LogStringWithReturn ("You head off to the " + directionNoun);
            controller.DisplayRoomText ();
        } else 
        {
            controller.LogStringWithReturn ("There is no path to the " + directionNoun);
        }

    }

    public void ClearExits()
    {
        exitDictionary.Clear ();
    }
}

Exit

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

[System.Serializable]
public class Exit
{
    public string keyString;
    public string exitDescription;
    public Room valueRoom;
}

TextInput

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

public class TextInput : MonoBehaviour 
{
    public InputField inputField;

    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
        inputField.onEndEdit.AddListener (AcceptStringInput);
    }

    void AcceptStringInput(string userInput)
    {
        userInput = userInput.ToLower ();
        controller.LogStringWithReturn (userInput);

        char[] delimiterCharacters = { ' ' };
        string[] separatedInputWords = userInput.Split (delimiterCharacters);

        for (int i = 0; i < controller.inputActions.Length; i++) 
        {
            InputAction inputAction = controller.inputActions [i];
            if (inputAction.keyWord == separatedInputWords [0]) 
            {
                inputAction.RespondToInput (controller, separatedInputWords);
            }
        }

        InputComplete ();

    }

    void InputComplete()
    {
        controller.DisplayLoggedText ();
        inputField.ActivateInputField ();
        inputField.text = null;
    }

}

InputAction

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

public abstract class InputAction : ScriptableObject 
{
    public string keyWord;

    public abstract void RespondToInput (GameController controller, string[] separatedInputWords);
}

Go

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

[CreateAssetMenu(menuName= "TextAdventure/InputActions/Go")]
public class Go : InputAction
{
    public override void RespondToInput (GameController controller, string[] separatedInputWords)
    {
        controller.roomNavigation.AttemptToChangeRooms (separatedInputWords [1]);
    }
}

7. Input Actions And The Delegate Pattern

In this session we will learn how to program a text based adventure game in which the player explores a series of rooms by reading text and inputting commands via the keyboard.

Creating a Text Based Adventure - Input Actions And The Delegate Pattern [7/8] Live 2017/3/22

Room

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

[CreateAssetMenu(menuName = "TextAdventure/Room")]
public class Room : ScriptableObject 
{
    [TextArea]
    public string description;
    public string roomName;
    public Exit[] exits;


}

GameController

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

public class GameController : MonoBehaviour {

    public Text displayText;
    public InputAction[] inputActions;

    [HideInInspector] public RoomNavigation roomNavigation;
    [HideInInspector] public List<string> interactionDescriptionsInRoom = new List<string> ();

    List<string> actionLog = new List<string>();

    // Use this for initialization
    void Awake () 
    {
        roomNavigation = GetComponent<RoomNavigation> ();    
    }

    void Start()
    {
        DisplayRoomText ();
        DisplayLoggedText ();
    }

    public void DisplayLoggedText()
    {
        string logAsText = string.Join ("\n", actionLog.ToArray ());

        displayText.text = logAsText;
    }

    public void DisplayRoomText()
    {
        ClearCollectionsForNewRoom ();

        UnpackRoom ();

        string joinedInteractionDescriptions = string.Join ("\n", interactionDescriptionsInRoom.ToArray ());

        string combinedText = roomNavigation.currentRoom.description + "\n" + joinedInteractionDescriptions;

        LogStringWithReturn (combinedText);
    }

    void UnpackRoom()
    {
        roomNavigation.UnpackExitsInRoom ();
    }

    void ClearCollectionsForNewRoom()
    {
        interactionDescriptionsInRoom.Clear ();
        roomNavigation.ClearExits ();
    }

    public void LogStringWithReturn(string stringToAdd)
    {
        actionLog.Add (stringToAdd + "\n");
    }

    // Update is called once per frame
    void Update () {

    }
}

RoomNavigation

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

public class RoomNavigation : MonoBehaviour {

    public Room currentRoom;


    Dictionary<string, Room> exitDictionary = new Dictionary<string, Room> ();
    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
    }

    public void UnpackExitsInRoom()
    {
        for (int i = 0; i < currentRoom.exits.Length; i++) 
        {
            exitDictionary.Add (currentRoom.exits [i].keyString, currentRoom.exits [i].valueRoom);
            controller.interactionDescriptionsInRoom.Add (currentRoom.exits [i].exitDescription);
        }
    }

    public void AttemptToChangeRooms(string directionNoun)
    {
        if (exitDictionary.ContainsKey (directionNoun)) {
            currentRoom = exitDictionary [directionNoun];
            controller.LogStringWithReturn ("You head off to the " + directionNoun);
            controller.DisplayRoomText ();
        } else 
        {
            controller.LogStringWithReturn ("There is no path to the " + directionNoun);
        }

    }

    public void ClearExits()
    {
        exitDictionary.Clear ();
    }
}

Exit

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

[System.Serializable]
public class Exit
{
    public string keyString;
    public string exitDescription;
    public Room valueRoom;
}

TextInput

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

public class TextInput : MonoBehaviour 
{
    public InputField inputField;

    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
        inputField.onEndEdit.AddListener (AcceptStringInput);
    }

    void AcceptStringInput(string userInput)
    {
        userInput = userInput.ToLower ();
        controller.LogStringWithReturn (userInput);

        char[] delimiterCharacters = { ' ' };
        string[] separatedInputWords = userInput.Split (delimiterCharacters);

        for (int i = 0; i < controller.inputActions.Length; i++) 
        {
            InputAction inputAction = controller.inputActions [i];
            if (inputAction.keyWord == separatedInputWords [0]) 
            {
                inputAction.RespondToInput (controller, separatedInputWords);
            }
        }

        InputComplete ();

    }

    void InputComplete()
    {
        controller.DisplayLoggedText ();
        inputField.ActivateInputField ();
        inputField.text = null;
    }

}

InputAction

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

public abstract class InputAction : ScriptableObject 
{
    public string keyWord;

    public abstract void RespondToInput (GameController controller, string[] separatedInputWords);
}

Go

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

[CreateAssetMenu(menuName= "TextAdventure/InputActions/Go")]
public class Go : InputAction
{
    public override void RespondToInput (GameController controller, string[] separatedInputWords)
    {
        controller.roomNavigation.AttemptToChangeRooms (separatedInputWords [1]);
    }
}

8. Questions and Answers

In this session we will learn how to program a text based adventure game in which the player explores a series of rooms by reading text and inputting commands via the keyboard.

Creating a Text Based Adventure - Questions and Answers [8/8] Live 2017/3/22

Room

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

[CreateAssetMenu(menuName = "TextAdventure/Room")]
public class Room : ScriptableObject 
{
    [TextArea]
    public string description;
    public string roomName;
    public Exit[] exits;


}

GameController

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

public class GameController : MonoBehaviour {

    public Text displayText;
    public InputAction[] inputActions;

    [HideInInspector] public RoomNavigation roomNavigation;
    [HideInInspector] public List<string> interactionDescriptionsInRoom = new List<string> ();

    List<string> actionLog = new List<string>();

    // Use this for initialization
    void Awake () 
    {
        roomNavigation = GetComponent<RoomNavigation> ();    
    }

    void Start()
    {
        DisplayRoomText ();
        DisplayLoggedText ();
    }

    public void DisplayLoggedText()
    {
        string logAsText = string.Join ("\n", actionLog.ToArray ());

        displayText.text = logAsText;
    }

    public void DisplayRoomText()
    {
        ClearCollectionsForNewRoom ();

        UnpackRoom ();

        string joinedInteractionDescriptions = string.Join ("\n", interactionDescriptionsInRoom.ToArray ());

        string combinedText = roomNavigation.currentRoom.description + "\n" + joinedInteractionDescriptions;

        LogStringWithReturn (combinedText);
    }

    void UnpackRoom()
    {
        roomNavigation.UnpackExitsInRoom ();
    }

    void ClearCollectionsForNewRoom()
    {
        interactionDescriptionsInRoom.Clear ();
        roomNavigation.ClearExits ();
    }

    public void LogStringWithReturn(string stringToAdd)
    {
        actionLog.Add (stringToAdd + "\n");
    }

    // Update is called once per frame
    void Update () {

    }
}

RoomNavigation

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

public class RoomNavigation : MonoBehaviour {

    public Room currentRoom;


    Dictionary<string, Room> exitDictionary = new Dictionary<string, Room> ();
    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
    }

    public void UnpackExitsInRoom()
    {
        for (int i = 0; i < currentRoom.exits.Length; i++) 
        {
            exitDictionary.Add (currentRoom.exits [i].keyString, currentRoom.exits [i].valueRoom);
            controller.interactionDescriptionsInRoom.Add (currentRoom.exits [i].exitDescription);
        }
    }

    public void AttemptToChangeRooms(string directionNoun)
    {
        if (exitDictionary.ContainsKey (directionNoun)) {
            currentRoom = exitDictionary [directionNoun];
            controller.LogStringWithReturn ("You head off to the " + directionNoun);
            controller.DisplayRoomText ();
        } else 
        {
            controller.LogStringWithReturn ("There is no path to the " + directionNoun);
        }

    }

    public void ClearExits()
    {
        exitDictionary.Clear ();
    }
}

Exit

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

[System.Serializable]
public class Exit
{
    public string keyString;
    public string exitDescription;
    public Room valueRoom;
}

TextInput

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

public class TextInput : MonoBehaviour 
{
    public InputField inputField;

    GameController controller;

    void Awake()
    {
        controller = GetComponent<GameController> ();
        inputField.onEndEdit.AddListener (AcceptStringInput);
    }

    void AcceptStringInput(string userInput)
    {
        userInput = userInput.ToLower ();
        controller.LogStringWithReturn (userInput);

        char[] delimiterCharacters = { ' ' };
        string[] separatedInputWords = userInput.Split (delimiterCharacters);

        for (int i = 0; i < controller.inputActions.Length; i++) 
        {
            InputAction inputAction = controller.inputActions [i];
            if (inputAction.keyWord == separatedInputWords [0]) 
            {
                inputAction.RespondToInput (controller, separatedInputWords);
            }
        }

        InputComplete ();

    }

    void InputComplete()
    {
        controller.DisplayLoggedText ();
        inputField.ActivateInputField ();
        inputField.text = null;
    }

}

InputAction

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

public abstract class InputAction : ScriptableObject 
{
    public string keyWord;

    public abstract void RespondToInput (GameController controller, string[] separatedInputWords);
}

Go

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

[CreateAssetMenu(menuName= "TextAdventure/InputActions/Go")]
public class Go : InputAction
{
    public override void RespondToInput (GameController controller, string[] separatedInputWords)
    {
        controller.roomNavigation.AttemptToChangeRooms (separatedInputWords [1]);
    }
}

Complete this tutorial