Introduction to Game Design, Prototyping, and Development (2015)

---

Setting Up the Game

We’re going to create a WordGame class to manage the game, but before we do so, we need to make a couple of changes to WordList. First, we need to make it not start parsing the words on Start() but instead wait until an Init() method is called by another class. Second, we need to make WordList notify the upcoming WordGame script when the parsing is complete. To do this, we will have the WordList send a message to the _MainCamera GameObject using the SendMessage() command. This message will be interpreted by WordGame as you’ll soon see. Change the name of the void Start() method in WordList to public void Init() and add the following bold code to the end of the ParseLines method in WordList:

public class WordList : MonoBehaviour {
...

void Awake() {
S = this; // Set up the singleton
}

public void Init() { // This line replaces "void Start()"
// Split the text of wordListText on line feeds, which creates a large,
// populated string[] with all the words from the list
lines = wordListText.text.Split('\n');
totalLines = lines.Length;

// This starts a coroutine of ParseLines. Coroutines can be paused in
// the middle to allow other code to execute.
StartCoroutine( ParseLines() );
}

...

public IEnumerator ParseLines() {
...
for (currLine = 0; currLine < totalLines; currLine++) {
...
}

// Send a message to this gameObject to let it know the parse is done
gameObject.SendMessage("WordListParseComplete");
}
}

The SendMessage() command is executed on the GameObject _MainCamera (because WordList is a Script Component of _MainCamera). This command will call a WordListParseComplete() method on any script that is attached to the GameObject on which it is called (that is, _MainCamera).

Now, create a WordGame C# script and attach it to _MainCamera as a Script component. Then enter the following code to take advantage of the changes just made to WordList:

using UnityEngine;
using System.Collections;
using System.Collections.Generic; // We'll be using List<> & Dictionary<>
using System.Linq; // We'll be using LINQ

public enum GameMode {
preGame, // Before the game starts
loading, // The word list is loading and being parsed
makeLevel, // The individual WordLevel is being created
levelPrep, // The level visuals are Instantiated
inLevel // The level is in progress
}

public class WordGame : MonoBehaviour {
static public WordGame S; // Singleton

public bool ________________;

public GameMode mode = GameMode.preGame;

void Awake() {
S = this; // Assign the singleton
}

void Start () {
mode = GameMode.loading;
// Tells WordList.S to start parsing all the words
WordList.S.Init();
}

// Called by the SendMessage() command from WordList
public void WordListParseComplete() {
mode = GameMode.makeLevel;
}

}

Select _MainCamera in the Hierarchy pane, and look at the WordGame (Script) component in the Inspector. When you press Play, you’ll see the value of the mode field initially move from preGame to loading. Then, after all the words have been parsed, it will change from loading tomakeLevel. This shows us that everything is working as we had hoped.

Now, it’s time to take the words in the WordList and make a level from them. The Level class will include the following:

The long word on which the level is based. (If maxWordLength is 6, this is the six-letter word whose letters will be reshuffled into the other words.)

The index number of that word in longWords.

The level number as the int levelNum. In this chapter, every time the game starts, we’ll choose a random word, but later you could use a pseudo-random function to ensure that the eighth level would always be the same word.

A Dictionary<,> of each character in the word and how many times it is used. Dictionaries are part of System.Collections.Generic along with Lists.

A List<> of all the other words that can be formed from the characters in the Dictionary above.

A Dictionary<,> is a generic collection type that holds a series of key value pairs. In each level, the Dictionary<,> will use char keys and int values to hold information about how many times each char is used in the long word. For example, this is how the long word MISSISSIPPI would look:

Dictionary<char,int> charDict = new Dictionary<char,int>();
charDict.Add('M',1); // MISSISSIPPI has 1 M
charDict.Add('I',4); // MISSISSIPPI has 4 Is
charDict.Add('S',4); // MISSISSIPPI has 4 Ss
charDict.Add('P',2); // MISSISSIPPI has 2 Ps

WordLevel will also contain two useful static methods:

MakeCharDict(): Creates a charDict like the one in the preceding code from any string

CheckWordInLevel(): Checks to see whether a word can be spelled using the chars in a WordLevel’s charDict

Create a new C# script named WordLevel and enter the following code. Note that WordLevel does not extend MonoBehaviour, so it is not a class that can be attached to a GameObject as a Script component, and it cannot have StartCoroutine() called within it.

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

[System.Serializable] // WordLevels can be viewed in the Inspector
public class WordLevel { // WordLevel does NOT extend MonoBehaviour
public int levelNum;
public int longWordIndex;
public string word;
// A Dictionary<,> of all the letters in word
public Dictionary<char,int> charDict;
// All the words that can be spelled with the letters in charDict
public List<string> subWords;

// A static function that counts the instances of chars in a string and
// returns a Dictionary<char,int> that contains this information
static public Dictionary<char,int> MakeCharDict(string w) {
Dictionary<char,int> dict = new Dictionary<char, int>();
char c;
for (int i=0; i<w.Length; i++) {
c = w[i];
if (dict.ContainsKey(c)) {
dict[c]++;
} else {
dict.Add (c,1);
}
}
return(dict);
}

// This static method checks to see whether the word can be spelled with the
// chars in level.charDict
public static bool CheckWordInLevel(string str, WordLevel level) {
Dictionary<char,int> counts = new Dictionary<char, int>();
for (int i=0; i<str.Length; i++) {
char c = str[i];
// If the charDict contains char c
if (level.charDict.ContainsKey(c)) {
// If counts doesn't already have char c as a key
if (!counts.ContainsKey(c)) {
// ...then add a new key with a value of 1
counts.Add (c,1);
} else {
// Otherwise, add 1 to the current value
counts[c]++;
}
// If this means that there are more instances of char c in str
// than are available in level.charDict
if (counts[c] > level.charDict[c]) {
// ... then return false
return(false);
}
} else {
// The char c isn't in level.word, so return false
return(false);
}
}
return(true);
}
}

Now, to make use of this, make the following bolded changes to WordGame:

public class WordGame : MonoBehaviour {
...

public GameMode mode = GameMode.preGame;
public WordLevel currLevel;

...

// Called by the SendMessage() command from WordList
public void WordListParseComplete() {
mode = GameMode.makeLevel;
// Make a level and assign it to currLevel, the current WordLevel
currLevel = MakeWordLevel();
}

// With the default value of -1, this method will generate a level from
// a random word.
public WordLevel MakeWordLevel(int levelNum = -1) {
WordLevel level = new WordLevel();
if (levelNum == -1) {
// Pick a random level
level.longWordIndex = Random.Range(0,WordList.S.longWordCount);
} else {
// This can be added later
}
level.levelNum = levelNum;
level.word = WordList.S.GetLongWord(level.longWordIndex);
level.charDict = WordLevel.MakeCharDict(level.word);

// Call a coroutine to check all the words in the WordList and see
// whether each word can be spelled by the chars in level.charDict
StartCoroutine( FindSubWordsCoroutine(level) );

// This returns the level before the coroutine finishes, so
// SubWordSearchComplete() is called when the coroutine is done
return( level );
}

// A coroutine that finds words that can be spelled in this level
public IEnumerator FindSubWordsCoroutine(WordLevel level) {
level.subWords = new List<string>();
string str;

List<string> words = WordList.S.GetWords();
// ^ This is very fast because List<string> is passed by reference

// Iterate through all the words in the WordList
for (int i=0; i<WordList.S.wordCount; i++) {
str = words[i];
// Check whether each one can be spelled using level.charDict
if (WordLevel.CheckWordInLevel(str, level)) {
level.subWords.Add(str);
}
// Yield if we've parsed a lot of words this frame
if (i%WordList.S.numToParseBeforeYield == 0) {
// yield until the next frame
yield return null;
}
}

// List<string>.Sort() sorts alphabetically by default
level.subWords.Sort ();
// Now sort by length to have words grouped by number of letters
level.subWords = SortWordsByLength(level.subWords).ToList();

// The coroutine is complete, so call SubWordSearchComplete()
SubWordSearchComplete();
}

public static IEnumerable<string> SortWordsByLength(IEnumerable<string> e)
{
// Use LINQ to sort the array received and return a copy
// The LINQ syntax is different from regular C# and is beyond
// the scope of this book // 1
var sorted = from s in e
orderby s.Length ascending
select s;
return sorted;
}

public void SubWordSearchComplete() {
mode = GameMode.levelPrep;

}

}

1. There is a good explanation of LINQ at the Unity Gems website. This link is from the Internet Archive to ensure that it remains valid. https://web.archive.org/web/20140209060811/ http://unitygems.com/linq-1-time-linq/

This code creates the level, chooses a goal word, and populates it with subWords that can be spelled using the characters in the goal word. When you press Play, you should now see the currLevel field populate in the _MainCamera Inspector.

Save your scene! If you haven’t been saving your scene all along—and this served as a reminder to do so—you need to be reminding yourself to save more often.

Laying Out the Screen

Now that the level has been created, it’s time to generate on-screen visuals to represent both the big letters that can be used to spell words and the regular letters of the words. To start, you need to create a PrefabLetter to be instantiated for each letter.

