Merge branch 'preda2or-multiple_logical_conditions' into develop

Assets/Fungus/Scripts/Commands/Condition.cs

@@ -13,8 +13,6 @@ namespace Fungus
     {
         protected End endCommand;
      
-        #region Public members
-
         public override void OnEnter()
         {
             if (ParentBlock == null)
@@ -88,7 +86,6 @@ namespace Fungus
             }
         }
 
-        #endregion
                
         protected End FindOurEndCommand()
         {

Assets/Fungus/Scripts/Commands/VariableCondition.cs

@@ -1,55 +1,141 @@
 // This code is part of the Fungus library (https://github.com/snozbot/fungus)
 // It is released for free under the MIT open source license (https://github.com/snozbot/fungus/blob/master/LICENSE)
 
-using UnityEngine;
 using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
 
 namespace Fungus
 {
-    public abstract class VariableCondition : Condition, ISerializationCallbackReceiver
+    /// <summary>
+    /// class for a single condition. A list of this is used for multiple conditions.
+    /// </summary>
+    [System.Serializable]
+    public class ConditionExpression
     {
-        [Tooltip("The type of comparison to be performed")]
         [SerializeField] protected CompareOperator compareOperator;
+        [SerializeField] protected AnyVariableAndDataPair anyVar;
+
+        public virtual AnyVariableAndDataPair AnyVar { get { return anyVar; } }
+        public virtual CompareOperator CompareOperator { get { return compareOperator; } }
+
+        public ConditionExpression()
+        {
+        }
+
+        public ConditionExpression(CompareOperator op, AnyVariableAndDataPair variablePair)
+        {
+            compareOperator = op;
+            anyVar = variablePair;
+        }
+    }
+
+    public abstract class VariableCondition : Condition, ISerializationCallbackReceiver
+    {
+        public enum AnyOrAll
+        {
+            AnyOf_OR,//Use as a chain of ORs
+            AllOf_AND,//Use as a chain of ANDs
+        }
 
-        [SerializeField] protected AnyVariableAndDataPair anyVar = new AnyVariableAndDataPair();
+        [Tooltip("Selecting AnyOf will result in true if at least one of the conditions is true. Selecting AllOF will result in true only when all the conditions are true.")]
+        [SerializeField] protected AnyOrAll anyOrAllConditions;
+
+        [SerializeField] protected List<ConditionExpression> conditions = new List<ConditionExpression>();
+
+        /// <summary>
+        /// Called when the script is loaded or a value is changed in the
+        /// inspector (Called in the editor only).
+        /// </summary>
+        public override void OnValidate()
+        {
+            base.OnValidate();
+
+            if (conditions == null)
+            {
+                conditions = new List<ConditionExpression>();
+            }
+
+            if (conditions.Count == 0)
+            {
+                conditions.Add(new ConditionExpression());
+            }
+        }
 
         protected override bool EvaluateCondition()
         {
-            if (anyVar.variable == null)
+            if (conditions == null || conditions.Count == 0)
             {
                 return false;
             }
 
-            bool condition = false;
-            anyVar.Compare(compareOperator, ref condition);
+            bool resultAny = false, resultAll = true;
+            foreach (ConditionExpression condition in conditions)
+            {
+                bool curResult = false;
+                if (condition.AnyVar == null)
+                {
+                    resultAll &= curResult;
+                    resultAny |= curResult;
+                    continue;
+                }
+                condition.AnyVar.Compare(condition.CompareOperator, ref curResult);
+                resultAll &= curResult;
+                resultAny |= curResult;
+            }
 
-            return condition;
+            if (anyOrAllConditions == AnyOrAll.AnyOf_OR) return resultAny;
+
+            return resultAll;
         }
 
         protected override bool HasNeededProperties()
         {
-            return (anyVar.variable != null);
+            if (conditions == null || conditions.Count == 0)
+            {
+                return false;
             }
 
-        #region Public members
-
-        /// <summary>
-        /// The type of comparison operation to be performed.
-        /// </summary>
-        public virtual CompareOperator CompareOperator { get { return compareOperator; } }
+            foreach (ConditionExpression condition in conditions)
+            {
+                if (condition.AnyVar == null || condition.AnyVar.variable == null)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
         
         public override string GetSummary()
         {
-            if (anyVar.variable == null)
+            if (!this.HasNeededProperties())
             {
                 return "Error: No variable selected";
             }
 
-            string summary = anyVar.variable.Key + " ";
-            summary += VariableUtil.GetCompareOperatorDescription(compareOperator) + " ";
-            summary += anyVar.GetDataDescription();
+            string connector = "";
+            if (anyOrAllConditions == AnyOrAll.AnyOf_OR)
+            {
+                connector = " <b>OR</b> ";
+            }
+            else
+            {
+                connector = " <b>AND</b> ";
+            }
+
+            StringBuilder summary = new StringBuilder("");
+            for (int i = 0; i < conditions.Count; i++)
+            {
+                summary.Append(conditions[i].AnyVar.variable.Key + " " +
+                               VariableUtil.GetCompareOperatorDescription(conditions[i].CompareOperator) + " " +
+                               conditions[i].AnyVar.GetDataDescription());
 
-            return summary;
+                if (i < conditions.Count - 1)
+                {
+                    summary.Append(connector);
+                }
+            }
+            return summary.ToString();
         }
 
         public override bool HasReference(Variable variable)
@@ -57,10 +143,14 @@ namespace Fungus
             return anyVar.HasReference(variable);
         }
 
-        #endregion
 
         #region backwards compat
 
+        [HideInInspector]
+        [SerializeField] protected CompareOperator compareOperator;
+
+        [HideInInspector]
+        [SerializeField] protected AnyVariableAndDataPair anyVar;
 
         [Tooltip("Variable to use in expression")]
         [VariableProperty(AllVariableTypes.VariableAny.Any)]
@@ -120,14 +210,9 @@ namespace Fungus
 
         void ISerializationCallbackReceiver.OnAfterDeserialize()
         {
-            if (variable == null)
-            {
-                return;
-            }
-            else
+            if (variable != null)
             {
                 anyVar.variable = variable;
-            }
 
                 if (variable.GetType() == typeof(BooleanVariable) && !booleanData.Equals(new BooleanData()))
                 {
@@ -214,6 +299,22 @@ namespace Fungus
                 //moved to new anyvar storage, clear legacy.
                 variable = null;
             }
-        #endregion
+
+            // just checking for anyVar != null fails here. is any var being reintilaized somewhere?
+
+            if (anyVar != null && anyVar.variable != null)
+            {
+                ConditionExpression c = new ConditionExpression(compareOperator, anyVar);
+                if (!conditions.Contains(c))
+                {
+                    conditions.Add(c);
+                }
+
+                anyVar = null;
+                variable = null;
+            }
+        }
+
+        #endregion backwards compat
     }
 }

Assets/Fungus/Scripts/Editor/VariableConditionEditor.cs

@@ -3,10 +3,14 @@
 
 using UnityEditor;
 using UnityEngine;
-using System.Collections.Generic;
 
 namespace Fungus.EditorUtils
 {
+    /// <summary>
+    /// Handles custom drawing for ConditionExperssions within the VariableCondition and inherited commands.
+    /// 
+    /// TODO; refactor to allow a propertydrawer on ConditionExperssion and potentially list as reorderable
+    /// </summary>
     [CustomEditor(typeof(VariableCondition), true)]
     public class VariableConditionEditor : CommandEditor
     {
@@ -17,7 +21,7 @@ namespace Fungus.EditorUtils
             None,
         };
 
-        static readonly GUIContent[] compareListAll = new GUIContent[]
+        private static readonly GUIContent[] compareListAll = new GUIContent[]
         {
             new GUIContent(VariableUtil.GetCompareOperatorDescription(CompareOperator.Equals)),
             new GUIContent(VariableUtil.GetCompareOperatorDescription(CompareOperator.NotEquals)),
@@ -27,29 +31,30 @@ namespace Fungus.EditorUtils
             new GUIContent(VariableUtil.GetCompareOperatorDescription(CompareOperator.GreaterThanOrEquals)),
         };
 
-        static readonly GUIContent[] compareListEqualOnly = new GUIContent[]
+        private static readonly GUIContent[] compareListEqualOnly = new GUIContent[]
         {
             new GUIContent(VariableUtil.GetCompareOperatorDescription(CompareOperator.Equals)),
             new GUIContent(VariableUtil.GetCompareOperatorDescription(CompareOperator.NotEquals)),
         };
 
-        protected SerializedProperty compareOperatorProp;
-        protected SerializedProperty anyVarProp;
-
-        protected Dictionary<System.Type, SerializedProperty> propByVariableType;
+        protected SerializedProperty conditions;
 
         public override void OnEnable()
         {
             base.OnEnable();
 
-            compareOperatorProp = serializedObject.FindProperty("compareOperator");
-            anyVarProp = serializedObject.FindProperty("anyVar");
+            conditions = serializedObject.FindProperty("conditions");
         }
 
         public override void DrawCommandGUI()
         {
             serializedObject.Update();
 
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("anyOrAllConditions"));
+
+            conditions.arraySize = EditorGUILayout.IntField("Size", conditions.arraySize);
+            GUILayout.Label("Conditions", EditorStyles.boldLabel);
+
             VariableCondition t = target as VariableCondition;
 
             var flowchart = (Flowchart)t.GetFlowchart();
@@ -58,19 +63,26 @@ namespace Fungus.EditorUtils
                 return;
             }
 
-            EditorGUILayout.PropertyField(anyVarProp, true);
+            EditorGUI.indentLevel++;
+            for (int i = 0; i < conditions.arraySize; i++)
+            {
+                var conditionAnyVar = conditions.GetArrayElementAtIndex(i).FindPropertyRelative("anyVar");
+                var conditionCompare = conditions.GetArrayElementAtIndex(i).FindPropertyRelative("compareOperator");
+
+                EditorGUILayout.PropertyField(conditionAnyVar, new GUIContent("Variable"), true);
 
                 // Get selected variable
-            Variable selectedVariable = anyVarProp.FindPropertyRelative("variable").objectReferenceValue as Variable;
+                Variable selectedVariable = conditionAnyVar.FindPropertyRelative("variable").objectReferenceValue as Variable;
+
+                if (selectedVariable == null)
+                    continue;
+
                 GUIContent[] operatorsList = emptyList;
-            if (selectedVariable != null)
-            {
                 operatorsList = selectedVariable.IsComparisonSupported() ? compareListAll : compareListEqualOnly;
-            }
 
                 // Get previously selected operator
-            int selectedIndex = (int)t.CompareOperator;
-            if (selectedIndex < 0)
+                int selectedIndex = conditionCompare.enumValueIndex;
+                if (selectedIndex < 0 || selectedIndex >= operatorsList.Length)
                 {
                     // Default to first index if the operator is not found in the available operators list
                     // This can occur when changing between variable types
@@ -82,12 +94,11 @@ namespace Fungus.EditorUtils
                     selectedIndex,
                     operatorsList);
 
-            if (selectedVariable != null)
-            {
-                compareOperatorProp.enumValueIndex = selectedIndex;
-            }
-
+                conditionCompare.enumValueIndex = selectedIndex;
 
+                EditorGUILayout.Separator();
+            }
+            EditorGUI.indentLevel--;
             serializedObject.ApplyModifiedProperties();
         }
     }

Assets/FungusExamples/Conditions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ab073c9a6f825fe4b82cbe37c37addb0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FungusExamples/Conditions/MultipleConditionsExample.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 0d9b345eec71ebc46bfb14d1a3b8af20
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: