Many pickups have additional properties, rather than simply being an item being carried. For example, a health pickup may add health "points" to the player's character, a coin pickup may add money "points" to the characters bank balance, and so on. So, let's add an integer points variable to our PickUp class and offer the user the ability to easily edit this points value via a GUI slider in our customer Inspector editor.

To add an editable points property to our PickUp objects, follow these steps:

We provide four parameters to the IntSlider(…) method. The first is the text label the user will see next to the slider. The second is the initial value the slider displays. The last two are the maximum and minimum values. In our example, we are permitting values from 0 to 100, but if health pickups only offer one, two, or three health points, then we'd just call with EditorGUILayout.IntSlider ("Health points", points.intValue, 1, 5). This method returns a new integer value based on where the slider has been positioned, and this new value is stored back into the integer value part of our SerializedProperty variable points.

Note that the loading and saving of values from the scripted component in the GameObject and our editor script is all part of the work undertaken by our calls to the Update() method and the ApplyModifiedProperties() method on the serialized object in the OnInspectorGUI() method.

Note that since points may not have any meaning for some pickups, for example, keys, then we simply would not display any slider for the GUI Inspector editor when the user is editing PickUp objects of that type.

While the concept of "points" may have no meaning for a key pickup, the concept of the type of lock that a given key fits is certainly something we may wish to implement in a game. Since Unity offers us a defined (and editable) list of string tags for any GameObject, often it is sufficient, and straightforward, to represent the type of lock or door corresponding to a key via its tag. For example, a green key might fit all objects tagged LockGreen and so on.

Therefore, it is very useful to be able to offer a custom Inspector editor for a string property of key pickups that stores the tag of the lock(s) the key can open. This task combines several actions, including using C# to retrieve an array of tags from the Unity editor, then the building and offering of a drop-down list of these tags to the user, with the current value already selected in this list.

To add a selectable list of strings for the tag for lock(s) that a key fits, follow these steps:

We've added several statements to the end of this method. First tags, an array of strings, is created (and sorted), containing the list of tags currently available in the Unity editor for the current game. We then attempt to find the location in this array of the current value of fitsLockTag — we can use the BinarySearch(…) method of built-in script class Array because we have alphabetically sorted our array (which also makes it easier for the user to navigate). If the string in fitsLockTag cannot be found in array tags, then the first item will be selected by default (index 0).

The user is then shown the drop-down list via the GUILayout method EditorGUILayout.Popup(…), and this method returns the index of whichever item is selected. The selected index is stored into selectedTagIndex, and the last statement in the method extracts the corresponding string and stores that string into the fitsLockTag variable.

In our player collision logic, we can now search through our inventory to see if any key items fit the lock we have collided with. For example, if a green door was collided with, and the player was carrying a key that could open such doors, then that item should be removed from the inventory List<> and the door should be opened.

To implement this, you would need to add an if test inside the OnTriggerEnter() method to detected collision with the item tagged Door, and then logic to attempt to open the door, and, if unsuccessful, do the appropriate action (for example, play sound) to inform the player they cannot open the door yet (we'll assume we have written a door animation controller that plays the appropriate animation and sounds and when a door is to be opened):

if("Door" == hitCollider.tag){
  if(!OpenDoor(hitCollider.gameObject))
    DoorNotOpenedAction();
}

The OpenDoor() method would need to identify which item (if any) in the inventory can open such a door, and, if found, then that item should be removed from the List<> and the door should be opened by the appropriate method:

private bool OpenDoor(GameObject doorGO){
  // search for key to open the tag of doorGO
  int colorKeyIndex = FindItemIndex(doorGO.tag);
  if( colorKeyIndex > -1 ){
    // remove key item from inventory List<>
    inventory.RemoveAt( colorKeyIndex );

    // now open the door...
    DoorAnimationController doorAnimationController = doorGO.GetComponent<>(DoorAnimationController);
    doorAnimationController.OpenDoor();

    return true;
  }

  return false;
}

The following is the code for a method to find the inventory list key item fitting a door tag:

private int FindItemIndex(string doorTag){
  for (int i = 0; i < inventory.Count; i++){
    PickUp item = inventory[i];
    if( (PickUp.PickUpType.Key == item.type) && (item.fitsLockTag == doorTag))
      return i;
  }

  // not found
return -1;
}

Note that if we wished to create editor extensions to work with private variables, then we'd need to explicitly add [SerializeField] in the line immediately before the variable to be changed by the editor script. Public variables are serialized by default in Unity, so this was not required for our public type variable in script class PickUp, although it's good practice to flag ALL variables that are changeable via an Editor Extension in this way.

Unity provides documentation pages about editor scripts at http://docs.unity3d.com/ScriptReference/Editor.html.