Making PrefabLetter

Follow these steps to make PrefabLetter:

1. From the menu bar, choose GameObject > Create Other > Quad. Rename the quad to PrefabLetter.

2. From the menu bar, choose Assets > Create > Material. Name the material LetterMat and place it in the Materials & Textures folder.

3. Drag LetterMat onto PrefabLetter to assign it. Click on PrefabLetter, and set the shader of LetterMat to ProtoTools > UnlitAlpha. Then select Rounded Rect 256 as the texture for the LetterMat material.

4. If you double-click PrefabLetter in the Hierarchy, you should now see a nice rounded rectangle there. If you can’t see it, you may need to orbit the camera around to the other side. (Backface culling makes quads visible only from one side and invisible from the other.)

5. From the menu bar, choose GameObject > Create Other > 3D Text and rename it 3D Text. Drag the 3D Text onto PrefabLetter in the Hierarchy to make it a child of PrefabLetter. Then select 3D Text in the Hierarchy and set it to the settings shown in Figure 33.3.

Figure 33.3 The Inspector settings for 3D Text, a child of PrefabLetter

6. Once PrefabLetter is ready, drag it into the _Prefabs folder in the Project pane and delete the remaining instance from the Hierarchy.

The Letter C# Script

PrefabLetter will have its own C# script to handle setting the character it shows, its color, and various other things. Create a new C# script named Letter and attach it to PrefabLetter. Then open it in MonoDevelop and enter the following code:

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

public class Letter : MonoBehaviour {

private char _c; // The char shown on this Letter
public TextMesh tMesh; // The TextMesh shows the char
public Renderer tRend; // The Renderer of 3D Text. This will
// determine whether the char is visible
public bool big = false; // Big letters act differently

void Awake() {
tMesh = GetComponentInChildren<TextMesh>();
tRend = tMesh.renderer;
visible = false;
}

// Used to get or set _c and the letter shown by 3D Text
public char c {
get {
return( _c );
}
set {
_c = value;
tMesh.text = _c.ToString();
}
}

// Gets or sets _c as a string
public string str {
get {
return( _c.ToString() );
}
set {
c = value[0];
}
}

// Enables or disables the renderer for 3D Text, which causes the char to be
// visible or invisible respectively.
public bool visible {
get {
return( tRend.enabled );
}
set {
tRend.enabled = value;
}
}

// Gets or sets the color of the rounded rectangle
public Color color {
get {
return(renderer.material.color);
}
set {
renderer.material.color = value;
}
}

// Sets the position of the Letter's gameObject
public Vector3 pos {
set {
transform.position = value;
}
}
}

This class makes use of several properties (faux fields with get{} and set{}) to perform various actions when variables are set. This enables, for instance, WordGame to set the char c of a Letter without worrying about how that gets converted to a string and then shown by 3D Text. This kind of encapsulation of functionality within a class is central to object-oriented programming.

The Wyrd Class: A Collection of Letters

Create a new C# script named Wyrd. The Wyrd class will act as a collection of Letters, and its name is spelled with a y to differentiate it from the other instances of the word word throughout the code and the text of this book. Wyrd is another class that does not extend MonoBehaviour and cannot be attached to a GameObject, but it can still contain List<>s of classes that are attached to GameObjects.

Enter the following code:

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

public class Wyrd {
public string str; // A string representation of the word
public List<Letter> letters = new List<Letter>();
public bool found = false; // True if the player has found this word

// A property to set visibility of the 3D Text of each Letter
public bool visible {
get {
if (letters.Count == 0) return(false);
return(letters[0].visible);
}
set {
foreach( Letter lett in letters) {
lett.visible = value;
}
}
}

// A property to set the rounded rectangle color of each Letter
public Color color {
get {
if (letters.Count == 0) return(Color.black);
return(letters[0].color);
}
set {
foreach( Letter lett in letters) {
lett.color = value;
}
}
}

// Adds a Letter to letters
public void Add(Letter lett) {
letters.Add(lett);
str += lett.c.ToString();
}

}

WordGame Layout

The Layout() function will generate Wyrds and Letters for the game as well as big Letters that the player can use to spell words (shown as large gray letters in the screenshot at the beginning of this chapter). We’ll start with the small letters, and for this phase of the prototype, we’ll make the letters visible to begin with (rather than hiding them as we’ll do in the final version). Add the following code to WordGame:

