public new static BooleanVariable Random()
        {
            var x = new BooleanVariable();

            x.SetRandomValues();
            return(x);
        }
Exemple #2
0
        public void TestFalseStringValue()
        {
            BooleanVariable var = new BooleanVariable();

            var.CheckForStore("false");
            Assert.IsFalse((bool)var.Value);
        }
Exemple #3
0
        public void TestGetNotBoolValue()
        {
            BooleanVariable var    = new BooleanVariable();
            bool            actual = var.CheckForStore(var.CheckForStore(4));

            Assert.IsTrue(actual);
        }
Exemple #4
0
        public void TestBoolValue()
        {
            BooleanVariable var = new BooleanVariable();

            var.CheckForStore(true);
            Assert.IsTrue((bool)var.Value);
        }
 protected virtual void Awake()
 {
     swapEnabled = tileSwapVals.GetVariable("swapEnabled") as BooleanVariable;
     SetToHighlightWhenTileClicked();
     SetToResetWhenSwapHappens();
     RegisterTheAirTileType();
 }
Exemple #6
0
        public void TestTrueStringValue()
        {
            BooleanVariable var = new BooleanVariable();

            var.CheckForStore("true");
            Assert.IsTrue((bool)var.Value);
        }
Exemple #7
0
        public bool EvaluateCondition()
        {
            BooleanVariable booleanVariable = variable as BooleanVariable;
            IntegerVariable integerVariable = variable as IntegerVariable;
            FloatVariable   floatVariable   = variable as FloatVariable;
            StringVariable  stringVariable  = variable as StringVariable;

            bool condition = false;

            if (booleanVariable != null)
            {
                condition = booleanVariable.Evaluate(compareOperator, booleanData.Value);
            }
            else if (integerVariable != null)
            {
                condition = integerVariable.Evaluate(compareOperator, integerData.Value);
            }
            else if (floatVariable != null)
            {
                condition = floatVariable.Evaluate(compareOperator, floatData.Value);
            }
            else if (stringVariable != null)
            {
                condition = stringVariable.Evaluate(compareOperator, stringData.Value);
            }

            return(condition);
        }
        public static void SerializeBooleanVariable()
        {
            var a = new BooleanVariable("foobar");
            var b = SerializationUtil.Reserialize(a);

            Assert.AreEqual(a, b);
        }
Exemple #9
0
        public void TestGetNullValue()
        {
            BooleanVariable var    = new BooleanVariable();
            bool            actual = var.CheckForStore(null);

            Assert.IsFalse(actual);
        }
Exemple #10
0
        public void BooleanVariableChangeValueTest()
        {
            var variable = new BooleanVariable(false);

            Assert.IsFalse(variable.Value);
            variable.Value = true;
            Assert.IsTrue(variable.Value);
        }
Exemple #11
0
    private void AddValueToList(FieldInfo f)
    {
        IBaseVariable variable = null;

        if (f.FieldType.ToString() == "System.String")
        {
            variable = new StringVariable();
        }
        else if (f.FieldType.ToString() == "System.Int32")
        {
            variable = new IntegerVariable();
        }
        else if (f.FieldType.ToString() == "System.Single")
        {
            variable = new FloatVariable();
        }
        else if (f.FieldType.ToString() == "System.Boolean")
        {
            variable = new BooleanVariable();
        }
        else if (f.FieldType.ToString() == "System.String[]")
        {
            variable = new StringVariableArray();
        }
        else if (f.FieldType.ToString() == "System.Int32[]")
        {
            variable = new IntegerVariableArray();
        }
        else if (f.FieldType.ToString() == "System.Single[]")
        {
            variable = new FloatVariableArray();
        }
        else if (f.FieldType.ToString() == "System.Boolean[]")
        {
            variable = new BooleanVariableArray();
        }
        else if (f.FieldType.ToString() == "UnityEngine.Vector2")
        {
            variable = new Vector2Variable();
        }
        else if (f.FieldType.ToString() == "UnityEngine.Vector3")
        {
            variable = new Vector3Variable();
        }
        else if (f.FieldType.ToString() == "UnityEngine.Vector2[]")
        {
            variable = new Vector2VariableArray();
        }
        else if (f.FieldType.ToString() == "UnityEngine.Vector3[]")
        {
            variable = new Vector3VariableArray();
        }
        if (variable != null)
        {
            variable.value = f.GetValue(this);
            ListValue.Add((string)f.Name, variable);
        }
    }
 protected virtual void Awake()
 {
     tileBoard = FindObjectOfType <TileBoardController>();
     TileController.AnyClicked += OnAnyTileClicked;
     swapDurationVar            = tileSwapVals.GetVariable("swapDuration") as FloatVariable;
     swapEnabledVar             = tileSwapVals.GetVariable("swapEnabled") as BooleanVariable;
     cancelAxisVar              = tileSwapVals.GetVariable("cancelAxis") as StringVariable;
     airTileVar           = gameVals.GetVariable("airTileType") as ObjectVariable;
     AnyPhysicalSwapMade += this.OnAnyPhysicalSwapMade;
 }
    public BooleanVariable boolVar; //tells others if it is playerTurn or not



    public void Enter()
    {
        BattleController.instance.voice.shareRecognitionEvent += BattleController.instance.TrySpellString;
        BattleController.instance.enemy.Die += EndBattleWin;
        boolVar = BattleController.instance.isPlayerTurn;

        BattleController.instance.battleText.text = BattleController.instance.player.name + "の番です!よく言ってね!";

        //Generate new forced spell
        BattleController.instance.mustBeCast = BattleController.instance.ChooseRandomSpell(BattleController.instance.player);
    }
Exemple #14
0
        public override void OnEnter()
        {
            if (key == "" ||
                variable == null)
            {
                Continue();
                return;
            }

            var flowchart = GetFlowchart();

            // Prepend the current save profile (if any)
            string prefsKey = SetSaveProfile.saveProfile + "_" + flowchart.SubstituteVariables(key);

            System.Type variableType = variable.GetType();

            if (variableType == typeof(BooleanVariable))
            {
                BooleanVariable booleanVariable = variable as BooleanVariable;
                if (booleanVariable != null)
                {
                    // PlayerPrefs does not have bool accessors, so just use int
                    booleanVariable.Value = (PlayerPrefs.GetInt(prefsKey) == 1);
                }
            }
            else if (variableType == typeof(IntegerVariable))
            {
                IntegerVariable integerVariable = variable as IntegerVariable;
                if (integerVariable != null)
                {
                    integerVariable.Value = PlayerPrefs.GetInt(prefsKey);
                }
            }
            else if (variableType == typeof(FloatVariable))
            {
                FloatVariable floatVariable = variable as FloatVariable;
                if (floatVariable != null)
                {
                    floatVariable.Value = PlayerPrefs.GetFloat(prefsKey);
                }
            }
            else if (variableType == typeof(StringVariable))
            {
                StringVariable stringVariable = variable as StringVariable;
                if (stringVariable != null)
                {
                    stringVariable.Value = PlayerPrefs.GetString(prefsKey);
                }
            }

            Continue();
        }
    /// <summary>Toggles a BooleanVariable.</summary>
    /// <param name="variable">The boolean variable.</param>
    public void ToggleBooleanVariable(BooleanVariable variable)
    {
        switch (variable)
        {
        case BooleanVariable.MusicEnabled:
            ToggleMusicEnabled();
            break;

        case BooleanVariable.SFXEnabled:
            ToggleSFXEnabled();
            break;
        }
    }
    /// <summary>Set a BooleanVariable to a given value.</summary>
    /// <param name="variable">The boolean variable.</param>
    /// <param name="value">The value to set.</param>
    public void SetBooleanVariable(BooleanVariable variable, bool value)
    {
        switch (variable)
        {
        case BooleanVariable.MusicEnabled:
            SetMusicEnabled(value);
            break;

        case BooleanVariable.SFXEnabled:
            SetSFXEnabled(value);
            break;
        }
    }
    /// <summary>Gets the value of a BooleanVariable.</summary>
    /// <param name="variable">The boolean variable.</param>
    public bool GetBooleanVariableValue(BooleanVariable variable)
    {
        switch (variable)
        {
        case BooleanVariable.MusicEnabled:
            return(musicEnabled);

        case BooleanVariable.SFXEnabled:
            return(sfxEnabled);

        default:
            Debug.LogErrorFormat("{0} is not cated for in the swich statement", variable); return(false);
        }
    }
