Exemple #1
0
        /// <summary>
        /// foamliu, 2009/01/20.
        ///
        /// 目标可达且彼此不互斥.
        /// </summary>
        /// <returns></returns>
        private bool GoalsReachable()
        {
            // 首先是所有目标中的命题都在.
            foreach (string literal in this.m_goal.Literals)
            {
                if (!this.m_lastProp.Conjunction.Literals.Contains(literal))
                {
                    return(false);
                }
            }

            // 其次目标中的命题不彼此互斥.
            for (int i = 0; i < m_goal.Literals.Count; i++)
            {
                Proposition theProp1 = m_lastProp.GetProposition(m_goal.Literals[i]);
                for (int j = i + 1; j < m_goal.Literals.Count; j++)
                {
                    Proposition theProp2 = m_lastProp.GetProposition(m_goal.Literals[j]);
                    if (theProp1.IsMutex(theProp2))
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }
Exemple #2
0
 /// <summary>
 /// foamliu, 2009/01/22.
 ///
 /// 是否选中的 action 已经可以满足它.
 /// </summary>
 /// <returns></returns>
 private bool SatisfiedBySelectedActions(Proposition theProp)
 {
     foreach (Action theAct in m_selectedActions)
     {
         if (theProp.AddEdges.Contains(theAct))
         {
             return(true);
         }
     }
     return(false);
 }
Exemple #3
0
        /// <summary>
        /// foamliu, 2009/01/21, 建立 Del-Effects 边.
        /// </summary>
        private void CreateDelEdges(Action theAct)
        {
            Conjunction add = theAct.DelEffects;

            foreach (string s in add.Literals)
            {
                Proposition theProp = m_next.AddProposition(s);
                theProp.AddDelEdge(theAct);
                theAct.AddDelProp(theProp);
            }
        }
Exemple #4
0
        /// <summary>
        /// foamliu, 2009/01/21, 建立 PreCondition 边.
        ///
        /// 例如:
        /// Move ( b1, b2, b3 )
        /// PreCondition 是:
        ///     ON (b1, b2) & Clear (b1) & Clear (b3)
        /// </summary>
        /// <param name="theAct"></param>
        private void CreatePreEdges(Action theAct)
        {
            Conjunction pre = theAct.PreCondition;

            foreach (string s in pre.Literals)
            {
                Proposition theProp = m_prev.GetProposition(s);
                theProp.AddPreEdge(theAct);
                theAct.AddPreProp(theProp);
            }
        }
Exemple #5
0
        public Proposition AddProposition(Proposition thePro)
        {
            // foamliu, 2009/01/22, fix a bug:
            // {"An item with the same key has already been added."}.
            if (m_dict.ContainsKey(thePro.Name))
            {
                return(m_dict[thePro.Name]);
            }

            m_props.Add(thePro);
            m_dict.Add(thePro.Name, thePro);
            m_conj.Literals.Add(thePro.Name);
            return(thePro);
        }
Exemple #6
0
 /// <summary>
 /// foamliu, 2009/01/22, 检测命题互斥.
 ///
 /// 要求所有相关的 action 都彼此互斥.
 /// </summary>
 /// <param name="theProp1"></param>
 /// <param name="theProp2"></param>
 /// <returns></returns>
 private bool TestActions(Proposition theProp1, Proposition theProp2)
 {
     foreach (Action theAct1 in theProp1.AddEdges)
     {
         foreach (Action theAct2 in theProp2.AddEdges)
         {
             if (theAct1.IsMutex(theAct2) == false)
             {
                 return(false);
             }
         }
     }
     return(true);
 }
Exemple #7
0
        /// <summary>
        /// foamliu, 2009/01/22, 检测互斥的命题.
        ///
        /// 下面这段拷贝自如下论文的 2.2 节:
        /// "Fast Planning Through Planning Graph Analysis"
        /// Two propositions p and q in a proposition-level are marked as exclusive if all ways of
        ///     creating proposition p are exclusive of all ways of creating proposition q. Specifically, they
        ///     are marked as exclusive if each action a having an add-edge to proposition p is marked as
        ///     exclusive of each action b having an add-edge to proposition q.
        /// </summary>
        public void TestMutex()
        {
            for (int i = 0; i < m_props.Count; i++)
            {
                for (int j = i + 1; j < m_props.Count; j++)
                {
                    Proposition theProp1 = m_props[i];
                    Proposition theProp2 = m_props[j];

                    if (TestActions(theProp1, theProp2))
                    {
                        theProp1.MutexProps.Add(theProp2);
                        theProp2.MutexProps.Add(theProp1);
                    }
                }
            }
        }
Exemple #8
0
        /// <summary>
        /// foamliu, 2009/01/21, 添加 No-op actions.
        /// </summary>
        private void AddNoops()
        {
            Conjunction conj = m_prev.Conjunction;

            foreach (string s in conj.Literals)
            {
                // 创建 No-op action.
                Action theAct = new Action("NOOP: " + s);
                theAct.PreCondition.Literals.Add(s);
                theAct.AddEffects.Literals.Add(s);
                this.m_actions.Add(theAct);
                // 把这个 no-op 加入当前行为层.
                Proposition theProp = m_prev.GetProposition(s);
                theProp.AddPreEdge(theAct);
                theAct.AddPreProp(theProp);
                // 把这个命题加入下个命题层.
                theProp = m_next.AddProposition(s);
                theProp.AddAddEdge(theAct);
                theAct.AddAddProp(theProp);
            }
        }
Exemple #9
0
 public bool IsMutex(Proposition otherProp)
 {
     return(m_mutexProps.Contains(otherProp));
 }
Exemple #10
0
 public void AddDelProp(Proposition prop)
 {
     this.m_delProps.Add(prop);
 }
Exemple #11
0
 public void AddAddProp(Proposition prop)
 {
     this.m_addProps.Add(prop);
 }
Exemple #12
0
 public void AddPreProp(Proposition prop)
 {
     this.m_preEdges.Add(prop);
 }