public class WordGame : MonoBehaviour {
static public WordGame S; // Singleton

public GameObject prefabLetter;
public Rect wordArea = new Rect(-24,19,48,28);
public float letterSize = 1.5f;
public bool showAllWyrds = true;
public float bigLetterSize = 4f;

public bool ________________;

public GameMode mode = GameMode.preGame;
public WordLevel currLevel;
public List<Wyrd> wyrds;

...

public void SubWordSearchComplete() {
mode = GameMode.levelPrep;
Layout(); // Call the Layout() function after SubWordSearch
}

void Layout() {
// Place the letters for each subword of currLevel on screen
wyrds = new List<Wyrd>();

// Declare a lot of variables that will be used in this method
GameObject go;
Letter lett;
string word;
Vector3 pos;
float left = 0;
float columnWidth = 3;
char c;
Color col;
Wyrd wyrd;

// Determine how many rows of Letters will fit on screen
int numRows = Mathf.RoundToInt(wordArea.height/letterSize);

// Make a Wyrd of each level.subWord
for (int i=0; i<currLevel.subWords.Count; i++) {
wyrd = new Wyrd();
word = currLevel.subWords[i];

// if the word is longer than columnWidth, expand it
columnWidth = Mathf.Max( columnWidth, word.Length );

// Instantiate a PrefabLetter for each letter of the word
for (int j=0; j<word.Length; j++) {
c = word[j]; // Grab the jth char of the word
go = Instantiate(prefabLetter) as GameObject;
lett = go.GetComponent<Letter>();
lett.c = c; // Set the c of the Letter
// Position the Letter
pos = new Vector3(wordArea.x+left+j*letterSize, wordArea.y, 0);
// The % here makes multiple columns line up
pos.y -= (i%numRows)*letterSize;
lett.pos = pos;
go.transform.localScale = Vector3.one*letterSize;
wyrd.Add(lett);
}

if (showAllWyrds) wyrd.visible = true; // This line is for testing

wyrds.Add(wyrd);

// If we've gotten to the numRows(th) row, start a new column
if (i%numRows == numRows-1) {
left += (columnWidth+0.5f)*letterSize;
}
}

}
}

Before pressing Play, you need to assign the PrefabLetter prefab from the Project pane to the prefabLetter field of the WordGame (Script) component of _MainCamera. After doing so, press Play, and you should see a list of words pop up on screen, as shown in Figure 33.4.

Figure 33.4 An example of the current state of the game: the level for the word TORNADO

Adding the Big Letters at the Bottom

The next step in Layout() is to place the large letters at the bottom of the screen. Add the following code to do so:

public class WordGame : MonoBehaviour {
...

public float bigLetterSize = 4f;
public Color bigColorDim = new Color(0.8f, 0.8f, 0.8f);
public Color bigColorSelected = Color.white;
public Vector3 bigLetterCenter = new Vector3(0, -16, 0);

public bool ________________;

public GameMode mode = GameMode.preGame;
public WordLevel currLevel;
public List<Wyrd> wyrds;
public List<Letter> bigLetters;
public List<Letter> bigLettersActive;

...

void Layout() {
...

// Make a Wyrd of each level.subWord
for (int i=0; i<currLevel.subWords.Count; i++) {
...
}

// Place the big letters
// Initialize the List<>s for big Letters
bigLetters = new List<Letter>();
bigLettersActive = new List<Letter>();

// Create a big Letter for each letter in the target word
for (int i=0; i<currLevel.word.Length; i++) {
// This is similar to the process for a normal Letter
c = currLevel.word[i];
go = Instantiate(prefabLetter) as GameObject;
lett = go.GetComponent<Letter>();
lett.c = c;
go.transform.localScale = Vector3.one*bigLetterSize;

// Set the initial position of the big Letters below screen
pos = new Vector3( 0, -100, 0 );
lett.pos = pos;

col = bigColorDim;
lett.color = col;
lett.visible = true; // This is always true for big letters
lett.big = true;
bigLetters.Add(lett);
}
// Shuffle the big letters
bigLetters = ShuffleLetters(bigLetters);
// Arrange them on screen
ArrangeBigLetters();

// Set the mode to be in-game
mode = GameMode.inLevel;
}

// This shuffles a List<Letter> randomly and returns the result
List<Letter> ShuffleLetters(List<Letter> letts) {
List<Letter> newL = new List<Letter>();
int ndx;
while(letts.Count > 0) {
ndx = Random.Range(0,letts.Count);
newL.Add(letts[ndx]);
letts.RemoveAt(ndx);
}
return(newL);
}

// This arranges the big Letters on screen
void ArrangeBigLetters() {
// The halfWidth allows the big Letters to be centered
float halfWidth = ( (float) bigLetters.Count )/2f-0.5f;
Vector3 pos;
for (int i=0; i<bigLetters.Count; i++) {
pos = bigLetterCenter;
pos.x += (i-halfWidth)*bigLetterSize;
bigLetters[i].pos = pos;
}
// bigLettersActive
halfWidth = ( (float) bigLettersActive.Count )/2f-0.5f;
for (int i=0; i<bigLettersActive.Count; i++) {
pos = bigLetterCenter;
pos.x += (i-halfWidth)*bigLetterSize;
pos.y += bigLetterSize*1.25f;
bigLettersActive[i].pos = pos;
}
}

}

Now, in addition to the Letters up top, you should also see big Letters below, the shuffled form of the goal word. It’s time to add some interactivity.

Adding Interactivity

For this game, we want the player to be able to type words from the available big Letters on her keyboard and press Return/Enter to submit them. She can also press Backspace/Delete to remove a letter from the end of what she has typed and press the space bar to shuffle the remaining unselected letters.

When she presses Enter, the word she typed will be compared with the possible words in the WordLevel. If the word she typed is in the WordLevel, she will get a point for each letter in the word. In addition, if the word she typed contains any smaller words that are in the WordLevel, she will also get points for those plus a multiplier for each word. Looking at the TORNADO example earlier, if a player typed TORNADO as her first word and hit Return, she would get 36 total points as follows:

All of this interactivity will be handled by the Update() function and will be based on Input.inputString, a string of all the keyboard input that occurred this frame. Add the following Update() method and supporting methods to WordGame:

public class WordGame : MonoBehaviour {
...

public List<Letter> bigLettersActive;
public string testWord;
private string upperCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

...

void Update() {
// Declare a couple of useful local variables
Letter lett;
char c;

switch (mode) {
case GameMode.inLevel:
// Iterate through each char input by the player this frame
foreach (char cIt in Input.inputString) {
// Shift cIt to UPPERCASE
c = System.Char.ToUpperInvariant(cIt);

// Check to see if it's an uppercase letter
if (upperCase.Contains(c)) { // Any uppercase letter
// Find an available Letter in bigLetters with this char
lett = FindNextLetterByChar(c);
// If a Letter was returned
if (lett != null) {
// ... then add this char to the testWord and move the
// returned big Letter to bigLettersActive
testWord += c.ToString();
// Move it from the inactive to the active List<>
bigLettersActive.Add(lett);
bigLetters.Remove(lett);
lett.color = bigColorSelected; // Make it the active color
ArrangeBigLetters(); // Rearrange the big Letters
}
}

if (c == '\b') { // Backspace
// Remove the last Letter in bigLettersActive
if (bigLettersActive.Count == 0) return;
if (testWord.Length > 1) {
// Clear the last char of testWord
testWord = testWord.Substring(0,testWord.Length-1);
} else {
testWord = "";
}

lett = bigLettersActive[bigLettersActive.Count-1];
// Move it from the active to the inactive List<>
bigLettersActive.Remove(lett);
bigLetters.Add (lett);
lett.color = bigColorDim; // Make it the inactive color
ArrangeBigLetters(); // Rearrange the big Letters
}

if (c == '\n' || c == '\r') { // Return/Enter
// Test the testWord against the words in WordLevel
CheckWord();
}

if (c == ' ') { // Space
// Shuffle the bigLetters
bigLetters = ShuffleLetters(bigLetters);
ArrangeBigLetters();
}
}

break;
}

}

// This finds an available Letter with the char c in bigLetters.
// If there isn't one available, it returns null.
Letter FindNextLetterByChar(char c) {
// Search through each Letter in bigLetters
foreach (Letter l in bigLetters) {
// If one has the same char as c
if (l.c == c) {
// ...then return it
return(l);
}
}
// Otherwise, return null
return( null );
}

public void CheckWord() {
// Test testWord against the level.subWords
string subWord;
bool foundTestWord = false;

// Create a List<int> to hold the indices of other subWords that are
// contained within testWord
List<int> containedWords = new List<int>();

// Iterate through each word in currLevel.subWords
for (int i=0; i<currLevel.subWords.Count; i++) {

// If the ith Wyrd on screen has already been found
if (wyrds[i].found) {
// ...then continue & skip the rest of this iteration
continue;
// This works because the Wyrds on screen and the words in the
// subWords List<> are in the same order
}

subWord = currLevel.subWords[i];
// if this subWord is the testWord
if (string.Equals(testWord, subWord)) {
// ...then highlight the subWord
HighlightWyrd(i);
foundTestWord = true;
} else if (testWord.Contains(subWord)) {
// ^else if testWord contains this subWord (e.g., SAND contains AND)
// ...then add it to the list of containedWords
containedWords.Add(i);
}
}

// If the test word was found in subWords
if (foundTestWord) {
// ...then highlight the other words contained in testWord
int numContained = containedWords.Count;
int ndx;
// Highlight the words in reverse order
for (int i=0; i<containedWords.Count; i++) {
ndx = numContained-i-1;
HighlightWyrd( containedWords[ndx] );
}
}

// Clear the active big Letters regardless of whether testWord was valid
ClearBigLettersActive();

}

// Highlight a Wyrd
void HighlightWyrd(int ndx) {
// Activate the subWord
wyrds[ndx].found = true; // Let it know it's been found
// Lighten its color
wyrds[ndx].color = (wyrds[ndx].color+Color.white)/2f;
wyrds[ndx].visible = true; // Make its 3D Text visible
}

// Remove all the Letters from bigLettersActive
void ClearBigLettersActive() {
testWord = ""; // Clear the testWord
foreach (Letter l in bigLettersActive) {
bigLetters.Add(l); // Add each Letter to bigLetters
l.color = bigColorDim; // Set it to the inactive color
}
bigLettersActive.Clear(); // Clear the List<>
ArrangeBigLetters(); // Rearrange the Letters on screen
}

}

