public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
        {
            Match m;
            if ((m = matcher.Match(spelling)).Success)
            {
                var ops = new List<ArithmeticCondition.Operation>();
                foreach (Match op in operation.Matches(m.Groups["Ops"].Value))
                {
                    ops.Add(new ArithmeticCondition.Operation
                    {
                       Number = double.Parse(op.Groups["Number"].Value, dialect.Parser.PatternCulture),
                       Operator = Arithmetic.GetArithmeticOperator(op.Groups["Op"].Value)
                    });
                }

                return new ArithmeticCondition
                {
                    Operations = ops,
                    CompareOperator = Arithmetic.GetCompareOperator(m.Groups["Op"].Value),
                    TargetValue = int.Parse(m.Groups["TargetValue"].Value)
                };
            }

            return null;
        }

        /// <summary>
        /// Parses the specified pattern returned by the reader and localizes error messages with the text manager specified
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="textManager">The text manager.</param>
        /// <returns></returns>
        public override Expression Parse(TextReader reader, TextManager textManager)
        {
            try
            {
                _reader = reader.ReadToEnd();

                _pos = -1;

                MoveNext();

                var expr = ParseExpression();
                if (_current != Eof)
                {
                    UnexpectedToken("Expression", "" + _current);
                }

                expr.Accept(_trimmer);

                return expr;
            }
            catch (InnerParserException template)
            {
                throw new SyntaxErrorException(template.Message, template.Construct, template.Pos);
            }
        }

        public override Expression Parse(System.IO.TextReader reader, TextManager manager)
        {
            var expr = new Expression();
            expr.Parts.Add(new Text { Spelling = reader.ReadToEnd() });

            return expr;
        }

 // Use this for initialization
 void Start()
 {
     rb2d = gameObject.GetComponent<Rigidbody2D> ();
     animator = gameObject.GetComponent<Animator> ();
     movement = getDefaultMovement ();
     dragon = GameObject.FindGameObjectWithTag ("Dragon").GetComponent<Dragon> ();
     textManager = GameObject.FindGameObjectWithTag ("TextManager").GetComponent<TextManager> ();
 }

 public IValueFormatter GetFor(string formatExpression, PatternDialect dialect, TextManager manager)
 {
     if (!string.IsNullOrEmpty(formatExpression))
     {
         return new StringFormatFormatter(formatExpression);
     }
     return null;
 }

        public IValueFormatter GetFor(string formatExpression, PatternDialect dialect, TextManager manager)
        {
            if (!string.IsNullOrEmpty(formatExpression) && formatExpression.Equals("roman", StringComparison.InvariantCulture))
            {
                return new RomanNumberFormatter();
            }

            return null;
        }

        public override PatternEvaluator GetEvaluator(string pattern, TextManager manager)
        {
            lock (_parseLock)
            {
                var expr = Parser.Parse(pattern, manager);

                return new PatternEvaluator(expr);
            }
        }

        public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
        {
            if (string.IsNullOrEmpty(spelling) || spelling.Equals("true", StringComparison.InvariantCultureIgnoreCase))
            {
                return new TakeAllCondition();
            }

            return null;
        }

 public virtual ISwitchConditionEvaluator GetSwitchConditionEvaluator(Expression expr, TextManager manager)
 {
     ISwitchConditionEvaluator sc = null;
     if (!SwitchConditionEvaluators.Any(x => (sc = x.GetFor(expr, this, manager)) != null))
     {
         throw new LocalizedKeyNotFoundException("Exceptions.SwitchConditionNotFound", "No switch condition evaluator found for {0}", new { Spec = expr });                
     }
     return sc;
 }

    // Use this for initialization
    void Start()
    {
        networkManager = gameObject.GetComponent<NetworkManager>();
        collisionManager = gameObject.GetComponent<CollisionManager>();
        textManager = gameObject.GetComponent<TextManager>();
        notificationManager = gameObject.GetComponent<NotificationManager>();

        panelManager = GameObject.Find("Panel");
        scaleChilds(panelManager);
    }

        public virtual IValueFormatter GetValueFormatter(string spelling, TextManager manager)
        {
            IValueFormatter formatter = null;
            if (!ValueFormatters.Any(x => (formatter = x.GetFor(spelling, this, manager)) != null))
            {
                throw new LocalizedKeyNotFoundException("Exceptions.ValueFormatterNotFound", "No parameter evaluator found for {0}", new { Text = spelling});                
            }

            return formatter;
        }

        public virtual IParameterEvaluator GetParameterEvaluator(ParameterSpec spec, TextManager manager)
        {
            IParameterEvaluator evaluator = null;
            if (!ParameterEvaluators.Any(x => (evaluator = x.GetFor(spec, this, manager)) != null))
            {
                throw new LocalizedKeyNotFoundException("Exceptions.ParameterEvaluatorNotFound", "No parameter evaluator found for {0}", new { Text = spec });
            }

            return evaluator;
        }

        public IParameterEvaluator GetFor(ParameterSpec spec, PatternDialect dialect, TextManager manager)
        {
            var parts = spec.ParameterName.Split('.');
            if (parts.Length > 1)
            {
                return new ReflectionParameterEvaluator(parts[0], parts.Skip(1).ToArray());
            }

            return null;
        }

        public IValueFormatter GetFor(string formatExpression, PatternDialect dialect, TextManager manager)
        {
            StringCaseTransformationType type;
            if (!string.IsNullOrEmpty(formatExpression) 
                && _transformationTypes.TryGetValue(formatExpression.ToLowerInvariant(), out type))
            {
                return new StringCaseFormatter { TransformationType = type };
            }

            return null;
        }

	void Start()
    {
        root = GameObject.Find("UI Root");
        ps = transform.GetComponent<PanelSwitch>();
        tm = transform.GetComponent<TextManager>();
        im = transform.GetComponent<ImageManager>();
        playerdata = new UserData();
        for(int i = 0; i < 7; i++)
        {
            girl[i] = new GirlData(i);
        }
    }

    void OnEnable()
    {
        thisScript = (TextManager) target;

        isFinalBoxProp = serializedObject.FindProperty("isFinalBox");
        TypeWritterFrequencyProp = serializedObject.FindProperty("TypeWritterFrequency");
        NumberOfStatementsProp = serializedObject.FindProperty("NumberOfStatements");
        ScriptProp = new SerializedProperty[thisScript.Script.Length];
        for(int i = 0; i < thisScript.Script.Length; i++)
        {
            ScriptProp[i] = serializedObject.FindProperty(string.Format("{0}.Array.data[{1}]", "Script", i));
        }
    }

        public ITextSource GetSource(TextManager textManager, Assembly referenceAssembly, string targetNamespace)
        {
            var source = new SimpleTextSource();
            source.Texts.Add(new LocalizedText
            {
                Namespace = targetNamespace,
                Key = "Tulips1",
                Pattern = "resource:TestPlugin.Koala.jpg",
                Language = "da-DK",
                Source = new TextSourceInfo { TextSource = source, ReferenceAssembly = referenceAssembly }
            });

            return source;
        }

 public override ITextSource GetSource(Assembly asm, TextManager textManager, string targetNamespace)
 {            
     var source = XmlTextSource.ForAssembly(asm, ResourceName);
     if (source != null)
     {
         source.DefaultNamespace = targetNamespace;
     }
     else
     {
         throw new LocalizedFileNotFoundException(ResourceName, "Exceptions.ResourceNotFoundException",
             defaultMessage: "The resource {0} could not be opened");
     }
     return source;
 }

        public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
        {
            if (spelling.StartsWith("@"))
            {
                var evaluator = dialect.GetParameterEvaluator(
                    new ParameterSpec { ParameterName = spelling }, manager) as PatternLookupEvaluator;
                if (evaluator != null)
                {
                    return new LookupCondition
                    {
                        Dialect = dialect,
                        Evaluator = evaluator
                    };
                }
            }

            return null;
        }        

        public ISwitchConditionEvaluator GetFor(Expression rep, PatternDialect dialect, TextManager manager)
        {
            if (rep == null)
            {
                return GetFor("", dialect, manager);
            }
            else if (rep.Parts.Count == 1)
            {
                var text = rep.Parts[0] as Text;
                if (text != null)
                {
                    return GetFor(text.Spelling.Trim(), dialect, manager);
                }
            }

            //Unsupported expression
            return null;
        }