---
title: "Recorded Video Session: Text Adventure Game Part 1"
content_type: tutorial
url: "https://learn.unity.com/course/beginner-scripting-old/tutorial/recorded-video-session-text-adventure-game-part-1?language=en"
language: en
container_type: course
container_title: "Beginner Scripting"
container_url: "https://learn.unity.com/course/beginner-scripting-old.md?language=en"
standalone_markdown_url: "https://learn.unity.com/tutorial/recorded-video-session-text-adventure-game-part-1.md?language=en"
previous_title: "Switch Statements"
previous_url: "https://learn.unity.com/course/beginner-scripting-old/unit/beginner-scripting/tutorial/switch-statements?language=en"
previous_markdown_url: "https://learn.unity.com/course/beginner-scripting-old/unit/beginner-scripting/tutorial/switch-statements.md?language=en"
next_title: "Recorded Video Session: Text Adventure Game Part 2"
next_url: "https://learn.unity.com/course/beginner-scripting-old/tutorial/recorded-video-session-text-adventure-game-part-2?language=en"
next_markdown_url: "https://learn.unity.com/course/beginner-scripting-old/tutorial/recorded-video-session-text-adventure-game-part-2.md?language=en"
difficulty: beginner
duration_minutes: 80
unity_version:
  - "2018.4"
supported_unity_versions:
  - name: "2018.4"
    url: "https://learn.unity.com/tutorial/recorded-video-session-text-adventure-game-part-1.md?language=en&version=2018.4"
last_updated: "2026-08-04T14:24:02.000Z"
---

# Recorded Video Session: Text Adventure Game Part 1

Program a text-based adventure game where the player explores rooms by reading descriptions and entering keyboard commands.

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

- [TextAdventure1-incomplete.zip](https://unity-connect-prd.storage.googleapis.com/20200923/8c38f545-5616-487c-947f-2548bbb042fc/TextAdventure1-incomplete.zip)
- [TextAdventure1-complete.zip](https://unity-connect-prd.storage.googleapis.com/20200923/20e57279-439e-4cb9-af1b-b18c269b96d4/TextAdventure1-complete.zip)

## 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.


[Video](http://www.youtube.com/watch?v=jAf1I1UWo5Q)

## Room

```csharp
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

```csharp
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

```csharp
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

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

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

## TextInput

```csharp
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

```csharp
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

```csharp
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.


[Video](http://www.youtube.com/watch?v=dQ4jcxKwXM8)

## Room

```csharp
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

```csharp
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

```csharp
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

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

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

## TextInput

```csharp
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

```csharp
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

```csharp
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.


[Video](http://www.youtube.com/watch?v=TP4gLQmKOLo)

## Room

```csharp
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

```csharp
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

```csharp
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

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

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

## TextInput

```csharp
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

```csharp
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

```csharp
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.


[Video](http://www.youtube.com/watch?v=-LlAahTMtjw)

## Room

```csharp
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

```csharp
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

```csharp
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

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

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

## TextInput

```csharp
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

```csharp
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

```csharp
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.


[Video](http://www.youtube.com/watch?v=m7Sl9NLv4HI)

## Room

```csharp
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

```csharp
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

```csharp
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

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

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

## TextInput

```csharp
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

```csharp
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

```csharp
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.


[Video](http://www.youtube.com/watch?v=g9Pjv-BWpso)

## Room

```csharp
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

```csharp
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

```csharp
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

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

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

## TextInput

```csharp
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

```csharp
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

```csharp
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.


[Video](http://www.youtube.com/watch?v=XLDrIBaxHKg)

## Room

```csharp
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

```csharp
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

```csharp
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

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

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

## TextInput

```csharp
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

```csharp
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

```csharp
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.


[Video](http://www.youtube.com/watch?v=Mb7SHYZ65Xo)

## Room

```csharp
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

```csharp
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

```csharp
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

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

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

## TextInput

```csharp
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

```csharp
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

```csharp
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]);
    }
}
```