After you’ve entered all this, you will also need to set showAllWyrds to false in the Inspector for the WordGame (Script) component of _MainCamera. Then, press Play.

You should be presented with a working version of the game and a random level.

Adding Scoring

Because of the Scoreboard and FloatingScore code that we’ve already written and imported into this project, adding scoring to this game should be very easy. Start by dragging Scoreboard from the _Prefab folder in the Project pane into the Hierarchy pane. Both the Scoreboard instance now in the Hierarchy and the PrefabFloatingScore should be preset for this game. (If you want to learn more about how they work, refer to Chapter 31, “Prototype 4: Prospector Solitaire.”)

Now, you must add scoring code to the WordGame C# script by making the following edits:

public class WordGame : MonoBehaviour {
...
public Vector3 bigLetterCenter = new Vector3(0, -16, 0);
public List<float> scoreFontSizes = new List<float> { 24, 36, 36, 1 };
public Vector3 scoreMidPoint = new Vector3(1,1,0);
public float scoreComboDelay = 0.5f;

...

public void CheckWord() {
...
// Iterate through each word in currLevel.subWords
for (int i=0; i<currLevel.subWords.Count; i++) {

...

// if this subWord is the testWord
if (string.Equals(testWord, subWord)) {
// ...then highlight the subWord
HighlightWyrd(i);
Score( wyrds[i], 1 ); // Score the testWord
foundTestWord = true;
}
...
}

// If the test word was found in subWords
if (foundTestWord) {
...
// Highlight the words in reverse order
for (int i=0; i<containedWords.Count; i++) {
ndx = numContained-i-1;
HighlightWyrd( containedWords[ndx] );
Score( wyrds[ containedWords[ndx] ], i+2 ); // Score other words
// The second parameter (i+2) is the # of this word in the combo
}
}
...

}

...

// Add to the score for this word
// int combo is the number of this word in a combo
void Score(Wyrd wyrd, int combo) {
// Get the position of the first Letter in the wyrd
Vector3 pt = wyrd.letters[0].transform.position;
// Create a List<> of Bezier points for the FloatingScore
List<Vector3> pts = new List<Vector3>();

// Convert the pt to a ViewportPoint. ViewportPoints range from 0 to 1
// across the screen and are used for GUI coordinates
pt = Camera.main.WorldToViewportPoint(pt);
pt.z = 0;

// Make pt the first Bezier point
pts.Add(pt);

// Add a second Bezier point
pts.Add( scoreMidPoint );

// Make the Scoreboard the last Bezier point
pts.Add(Scoreboard.S.transform.position);

// Set the value of the Floating Score
int value = wyrd.letters.Count * combo;
FloatingScore fs = Scoreboard.S.CreateFloatingScore(value, pts);

fs.timeDuration = 2f;
fs.fontSizes = scoreFontSizes;

// Double the InOut Easing effect
fs.easingCurve = Easing.InOut+Easing.InOut;

// Make the text of the FloatingScore something like "3 x 2"
string txt = wyrd.letters.Count.ToString();
if (combo > 1) {
txt += " x "+combo;
}
fs.guiText.text = txt;
}

}

