public void PlaySound(Automaton owner)
 {
     if (template.UseSFX > 0)
     {
         owner.PlaySound(template.UseSFX);
     }
 }

 /// <summary>
 /// Create a new AutomatonQuery from an <seealso cref="Automaton"/>.
 /// </summary>
 /// <param name="term"> Term containing field and possibly some pattern structure. The
 ///        term text is ignored. </param>
 /// <param name="automaton"> Automaton to run, terms that are accepted are considered a
 ///        match. </param>
 public AutomatonQuery(Term term, Automaton automaton)
     : base(term.Field)
 {
     this.Term = term;
     this.Automaton_Renamed = automaton;
     this.Compiled = new CompiledAutomaton(automaton);
 }

 public CommandSet(Automaton owner, int capacity, bool autoFire, CommandSet pipe)
 {
     this.owner = owner;
     this.capacity = capacity;
     this.queue = new List<Command>();
     this.pipe = pipe;
 }

 public State(State[] states, string regexPattern, bool isAcceptedState, Automaton automaton)
 {
     this.automaton = automaton;
     this.states = states == null ? null : new List<State>(states);
     this.pattern = regexPattern;
     this.isAcceptedState = isAcceptedState;
 }

        /// <summary>
        /// Computes the ratio of two dfas
        /// </summary>        
        /// <returns>size of dfa2/ size of dfa1</returns>
        internal static double GetDFARatio(Automaton<BDD> dfa1, Automaton<BDD> dfa2, HashSet<char> al, CharSetSolver solver, bool isSolDense)
        {
            var n = dfa1.StateCount;

            double multiplier = 3;
            int k = Math.Min(13, (int)(n * multiplier));

            int finalDivider = k;

            double[] paths1 = GetPathsUpToN(dfa1, al, solver, k);
            double[] paths2 = GetPathsUpToN(dfa2, al, solver, k);

            double sum = 0;
            for (int i = 0; i <= k; i++)
            {
                //TODO check grading still works
                double divider = Math.Min(paths1[i], Math.Pow(al.Count, i) - paths1[i]);
                if (divider != 0)
                    sum += (paths2[i] / divider);
                else
                {
                    sum += paths2[i];
                    if (paths2[i] == 0)
                        finalDivider--;
                }
            }

            return sum / (finalDivider + 1);
        }

 public MoveSequence(string regex)
 {
     solver = new CharSetSolver(BitWidth.BV7);
     moveAutomaton = solver.Convert("^(" + regex + ")$").Determinize(solver).Minimize(solver);
     currentState = 0;
     //solver.ShowGraph(moveAutomaton, "D");
     //ComputeDeadStates();
 }

        public readonly long elapsedTime; // in milliseconds

        //public readonly double densityDiffAverage, densityDifferenceDeviation;
        //public readonly double editDistanceAverage, editDistanceDeviation;

        public MeasurementResultSet(PDLPred originalFormula, IEnumerable<PDLPred> generatedFormulas, long time, VariableCache.ConstraintMode constraintmode, 
            PdlFilter.Filtermode filtermode, HashSet<char> alphabet, IDictionary<PDLPred, SingleMeasurementResult> cache,
            IDictionary<Automaton<BDD>, SingleMeasurementResult> automatonCache)
        {
            this.originalFormula = originalFormula;
            this.alphabet = alphabet;
            this.originalAutomaton = originalFormula.GetDFA(alphabet, new CharSetSolver());

            this.constraintmode = constraintmode;
            this.filtermode = filtermode;

            this.elapsedTime = time;

            this.results = new List<SingleMeasurementResult>();

            foreach (PDLPred generatedFormula in generatedFormulas)
            {
                SingleMeasurementResult result;
                if (cache.ContainsKey(generatedFormula))
                {
                    result = cache[generatedFormula];
                }
                else
                {
                    result = SingleMeasurementResult.Create(this.originalAutomaton, generatedFormula, this.alphabet, automatonCache);
                    cache[generatedFormula] = result;
                }
                this.results.Add(result);
            }

            // Compute statistics
            /*
            double densityDiffSum = 0;
            int editDistanceSum = 0;

            foreach (SingleMeasurementResult result in this.results)
            {
                densityDiffSum += result.densityDiff;
                editDistanceSum += result.editDistance;
            }

            this.densityDiffAverage = ((double)densityDiffSum) / ((double)this.results.Count);
            this.editDistanceAverage = ((double)editDistanceSum) / ((double)this.results.Count);

            double densityDiffDeviation = 0;
            double editDistanceDeviation = 0;
            foreach (SingleMeasurementResult result in this.results)
            {
                densityDiffDeviation += Math.Pow(result.densityDiff - this.densityDiffAverage, 2.0);
                editDistanceDeviation += Math.Pow(((double)result.editDistance) - this.editDistanceAverage, 2.0);
            }
            densityDiffDeviation /= this.results.Count;
            densityDiffDeviation = Math.Sqrt(densityDiffDeviation);

            editDistanceDeviation /= this.results.Count;
            editDistanceDeviation = Math.Sqrt(editDistanceDeviation);
            */
        }

 static bool IsPuzzleReady(Automaton firer)
 {
     if (firer is HeroCharacter)
     {
         PuzzlePanel puzzle = (firer as HeroCharacter).puzzlePanel;
         return puzzle.IsReadyToBlockTrans();
     }
     return true;
 }

 public CSharpGenerator(Automaton<BDD> automaton, CharSetSolver solver, string classname, string namespacename, bool OptimzeForAsciiInput = true)
 {
     this.solver = solver;
     this.automaton = automaton;
     this.namespacename = namespacename;
     this.classname = classname;
     ASCII = solver.MkCharSetFromRange('\0', '\x7F');
     helper_predicates = new HelperPredicates(solver, OptimzeForAsciiInput);
 }

        private static void PrintDFA(Automaton<BDD> dfa, string name, HashSet<char> al)
        {
            var sb = new StringBuilder();
            DFAUtilities.printDFA(dfa, al, sb);

            System.IO.StreamWriter file = new System.IO.StreamWriter(@"../../../TestPDL/DFAs/" + name + ".txt");
            file.WriteLine(sb);
            file.Close();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public NFAEditScript GetNFAOptimalEdit(Automaton<BDD> nfa2)
        {
            NFAEditScript editScript = new NFAEditScript();           

            //Start timer
            sw.Start();

            //Normalize NFAs
            var normNfaPair = DFAUtilities.normalizeDFA(nfa2);
            var normNfa2 = normNfaPair.First;
            var stateNamesMapping = normNfaPair.Second;


            NFAEditScript bestScript = new NFAEditScript();
            bestScript.script = null;

            // increase depth up to maxMoves
            for (int depth = 1; true; depth++)
            {
                var editList = new List<NFAEdit>();
                if(GetNFAEditScriptTimeout(
                    depth, -1, normNfa2,
                    editScript.script, editScript.GetCost(), bestScript))
                {
                    // if hits timeout break and return null
                    break;
                }
                if (bestScript.script != null)
                {
                    bestScript.script.Reverse();
                    sw.Stop();
                    var mappedEditList = new List<NFAEdit>();

                    //fix states name because of normalization
                    foreach (var edit in bestScript.script)
                    {   
                        NFAEdit mappedEdit = null;
                        if(edit is NFAEditState){
                            var castEdit = edit as NFAEditState;
                            mappedEdit = new NFAEditState(stateNamesMapping[castEdit.state], castEdit.makeFinal);
                        }
                        if(edit is NFAEditMove){
                            var castEdit = edit as NFAEditMove;
                            mappedEdit = new NFAEditMove(
                                stateNamesMapping[castEdit.sourceState], 
                                stateNamesMapping[castEdit.newTargetState],
                                castEdit.ch);
                        }
                        mappedEditList.Add(mappedEdit);
                    }
                    return bestScript;
                }
            }

            return null;
        }

        public MainForm()
        {
            InitializeComponent();
            this.Size = Properties.Settings.Default.MainFormSize;
            this.Location = Properties.Settings.Default.MainFormLocation;

            // Load all known color on textBoxColorName's AutoComplete Collection
            Automaton c = new Automaton();
            this.textBoxColorName.AutoCompleteCustomSource = c.GetAllKnownColors();
        }

 /// <summary>
 /// Returns the minimum PDL edit distance ratio between all the PDL A1 and A2 inferred for dfa1 and dfa2
 /// in less than timeout. For every  min_ij(d(A1i,A2j)/|A1i)
 /// </summary>
 /// <param name="dfa1"></param>
 /// <param name="dfa2"></param>
 /// <param name="al"></param>
 /// <param name="solver"></param>
 /// <param name="timeout"></param>
 /// <returns></returns>
 public static double GetMinimalFormulaEditDistanceRatio(Automaton<BDD> dfa1, Automaton<BDD> dfa2, HashSet<char> al, CharSetSolver solver, long timeout, PDLEnumerator pdlEnumerator)
 {
     var v = GetMinimalFormulaEditDistanceTransformation(dfa1, dfa2, al, solver, timeout, pdlEnumerator);
     if(v!=null){
         var transformation = v.First;
         var scaling = 1.0;
         return transformation.totalCost / (transformation.minSizeForTreeA * scaling);
     }
     return 10;
 }

 public bool HasFirable(Automaton owner)
 {
     foreach (var entity in queue)
     {
         if (entity.IsFirable(owner))
         {
             return true;
         }
     }
     return false;
 }

 public bool HasFirableTarget(Automaton firer)
 {
     if (pattern != null)
     {
         if (base.IsFirable(firer))
         {
             return pattern.HasApplicableTarget(firer.FindTarget);
         }
     }
     return false;
 }

 public override bool IsFirable(Automaton firer)
 {
     if (pattern != null)
     {
         if (base.IsFirable(firer))
         {
             return pattern.HasTarget(firer.FindTarget);
         }
     }
     return false;
 }

 public void OnSight(RaycastHit[] hits, Automaton au)
 {
     if(au.CurrentTarget == null){
         foreach(RaycastHit hit in hits){
             if(hit.transform.gameObject.tag.Equals("Fireteam")){
                 au.CurrentTarget = hit.transform.gameObject;
                 break;
             }
         }
     }
 }

 protected override bool Fire(Automaton owner, Command command)
 {
     if (base.Fire(owner, command))
     {
         if (consumable)
         {
             Remove(command);
         }
         return true;
     }
     return false;
 }

        /// <summary>
        /// Computes the ratio of the symmetric difference to the size of dfa1 enumerating paths up to length n (uses the complement if density is high)
        /// </summary>        
        /// <returns>size of ((dfa2-dfa1)+(dfa1-dfa2))/dfa1</returns>
        public static double GetDFADifferenceRatio(Automaton<BDD> dfa1, Automaton<BDD> dfa2, HashSet<char> al, CharSetSolver solver)
        {
            var solutionDensity = DFADensity.GetDFADensity(dfa1, al, solver);

            //Symmetric difference
            var dfadiff1 = dfa1.Minus(dfa2, solver);
            var dfadiff2 = dfa2.Minus(dfa1, solver);
            var dfatrue = Automaton<BDD>.Create(0, new int[] { 0 }, new Move<BDD>[] { new Move<BDD>(0, 0, solver.True) });
            var dfadiff = dfatrue.Minus(dfatrue.Minus(dfadiff1, solver).Intersect(dfatrue.Minus(dfadiff2, solver), solver), solver).Determinize(solver).Minimize(solver);

            //Use smallest of |dfa1| and complement of |dfa1| for cardinality base
            return GetDFARatio(dfa1.Determinize(solver).Minimize(solver), dfadiff, al, solver, solutionDensity > 0.5);
        }

 public void OnHear(GameObject source, Automaton au)
 {
     if(au.CurrentTarget==null && !au.IsChecking){
         if(!au.agresive){
             au.transform.LookAt(new Vector3 (source.transform.position.x, au.transform.position.y,source.transform.position.z));
             au.IsChecking = true;
             au.StartCoroutine("CheckNoise");
         }else{
             au.SaveIndex();
             au.ClearQue(source.transform.position);
             au.StartCoroutine("Going");
         }
     }
 }