private OperationResult ParseVariable()
        {
            if (Const.Digits.Contains(LastCharacter) || Regex.IsMatch(LastCharacter.ToString(), "[a-z]") || LastCharacter == Const.RightParenthesis)
            {
                _operationStack.Push(new BinaryOperationToken {
                    Value = "*"
                });
                if (_parenthesesStack.Count >= 1)
                {
                    _parenthesesStack.Push('*');
                }
            }

            LastCharacter = Input[Pointer];
            var token = new VariableToken(1, new List <Variable> {
                new Variable {
                    Letter = Input[Pointer], Exponent = 1
                }
            });

            if (NegateFlag && _parenthesesStack.Count == 0)
            {
                token.Negate();
                NegateFlag = false;
            }

            _expressionStack.Push(token);
            return(ParseAndSimplify());
        }
        private OperationResult ParseParentheses()
        {
            if (Input[Pointer] == Const.LeftParenthesis)
            {
                if (Const.Digits.Contains(LastCharacter) || Regex.IsMatch(LastCharacter.ToString(), "[a-z]") || LastCharacter == Const.RightParenthesis)
                {
                    _operationStack.Push(new BinaryOperationToken {
                        Value = "*"
                    });
                }

                _parenthesesStack.Push(Input[Pointer]);

                LastCharacter = Input[Pointer];

                return(ParseAndSimplify());
            }
            else if (Input[Pointer] == Const.RightParenthesis)
            {
                _parenthesesStack.Push(Input[Pointer]);

                if (UnwindLastParentheses(out string errorMessage))
                {
                    return(ParseAndSimplify());
                }
                else
                {
                    return(OperationResult.CreateFailure(errorMessage));
                }
            }
            else
            {
                throw new Exception("Wrong parenthesis token. Check Const class.");
            }
        }
示例#3
0
            // Overrides
            public override void OnActivate()
            {
                // Cache
                float differenceY = m_item.transform.position.y - LastCharacter.transform.position.y;
                bool  isStanding  = differenceY >= STANDING_TAKE_MIN_HEIGHT;

                Character.SpellCastType animation = isStanding ? Character.SpellCastType.UseUp : Character.SpellCastType.PickupGround;

                // Execute
                if (!LastCharacter.Sheathed)
                {
                    LastCharacter.SheatheInput();
                }
                this.ExecuteOnceWhen(() => !LastCharacter.Sheathing, () =>
                {
                    // Sending SpellCast message to null to override default behaviour
                    // (will raise a few log messages, but no errors)
                    LastCharacter.CastSpell(animation, (GameObject)null, Character.SpellCastModifier.Immobilized, 1, -1f);
                    this.ExecuteOnceAfterDelay(ANIMATED_TAKE_DELAY, () =>
                    {
                        m_item.SetBeingTaken(true, RightHandTransform);
                        this.ExecuteOnceWhen(() => LastCharacter.CurrentSpellCast == Character.SpellCastType.NONE, () =>
                        {
                            TryTake(m_item, false);
                            base.OnActivate();
                        });
                    });
                });
            }
示例#4
0
        public void ModifyLast_StringInput_ReturnStringWithLastCharacterRepeated(string str, int n, string expected)
        {
            var actual = LastCharacter.ModifyLast(str, n);

            Assert.Equal(expected, actual);
        }