After you’ve entered this code and run the game, you’ll see that you get a score for each correct word you enter, and you get a multiplier for each additional valid word contained in the word you type. However, all the scores happen at the same time. Happily, this is something else that we can use coroutines to fix. Make the following changes to make the CheckWord() function into a coroutine that pauses for 0.5 seconds between each word in the combo:

public class WordGame : MonoBehaviour {
...

void Update() {
...
switch (mode) {
case GameMode.inLevel:
...
// Iterate through each char input by the player this frame
foreach (char cIt in Input.inputString) {
...
if (c == '\n') { // Return/Enter
// Test the testWord against the words in WordLevel
StartCoroutine( CheckWord() );
}
...
}
break;
}
}

...

public IEnumerator CheckWord() {
...

// If the test word was found in subWords
if (foundTestWord) {
// ...then highlight the other words contained in testWord
int numContained = containedWords.Count;
int ndx;
// Highlight the words in reverse order
for (int i=0; i<containedWords.Count; i++) {

// yield for a bit before highlighting each word
yield return( new WaitForSeconds(scoreComboDelay) );

ndx = numContained-i-1;
HighlightWyrd( containedWords[ndx] );
Score( wyrds[ containedWords[ndx] ], i+2 ); // Score other words
// The second parameter (i+2) is the # of this word in the combo
}
}
...
}
...
}

Now, the scores will fly and the words will show with a separation of about 0.5 seconds.

Adding Animation

In a similar manner to scoring, we can very easily add smooth animation of Letters by taking advantage of the interpolation functions that we imported in the Utils script.

Add the following code to the Letter C# script:

public class Letter : MonoBehaviour {
...
public bool big = false; // Big letters are a little different
// Linear interpolation fields
public List<Vector3> pts = null;
public float timeDuration = 0.5f;
public float timeStart = -1;
public string easingCuve = Easing.InOut; // Easing from Utils.cs

...

// Now set up a Bezier curve to move to the new position
public Vector3 pos {
set {
// transform.position = value; // This line is now commented out

// Find a midpoint that is a random distance from the actual
// midpoint between the current position and the value passed in
Vector3 mid = (transform.position + value)/2f;
// The random distance will be within 1/4 of the magnitude of the
// line from the actual midpoint
float mag = (transform.position - value).magnitude;
mid += Random.insideUnitSphere * mag*0.25f;
// Create a List<Vector3> of Bezier points
pts = new List<Vector3>() { transform.position, mid, value };
// If timeStart is at the default -1, then set it
if (timeStart == -1 ) timeStart = Time.time;
}
}

// Moves immediately to the new position
public Vector3 position {
set {
transform.position = value;
}
}

// Interpolation code
void Update() {
if (timeStart == -1) return;

// Standard linear interpolation code
float u = (Time.time-timeStart)/timeDuration;
u = Mathf.Clamp01(u);
float u1 = Easing.Ease(u,easingCurve);
Vector3 v = Utils.Bezier(u1, pts);
transform.position = v;

// If the interpolation is done, set timeStart back to -1
if (u == 1) timeStart = -1;
}
}

Now, if you play the scene, you’ll see the Letters all interpolate to their new positions. However, it looks a little strange for all the Letters to move at the same time and start from the center of the screen. Let’s add some small changes to WordGame.Layout() to improve this:

public class WordGame : MonoBehaviour {
...

void Layout() {
...

// Make a Wyrd of each level.subWord
for (int i=0; i<currLevel.subWords.Count; i++) {
...

// Instantiate a PrefabLetter for each letter of the word
for (int j=0; j<word.Length; j++) {
...
// The % here makes multiple columns line up
pos.y -= (i%numRows)*letterSize;

// Move the lett immediately to a position above the screen
lett.position = pos+Vector3.up*(20+i%numRows);
// Then set the pos for it to interpolate to
lett.pos = pos;
// Increment lett.timeStart to move wyrds at different times
lett.timeStart = Time.time + i*0.05f;

go.transform.localScale = Vector3.one*letterSize;
wyrd.Add(lett);
}
...
}

...
// Create a big Letter for each letter in the target word
for (int i=0; i<currLevel.word.Length; i++) {
...
go.transform.localScale = Vector3.one*bigLetterSize;

// Set the initial position of the big Letters below screen
pos = new Vector3( 0, -100, 0 );
lett.pos = pos;

// Increment lett.timeStart to have big Letters come in last
lett.timeStart = Time.time + currLevel.subWords.Count*0.05f;
lett.easingCuve = Easing.Sin+"-0.18"; // Bouncy easing

col = bigColorDim;
lett.color = col;

...
}
...
}
...
}

With this code, the game should now layout with nice smooth motions.

