public GitTfsRemote(RemoteOptions remoteOptions, Globals globals, ITfsHelper tfsHelper, TextWriter stdout)
 {
     this.remoteOptions = remoteOptions;
     this.globals = globals;
     this.stdout = stdout;
     Tfs = tfsHelper;
 }

 public InitBranch(TextWriter stdout, Globals globals, Help helper, AuthorsFile authors)
 {
     _stdout = stdout;
     _globals = globals;
     _helper = helper;
     _authors = authors;
 }

 public Subtree(Fetch fetch, QuickFetch quickFetch, Globals globals, RemoteOptions remoteOptions)
 {
     _fetch = fetch;
     _quickFetch = quickFetch;
     _globals = globals;
     _remoteOptions = remoteOptions;
 }

    public static Color GetConvictionColor(Globals.Conviction conviction)
    {
        Color color = Color.white;
        switch(conviction){
        case Globals.Conviction.anger:
            color = GetMoodColor(Globals.Mood.lustful);
            break;
        case Globals.Conviction.envy:
            color = GetMoodColor(Globals.Mood.obsessed);
            break;
        case Globals.Conviction.gluttony:
            color = GetMoodColor(Globals.Mood.bitter);
            break;
        case Globals.Conviction.greed:
            color = GetMoodColor(Globals.Mood.idealistic);
            break;
        case Globals.Conviction.lust:
            color = Color.blue;
            break;
        case Globals.Conviction.pride:
            color = GetMoodColor(Globals.Mood.conservative);
            break;
        case Globals.Conviction.sloth:
            color = GetMoodColor(Globals.Mood.lovestruck);
        //			Debug.Log(color);
            break;
        }

        //		Debug.Log("getting color " + color + " for conviction " + conviction.ToString());
        return color;
    }

 public ListRemoteBranches(Globals globals, TextWriter stdout, ITfsHelper tfsHelper, RemoteOptions remoteOptions)
 {
     this.globals = globals;
     this.stdout = stdout;
     this.tfsHelper = tfsHelper;
     this.remoteOptions = remoteOptions;
 }

 public Bootstrap(RemoteOptions remoteOptions, Globals globals, TextWriter stdout, Bootstrapper bootstrapper)
 {
     _remoteOptions = remoteOptions;
     _globals = globals;
     _stdout = stdout;
     _bootstrapper = bootstrapper;
 }

 public Clone(Globals globals, Fetch fetch, Init init, InitBranch initBranch)
 {
     this.fetch = fetch;
     this.init = init;
     this.globals = globals;
     this.initBranch = initBranch;
 }

 public Fetch(Globals globals, RemoteOptions remoteOptions, AuthorsFile authors, Labels labels)
 {
     this.remoteOptions = remoteOptions;
     this.globals = globals;
     this.authors = authors;
     this.labels = labels;
 }

 public Rcheckin(TextWriter stdout, CheckinOptions checkinOptions, TfsWriter writer, Globals globals)
 {
     _stdout = stdout;
     _checkinOptions = checkinOptions;
     _checkinOptionsFactory = new CommitSpecificCheckinOptionsFactory(_stdout, globals);
     _writer = writer;
 }

	void Start() {
		Globals[] globals = GameObject.FindObjectsOfType<Globals> ();
		for (int c = 1; c < globals.Length; c++) {
			Destroy(globals[c].gameObject);
		}
		global = globals [0];
	}

        protected void Parse(StringReader rdr, DepthScanner scanner, Globals globals)
        {
            int currentLine = 0;
            ParseNamespace(rdr, globals, scanner, ref currentLine, false);

            // Resolve incomplete names
            foreach (string key in globals.GetPropertyNames())
            {
                TypeInfo t = globals.GetProperty(key, true) as TypeInfo;
                if (t != null)
                {
                    if (!t.IsComplete)
                        globals.AddProperty(key, globals.GetTypeInfo(t.Name), -1, "");
                    if (t is TemplateInst)
                    {
                        TemplateInst ti = t as TemplateInst;
                        if (!ti.WrappedType.IsComplete)
                            ti.WrappedType = globals.GetTypeInfo(ti.WrappedType.Name);
                    }
                }
            }

            foreach (FunctionInfo f in globals.GetFunctions(null, true))
            {
                f.ResolveIncompletion(globals);
            }

            foreach (TypeInfo type in globals.TypeInfo)
            {
                type.ResolveIncompletion(globals);
            }
        }

        public GameServer(int port, Globals.LoggerDelegate logger)
        {
            m_IP = "0.0.0.0";
            m_port = port;
            m_logger = logger;
            m_Player = new Player[NPLAYER];
            m_Player[0] = new Player();
            m_Player[1] = new Player();
            reacive_t = new Thread[NPLAYER];
            connection_t = new Thread((limitConnection));
            connection_t.Start();
            //reacive_t[0] = new Thread(

            try
            {
                listener = new TcpListener(IPAddress.Parse(m_IP), m_port); //listner
            }
            catch (ArgumentNullException)
            {
                m_logger("caught ArgumentNullException");
            }
            catch (ArgumentOutOfRangeException)
            {
                m_logger("caught ArgumentOutOfRangeException");
            }
        }

    void Awake()
    {
        globals = Globals.GetInstance();
        XPBarSlider = XPBarSliderGO.GetComponent<UISlider>();
        maxWidth = XPBarSlider.foreground.localScale.x;

        if(XPBarSlider == null)
        {
            Debug.LogError("Couldn't get the UISlider component in XPBar Script.");
        }

        XPMaximum = globals.XPMaximum;
        if(XPMaximum == 0)
        {
            globals.XPPoints = 0;
            PlayerPrefs.SetInt("XP", 0);
            XPMaximum = 100;
            globals.XPMaximum = 100;
            PlayerPrefs.SetInt("XPMaximum", 100);
            Debug.Log("This is the first time XP bar is used.");
        }

        //XPBar.pixelInset.width = globals.XPPoints / (globals.XPMaximum / 100);
        XPPoints = globals.XPPoints;
        UpdateDisplay((XPPoints / XPMaximum));
        player = GameObject.FindWithTag("Player");
    }

 public static string GetGlobalVariable(Globals globals, string varName, string defaultValue)
 {
     string result;
     if (globals == null)
     {
         result = defaultValue;
     }
     else
     {
         object[] array = (object[])globals.VariableNames;
         if (globals.get_VariableExists(varName))
         {
             object[] array2 = array;
             for (int i = 0; i < array2.Length; i++)
             {
                 object obj = array2[i];
                 if (obj.ToString() == varName)
                 {
                     result = (string)globals[varName];
                     return result;
                 }
             }
         }
         result = defaultValue;
     }
     return result;
 }

 public void load(Globals globals)
 {
     int count = ParameterSerializer.loadParameter(globals, SERVER_COUNT, -1);
     if (count != -1)
     {
         try
         {
             for (int i = 1; i <= count; ++i)
             {
                 string guidStr = ParameterSerializer.loadParameter(globals, SERVER_GUID + i, null);
                 Guid guid = new Guid(guidStr);
                 string sName = ParameterSerializer.loadParameter(globals, SERVER_NAME + guidStr, null);
                 string url = ParameterSerializer.loadParameter(globals, SERVER_URL + guidStr, null);
                 JiraServer server = new JiraServer(guid, sName, url, null, null);
                 server.UserName = CredentialsVault.Instance.getUserName(server);
                 server.Password = CredentialsVault.Instance.getPassword(server);
                 addServer(server);
             }
             changedSinceLoading = false;
         }
         catch (Exception e)
         {
             Debug.WriteLine(e);
         }
     }
 }

        public static CheckinOptions Clone(this CheckinOptions source, Globals globals)
        {
            CheckinOptions clone = new CheckinOptions();

            clone.CheckinComment = source.CheckinComment;
            clone.NoGenerateCheckinComment = source.NoGenerateCheckinComment;
            clone.NoMerge = source.NoMerge;
            clone.OverrideReason = source.OverrideReason;
            clone.Force = source.Force;
            clone.OverrideGatedCheckIn = source.OverrideGatedCheckIn;
            clone.WorkItemsToAssociate.AddRange(source.WorkItemsToAssociate);
            clone.WorkItemsToResolve.AddRange(source.WorkItemsToResolve);
            clone.AuthorTfsUserId = source.AuthorTfsUserId;
            try
            {
                string re = globals.Repository.GetConfig(GitTfsConstants.WorkItemAssociateRegexConfigKey);
                if (String.IsNullOrEmpty(re))
                    clone.WorkItemAssociateRegex = GitTfsConstants.TfsWorkItemAssociateRegex;
                else
                    clone.WorkItemAssociateRegex = new Regex(re);
            }
            catch (Exception)
            {
                clone.WorkItemAssociateRegex = null;
            }
            foreach (var note in source.CheckinNotes)
            {
                clone.CheckinNotes[note.Key] = note.Value;
            }

            return clone;
        }

        public void load(Globals globals, string solutionName)
        {
            lock (this)
            {
                issues.Clear();

                solutionName = ParameterSerializer.getKeyFromSolutionName(solutionName);

                int count = ParameterSerializer.loadParameter(globals, RECENTLY_VIEWED_COUNT + solutionName, -1);
                if (count != -1)
                {
                    try
                    {
                        if (count > MAX_ITEMS)
                            count = MAX_ITEMS;

                        for (int i = 1; i <= count; ++i)
                        {
                            string guidStr = ParameterSerializer.loadParameter(globals, RECENTLY_VIEWED_ISSUE_SERVER_GUID + solutionName + "_" + i, null);
                            Guid guid = new Guid(guidStr);
                            string key = ParameterSerializer.loadParameter(globals, RECENTLY_VIEWED_ISSUE_KEY + solutionName + "_" + i, null);
                            RecentlyViewedIssue issue = new RecentlyViewedIssue(guid, key);
                            issues.Add(issue);
                        }
                    }
                    catch (Exception e)
                    {
                        Debug.WriteLine(e);
                    }
                }
                changedSinceLoading = false;
            }
        }

 public Verify(Globals globals, TreeVerifier verifier, TextWriter stdout, Help helper)
 {
     _globals = globals;
     _verifier = verifier;
     _stdout = stdout;
     _helper = helper;
 }

 public Shelve(CheckinOptions checkinOptions, TfsWriter writer, Globals globals)
 {
     _globals = globals;
     _checkinOptions = checkinOptions;
     _checkinOptionsFactory = new CheckinOptionsFactory(_globals);
     _writer = writer;
 }

 /// <summary>
 /// Creates a TerrainType of the type specified in t.
 /// </summary>
 /// <param name="t">A type of Globals.TerrainTypes.</param>
 public TerrainType(Globals.TerrainTypes t)
 {
     this.type = t;
     switch (t)
     {
         case (Globals.TerrainTypes.Membrane):
             {
                 this.dmgMod = 0;
                 this.spdMod = 10;
                 this.rscMod = 0;
                 break;
             }
         case (Globals.TerrainTypes.Mucus):
             {
                 this.dmgMod = 0;
                 this.spdMod = 8;
                 this.rscMod = 4;
                 break;
             }
         case (Globals.TerrainTypes.Slow):
             {
                 this.dmgMod = 0;
                 this.spdMod = 5;
                 this.rscMod = 0;
                 break;
             }
         case (Globals.TerrainTypes.Infected):
             {
                 this.dmgMod = 5;
                 this.spdMod = 10;
                 this.rscMod = 0;
                 break;
             }
     }
 }