Exemple #18
0
        public override void OnStepStart()
        {
            base.OnStepStart();

            originalControlsTriggerIsBlocked = toggleControlsHud.isTriggerBlocked;
            if (toggleControlsHud != null)
            {
                toggleControlsHud.isTriggerBlocked = null;
            }

            if (tutorialController != null && tutorialController.hudController != null)
            {
                tutorialController.hudController.controlsHud.OnControlsOpened += ControlsHud_OnControlsOpened;
                tutorialController.hudController.controlsHud.OnControlsClosed += ControlsHud_OnControlsClosed;
            }
        }
    private Spell toCast;             //chosen by AI

    public void Enter()
    {
        BattleController.instance.battleText.text = BattleController.instance.enemy.name + "は考えている。。。";
        BattleController.instance.player.animator.SetBool("Casting", false);

        BattleController.instance.player.Die += EndBattleLoss;
        boolVar = BattleController.instance.isPlayerTurn;

        toCast = BattleController.instance.ChooseRandomSpell(BattleController.instance.enemy);

        if (toCast == null)
        {
            Debug.Log("I didn't have any spells to cast, so you can have your turn back...");
        }

        BattleController.instance.StartCoroutine(BattleController.instance.CastAfterSeconds(enemyThinkTime, toCast)); //why is StartCoroutine a MonoBehaviour method.... :/
    }
Exemple #20
0
    //If a block is activated by the user, then this is not needed in the flowchart
    //Copies the variables in the list from the GM flowcharts to the activated flowchart
    public void CopyGameMasterToFlowchart()
    {
        gm = GameObject.Find("GameMaster").GetComponent <GameMaster>();
        Flowchart gmQuest = gm.GetQuestFlowchart();
        Flowchart target  = this.GetComponent <Flowchart>();

        Variable sourceVar = null;

        for (int i = 0; i < varNames.Length; i++)
        {
            sourceVar = gmQuest.GetVariable(varNames[i]);

            StringVariable tempstr = sourceVar as StringVariable;
            if (tempstr != null)
            {
                target.SetStringVariable(varNames[i], tempstr.Value);
                continue;
            }

            BooleanVariable tempBool = sourceVar as BooleanVariable;
            if (tempBool != null)
            {
                target.SetBooleanVariable(varNames[i], tempBool.Value);
                continue;
            }

            IntegerVariable tempInt = sourceVar as IntegerVariable;
            if (tempInt != null)
            {
                target.SetIntegerVariable(varNames[i], tempInt.Value);
                continue;
            }

            FloatVariable tempFloat = sourceVar as FloatVariable;
            if (tempFloat != null)
            {
                target.SetFloatVariable(varNames[i], tempFloat.Value);
                continue;
            }
        }
    }
Exemple #21
0
        public Settings()
        {
            if (qualitySettingsPreset == null)
            {
                qualitySettingsPreset = Resources.Load <SettingsData.QualitySettingsData>("ScriptableObjects/QualitySettingsData");
            }

            if (autoqualitySettings == null)
            {
                autoqualitySettings     = Resources.Load <SettingsData.QualitySettingsData>("ScriptableObjects/AutoQualitySettingsData");
                lastValidAutoqualitySet = autoqualitySettings[autoqualitySettings.Length / 2];
            }

            if (autosettingsEnabled == null)
            {
                autosettingsEnabled = Resources.Load <BooleanVariable>("ScriptableObjects/AutoQualityEnabled");
            }

            LoadQualitySettings();
            LoadGeneralSettings();
        }
        BooleanFunction FixVar(BooleanVariable variable, int value)
        {
            int res = 0;

            switch (variable)
            {
            case BooleanVariable.A:
                res = FixA(value);
                break;

            case BooleanVariable.B:
                res = FixB(value);
                break;

            case BooleanVariable.C:
                res = FixC(value);
                break;

            default:
                throw new ArgumentException("The variable argument for FixVar should be A, B or C");
            }

            return(new BooleanFunction((byte)res));
        }
 public VarExpression(BooleanVariable var, bool not = false)
 {
     Var = var;
 }
