DebugConsole

From Unify Community Wiki
(Difference between revisions)
Jump to: navigation, search
Line 68: Line 68:
 
public ArrayList names = new ArrayList();    // The GUI names array.  This holds the names of our duplicated GUIs (might not be needed)
 
public ArrayList names = new ArrayList();    // The GUI names array.  This holds the names of our duplicated GUIs (might not be needed)
 
public ArrayList colors = new ArrayList();    // The array that holds the user selection of color for each message. normal, warning, error.
 
public ArrayList colors = new ArrayList();    // The array that holds the user selection of color for each message. normal, warning, error.
public ArrayList pruneArray = new ArrayList();
 
 
public bool showOnScreen = true;              // Does the output actually get displayed on screen or not?
 
public bool showOnScreen = true;              // Does the output actually get displayed on screen or not?
  

Revision as of 03:02, 9 February 2006

Author: Jeremy Hollingsworth (jeremyace)

Description

This script will control a guiText object to generate a scrolling console-like debug feeback pane. Allows you to set one of three colors (normal, warning, error) to each line to get more feedback.

Usage

This C# script _must_ be placed in the Standard Assets folder to be called from Jscript.


First create a new guiText (GameObject->Create Other->Text). This guiText will be duplicated and moved by the script to form your debug output, so set it up as you want the individual output lines to appear.
-> Make sure the Text field of the guiText is blank.
-> Make sure you set a material (the orange font material) as the code will be modifying the color property.
-> Make sure you set the position of this object to where you want the first line of output to be (code duplicate down).
-> I recommend you cut the scale down so you can fit more lines in the output.


Now create a new blank GameObject (GameObject->Create Empty) and then drag the DebugGUIController.cs script to it.


Settings:
->Debug GUI : Drag the guiText you created here.
->The three colors are for normal, warning, and error. Set to whatever you like or leave alone.
->Max messages : How many message lines we will put on the screen at once. This number depends on the size of your guiText.
->Line Spacing : A float for how far down we will move each new line. Again, this depends on the size of your guiText.
->Show On Screen : The default setting for visibility of the debug output. If set to false (unchecked), you can send data but it wont show until you tell it to, if set to true (checked) it will show all debug output until you tell it not to.


The setup is done!


Using the Debug script from your scripts:
To call the DebugGUIController script from your scripts, just type:
DebugGUIController.instance.someFunction()


Replace someFunction() with any of the following:


AddMessage(string message, string color)
->Adds a message to the list. The color is a string either "normal", "warning" or "error". The color argument is optional and if omitted, the color will default to "normal".


ClearMessages()
->Clears all of the messages from the list and the screen.


Hide()
->Hides the display of the output. Does not reset the contents of the list (same as setting Show On Screen to false in the inspector)


Show()
->Shows the previously hidden display.


So for a simple example, to add hello world in warning color (yellow), we type: DebugGUIController.instance.AddMessage("hello world", "warning");


C# - DebugGUIController.cs

The script _must_ be named DebugGUIController.cs <csharp> using UnityEngine; using System.Collections;


public class DebugGUIController : MonoBehaviour {

public GameObject DebugGui = null; // The GUI that will be duplicated public Color normal = Color.green; public Color warning = Color.yellow; public Color error = Color.red; public int maxMessages = 20; // The max number of messages displayed public float lineSpacing = 0.02F; // The amount of space between lines public ArrayList messages = new ArrayList(); // The messages array public ArrayList names = new ArrayList(); // The GUI names array. This holds the names of our duplicated GUIs (might not be needed) public ArrayList colors = new ArrayList(); // The array that holds the user selection of color for each message. normal, warning, error. public bool showOnScreen = true; // Does the output actually get displayed on screen or not?


// s_Instance is used to cache the instance found in the scene so we don't have to look it up every time.

   private static DebugGUIController s_Instance = null;