Adding Color

Now that the game moves well, it’s time to add a little color:

1. Add the following code to WordGame to color the wyrds based on their length:

public class WordGame : MonoBehaviour {
...
public float scoreComboDelay = 0.5f;
public Color[] wyrdPalette;

public bool ________________;
...

void Layout() {
...
// Make a Wyrd of each level.subWord
for (int i=0; i<currLevel.subWords.Count; i++) {
...
// Instantiate a PrefabLetter for each letter of the word
for (int j=0; j<word.Length; j++) {
...
wyrd.Add(lett);
}

if (showAllWyrds) wyrd.visible = true; // This line is for testing

// Color the wyrd based on length
wyrd.color = wyrdPalette[word.Length-WordList.S.wordLengthMin];

wyrds.Add(wyrd);
...
}
...
}
}

These last few code changes have been so simple because we already had supporting code in place (for example, the Wyrd.color and Letter.color properties as well as the Easing code in the Utils class).

2. Now, you need to set about eight colors for wyrdPalette. To do this, we’ll use the Color Palette image included in the import at the beginning of the project. We’re going to be using the eye dropper to set color, which may leave you wondering how to see both the Color Palette image and the _MainCamera Inspector at the same time. To do this, we’ll take advantage of Unity’s capability to have more than one Inspector window open at the same time.

3. As shown in Figure 33.5, click the pane options button (circled in red) and choose Add Tab > Inspector to add an Inspector to the Game tab. Then select the Color Palette image in the Project pane. It will appear in both Inspectors. (You might need to drag the edge of the image preview part of the Inspector to make it look like the Figure 33.6.) Click the lock icon on one inspector (circled in red in the Figure 33.6), and then select _MainCamera in the Hierarchy pane. You’ll see that the unlocked Inspector changes to _MainCamera, but the locked one is still showing Color Palette.

Figure 33.5 Using the pane options button to add an Inspector to the Game pane

Figure 33.6 The lock icon on one Inspector (circled in red) and the eye dropper in the other inspector (circled in light blue)

4. Expand the disclosure triangle next to wyrdPalette in the _MainCamera Inspector and set its size to 8. Click the eye dropper next to each wyrdPalette element (circled in light blue in Figure 33.6), and then click one of the colors in the Color Palette image. Doing this for each element of wyrdPalette will give you the eight different colors of the Color Palette image, but they will all default to having an alpha of 0 (and therefore being invisible). Click each color bar in the wyrdPalette array and set each one’s alpha (or A) to 255 to make it fully opaque, as indicated by the white bar below the color swatch.

Now when you play the scene, you should see something that looks like the screen shot from the beginning of the chapter.

Summary

In this chapter, you created a simple word game and added a little flair to it with some nice interpolated movement. If you’ve been following these tutorials in order, you may have realized that the process of making them is getting a little bit easier. With the expanded understanding of Unity that you now have and the capabilities of readymade utility scripts like Scoreboard, FloatingScore, and Utils, you’re able to focus more of the coding effort on the things that are new and different in each game and less on reinventing the wheel.

Next Steps

In the previous prototypes, you saw examples of how to set up a series of game states to handle the different phases of the game and transition from one level to the next. Right now, this prototype doesn’t have any of that. On your own, you should add that kind of control structure to this game.

Here are some things to think about as you do so:

When should the player be able to move on to the next level? Must she guess every single word, or can she move on once she has either reached a specific point total or has guessed the target word.

How will you handle levels? Will you just pick a completely random word as we are now, or will you modify the randomness to make sure that level 5 is always the same word (therefore making it fair for players to compare their scores on level 5)? Here’s a hint if you decide to try for a modified randomness:

int PickNthRandom(int n, int range) {
// If 0 is passed in, 0 is returned.

int seed = Random.seed; // Store the current Random.seed

// The Random.seed sets the starting point for the Random function.
// With the same Random.seed, Random.value will generate the same
// results, in the same order, every time.

Random.seed = 0; // Set a new Random.seed

// Get the nth random number between 0 and range-1
int j=0;
for (int i=0; i<n; i++) {
j = Random.Range(0,range);
}

Random.seed = seed; // Restore the original Random.seed

return(j);
}

How do you want to handle levels with too many or too few subWords? Some collections of seven letters have so many words that they extend off the screen to the right, whereas others have so few that there’s only one column. Do you want to make the game ask for the next word in this case? If so, how do you then instruct something like the PickNthRandom function to skip certain numbers?

You should have enough knowledge of programming and prototyping now that you can take these questions and make this into a real game. You’ve got the skills, now go for it!