Exemple #24
0
 public void SetValue(BooleanVariable boolVariable)
 {
     Value = boolVariable.Value;
 }
        public static BooleanExpression FindMininalExpressionInBasis(int n, BooleanOperation[] ops,
			BooleanVariable[] vars, ExpressionSearchMode mode = ExpressionSearchMode.CountOps)
        {
            var queue = new ImprovisedPriorityQueue<BooleanExpression>(20);
            var knownTruthTables = new HashSet<byte>();
            var knownExpressions = new HashSet<BooleanExpression>();

            foreach(var variable in vars) {
                queue.TryEnqueue(new VarExpression(variable), 1);
            }

            while(queue.Count != 0) {
                var curExperession = queue.Dequeue();

                byte truthTable = curExperession.Eval();

                if(knownTruthTables.Contains(truthTable)) {
                    continue;
                }

                if(curExperession.Eval() == n) {
                    return curExperession;
                }

                knownExpressions.Add(curExperession);
                knownTruthTables.Add(truthTable);

                foreach(var anotherExpression in knownExpressions) {
                    foreach(var neighbourExpression in curExperession.CombineWith(anotherExpression, ops)) {
                        queue.TryEnqueue(neighbourExpression, mode == ExpressionSearchMode.CountBlocks
                            ? neighbourExpression.CountBlocks() : neighbourExpression.CountOps());
                    }
                }
            }

            throw new CouldntFindExpressionException();
        }
        BooleanFunction FixVar(BooleanVariable variable, int value)
        {
            int res = 0;

            switch(variable) {
            case BooleanVariable.A:
                res = FixA(value);
                break;
            case BooleanVariable.B:
                res = FixB(value);
                break;
            case BooleanVariable.C:
                res = FixC(value);
                break;
            default:
                throw new ArgumentException("The variable argument for FixVar should be A, B or C");
            }

            return new BooleanFunction((byte)res);
        }
 public OpExpression(BooleanOperation op, BooleanVariable left, BooleanVariable right)
 {
     Op = op;
     Left = new VarExpression(left);
     Right = new VarExpression(right);
 }
 public void SetBool(BooleanVariable state)
 {
     State = state.State;
 }
Exemple #29
0
        protected virtual void DoSetOperation()
        {
            if (variable == null)
            {
                return;
            }

            if (variable.GetType() == typeof(BooleanVariable))
            {
                BooleanVariable lhs = (variable as BooleanVariable);
                bool            rhs = booleanData.Value;

                switch (setOperator)
                {
                default:
                case SetOperator.Assign:
                    lhs.Value = rhs;
                    break;

                case SetOperator.Negate:
                    lhs.Value = !rhs;
                    break;
                }
            }
            else if (variable.GetType() == typeof(IntegerVariable))
            {
                IntegerVariable lhs = (variable as IntegerVariable);
                int             rhs = integerData.Value;

                switch (setOperator)
                {
                default:
                case SetOperator.Assign:
                    lhs.Value = rhs;
                    break;

                case SetOperator.Add:
                    lhs.Value += rhs;
                    break;

                case SetOperator.Subtract:
                    lhs.Value -= rhs;
                    break;

                case SetOperator.Multiply:
                    lhs.Value *= rhs;
                    break;

                case SetOperator.Divide:
                    lhs.Value /= rhs;
                    break;
                }
            }
            else if (variable.GetType() == typeof(FloatVariable))
            {
                FloatVariable lhs = (variable as FloatVariable);
                float         rhs = floatData.Value;

                switch (setOperator)
                {
                default:
                case SetOperator.Assign:
                    lhs.Value = rhs;
                    break;

                case SetOperator.Add:
                    lhs.Value += rhs;
                    break;

                case SetOperator.Subtract:
                    lhs.Value -= rhs;
                    break;

                case SetOperator.Multiply:
                    lhs.Value *= rhs;
                    break;

                case SetOperator.Divide:
                    lhs.Value /= rhs;
                    break;
                }
            }
            else if (variable.GetType() == typeof(StringVariable))
            {
                StringVariable lhs = (variable as StringVariable);
                string         rhs = stringData.Value;

                switch (setOperator)
                {
                default:
                case SetOperator.Assign:
                    lhs.Value = rhs;
                    break;
                }
            }
        }
 public OpExpression(BooleanOperation op, BooleanVariable left, BooleanVariable right)
 {
     Op    = op;
     Left  = new VarExpression(left);
     Right = new VarExpression(right);
 }
Exemple #31
0
        public void BooleanVariableInitialFalseValueTest()
        {
            var variable = new BooleanVariable(false);

            Assert.IsFalse(variable.Value);
        }
Exemple #32
0
        public void BooleanVariableInitialTrueValueTest()
        {
            var variable = new BooleanVariable(true);

            Assert.IsTrue(variable.Value);
        }
Exemple #33
0
        public void BooleanVariableDefaultValueTest()
        {
            var variable = new BooleanVariable();

            Assert.IsFalse(variable.Value);
        }
 public VarExpression(BooleanVariable var, bool not = false)
 {
     Var = var;
 }