Ejemplo n.º 1
0
        public virtual float Heuristic(AIGoal goal)
        {
            //float r = 0;

            //foreach (var keys in goal.PostConditions)
            //{
            //    object Output;
            //    if (PostConditions.TryGetValue(keys.Key, out Output))
            //    {
            //        r++;
            //        if (Convert.ToBoolean(Output) != Convert.ToBoolean(keys.Value))
            //        {

            //        }
            //        else
            //        {
            //            r--;
            //        }
            //    }
            //    else
            //    {
            //    }
            //}



            //return r;

            return(0);
        }
Ejemplo n.º 2
0
        public List <AIAction> TryAndPlan(AIGoal corGoal)
        {
            List <AIAction> plan = new List <AIAction>();

            List <AIAction> validActions = new List <AIAction>();
            bool            valid        = true;

            foreach (var action in Actions)
            {
                action.mAgent = this;
                valid         = true;
                foreach (var keys in action.PostConditions)
                {
                    object Output;
                    if (corGoal.PostConditions.TryGetValue(keys.Key, out Output))
                    {
                        if (Convert.ToBoolean(Output) != Convert.ToBoolean(keys.Value))
                        {
                            valid = false;
                        }
                    }
                    else
                    {
                        valid = false;
                    }
                }



                if (valid)
                {
                    if (action.CheckProceduralPreCondition())
                    {
                        validActions.Add(action);
                    }
                }
            }


            validActions.Sort((x, y) => x.GetCost().CompareTo(y.GetCost()));

            if (validActions.Count() == 0)
            {
                return(plan);
            }

            List <AIAction> path = new List <AIAction>();



            //clear tiles prev stuff
            foreach (var t in Actions)
            {
                t.g = 0;
            }

            var             lastCheckedNode = validActions[0];
            List <AIAction> openSet         = new List <AIAction>();

            // openSet starts with beginning node only
            openSet.Add(lastCheckedNode);
            List <AIAction> closedSet = new List <AIAction>();

            //This function returns a measure of aesthetic preference for
            //use when ordering the openSet. It is used to prioritise
            //between equal standard heuristic scores. It can therefore
            //be anything you like without affecting the ability to find
            //a minimum cost path.



            //Run one finding step.
            //returns 0 if search ongoing
            //returns 1 if goal reached
            //returns -1 if no solution
            var  end       = corGoal;
            bool searching = true;

            while (searching == true)
            {
                if (openSet.Count() > 0)
                {
                    // Best next option
                    var winner = 0;
                    for (var i = 1; i < openSet.Count(); i++)
                    {
                        if (openSet[i].GetF(end) < openSet[winner].GetF(end))
                        {
                            winner = i;
                        }
                        //if we have a tie according to the standard heuristic
                        if (openSet[i].GetF(end) == openSet[winner].GetF(end))
                        {
                            //Prefer to explore options with longer known paths (closer to goal)
                            if (openSet[i].g > openSet[winner].g)
                            {
                                winner = i;
                            }
                        }
                    }
                    var current = openSet[winner];
                    lastCheckedNode = current;
                    // Did I finish?
                    if (current.IsCompatibleWithCurWorldState(WorldState))
                    {
                        path.Add(current);

                        AIAction cur = current;
                        while (cur.Parent != null)
                        {
                            path.Add(cur.Parent);
                            cur = cur.Parent;
                        }
                        path.Reverse();
                        return(path);
                    }

                    // Best option moves from openSet to closedSet
                    openSet.Remove(current);
                    closedSet.Add(current);

                    // Check all the neighbors
                    var neighbors = current.GetActionNeighbours(this);

                    neighbors = neighbors.Where(o => o.CheckProceduralPreCondition()).ToList();

                    for (var i = 0; i < neighbors.Count(); i++)
                    {
                        var neighbor = neighbors[i];

                        // Valid next spot?
                        if (!closedSet.Contains(neighbor))
                        {
                            // Is this a better path than before?
                            var tempG = current.g + 0 + current.GetCost();;

                            // Is this a better path than before?
                            if (!openSet.Contains(neighbor))
                            {
                                openSet.Add(neighbor);
                            }
                            else if (tempG >= neighbor.g)
                            {
                                // No, it's not a better path
                                continue;
                            }

                            neighbor.g = tempG;

                            neighbor.Parent = current;
                        }
                    }
                }
                else
                {
                    searching = false;

                    return(path);
                }
                // Uh oh, no solution
            }
            return(path);
        }
Ejemplo n.º 3
0
 public virtual float GetF(AIGoal goal)
 {
     return(Heuristic(goal) + g);
 }