   // This defines a static instance property that attempts to find the manager object in the scene and
   // returns it to the caller.
   public static DebugGUIController instance {
       get {
           if (s_Instance == null) {
               // This is where the magic happens.
               //  FindObjectOfType(...) returns the first AManager object in the scene.
               s_Instance =  FindObjectOfType(typeof (DebugGUIController)) as DebugGUIController;
               if (s_Instance == null)
                   Debug.Log ("Could not locate a DebugGUIController object.  You have to have exactly one DebugGUIController in the scene.");
           }
           
           return s_Instance;
       }
   }
   
   void Awake() {
       s_Instance = this;
   }

public void Start() { // Create our GUI objects to our maxMessages count

Vector3 position = new Vector3(0.01F, DebugGui.transform.position.y, 0F);
  int x = 0;
  while(x < maxMessages)
   {
       
       position.y -= lineSpacing;  //new position moved down from parent
       Object clone = null;
       clone = Instantiate(DebugGui, position, transform.rotation);
       string name = "DebugGui(" + x + ")";    // Add the current loop number to the DebugGui() name string
       names.Add(name);   // add the name to our name array (might have to change this to work on a per-element basis) 
       clone.name = name;  // Set the name of our newly instantiated GUI object.
       x+=1; 
   }

}



   //---------- void AddMesage(string message, string color) ------
   //Adds a mesage to the list
   //--------------------------------------------------------------

public void AddMessage(string message, string color) { messages.Add(message); colors.Add(color); Display(); } //++++++++++ OVERLOAD for AddMessage ++++++++++++++++++++++++++++ // Overloads AddMessage to only require one argument(message) //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ public void AddMessage(string message) { messages.Add(message); colors.Add("normal"); Display();

   }


   //----------- void ClearMessages() ------------------------------
   // Clears the messages from the screen and the lists
   //---------------------------------------------------------------
   public void ClearMessages()
   {
       messages.Clear();
       colors.Clear();
       ClearScreen();
   }
   
   
   //--------- void Hide() -----------------------------------------
   // Hides the display with a variable, but does NOT clear arrays
   //---------------------------------------------------------------
   public void Hide()
   {
       showOnScreen = false;
       ClearScreen();
   }
   
   
   //--------- void Show() ----------------------------------------
   // Shows the hidden display on the screen
   //--------------------------------------------------------------
   public void Show()
   {
       showOnScreen = true;
       Display();
   }
   
   
 
   //-------- void ClearScreen() ----------------------------------
   // Clears all output from all GUI objects
   //--------------------------------------------------------------
   void ClearScreen()
   {
       int x = 0;
       while (x < names.Count)
       {
           GameObject gui = GameObject.Find((string)names[x]);   //find our gui object
           gui.guiText.text = "";
           //increment and loop
           x += 1;
          
       }//end loop
   }


   //---------- void Prune() ---------------------------------------
   // Prunes the array to fit within the maxMessages limit
   //---------------------------------------------------------------
   void Prune()
   {
   int diff;
       if (messages.Count > maxMessages)
       {
          if (messages.Count <= 0)
          {
           diff = 0;
          }
          else
          {
           diff = messages.Count - maxMessages;
          }
          messages.RemoveRange(0, (int)diff);
          colors.RemoveRange(0, (int)diff);
       }
   
   }
   
   //---------- void Display() -------------------------------------
   // Displays the list and handles coloring
   //---------------------------------------------------------------
   public void Display()
   {
       //check if we are set to display
       if (showOnScreen == false)
       {
          ClearScreen();
       }
       else 
       {
           if (messages.Count > maxMessages)
           {
              Prune();
           }            
       
       // Carry on with display
               
       int x = 0;
       while (x < messages.Count)
       {
      
           GameObject gui = GameObject.Find((string)names[x]);   //find our gui object
           //set our color
           
           switch ((string) colors[x])
           {
               case "normal": gui.guiText.material.color = normal;
               break;
               case "warning": gui.guiText.material.color = warning;
               break;
               case "error": gui.guiText.material.color = error;
               break;
           }
           //now set the text for this element
           gui.guiText.text = (string)messages[x];
           
           //increment and loop
           x += 1;
          
       }//end loop
           
       
       
       }//end display check
   
   } 

}// End Class

</csharp>

Personal tools
Namespaces

Variants
Actions
Navigation
Extras
Toolbox