private GameObject CreateDefaultValue(ref IValue value, ValueType type) { ActiveLabel variableLabel = CreateActiveLabel(); variableLabel.ValueType = type; switch (variableLabel.ValueType) { case ValueType.Bool: { value = new BoolConstant(); } break; case ValueType.Number: { value = new FloatConstant(); } break; default: Debug.Log("ActiveLabelType is operation but Expression is null!"); break; } variableLabel.Value = value; return(variableLabel.gameObject); }
public static StatAttribute Create(float baseValue, string attributeType) { var baseValueF = FloatConstant.Create(baseValue); var type = AttributeType.Create(attributeType); return(Create(baseValueF, attributeType: type)); }
public void TestFloat() { var f = new FloatConstant(123.34); var res = Util.FloatConstant.Compile(f); HasValue(res, f.Value); }
public static void CompileFloat(ParserContext parser, ByteBuffer buffer, FloatConstant floatConstant, bool outputUsed) { if (!outputUsed) { throw new ParserException(floatConstant, "This expression doesn't do anything."); } buffer.Add(floatConstant.FirstToken, OpCode.LITERAL, parser.GetFloatConstant(floatConstant.Value)); }
private ExpressionNode ParseFactor() { ExpressionNode x; if (_reader.Peek() is LeftParen) { Match <LeftParen>(); x = ParseExpression(); Match <RightParen>(); return(x); } if (_reader.Peek() is IntegerLiteral) { var token = Match <IntegerLiteral>(); x = new IntegerConstant(token.Value); return(x); } if (_reader.Peek() is FloatLiteral) { var token = Match <FloatLiteral>(); x = new FloatConstant(token.Value); return(x); } if (_reader.Peek() is StringLiteral) { var token = Match <StringLiteral>(); x = new StringConstant(token.Value); return(x); } if (_reader.Peek() is True) { Match <True>(); x = BoolConstant.True; return(x); } if (_reader.Peek() is False) { Match <False>(); x = BoolConstant.False; return(x); } if (_reader.Peek() is Identifier) { var token = Match <Identifier>(); x = new IdentifierNode(token); return(x); } throw new Exception("syntax error"); }
private void Start() { if (weightAttributeType == null) { weightAttributeType = AttributeType.Create("Weight"); } weightModifier = ScriptableObject.CreateInstance <StatModifier>(); weightModifier.value = FloatConstant.Create(weigth); weightModifier.modifierType = StatModifierType.AdditiveAbsolute; weightModifier.attributeType = weightAttributeType; }
// Use this for initialization void Awake() { FloatConstant tempCurrentHealth = ScriptableObject.CreateInstance <FloatConstant>(); tempCurrentHealth.FloatValue = manager.currentHealth.FloatValue; manager = ScriptableObject.CreateInstance <HealthManager>(); manager.currentHealth = tempCurrentHealth; healthUI.healthManager = manager; manager.healthAtZero += HealthAtZeroHandler; manager.healthUpdate += HealthUpdateHandler; foreach (var hurtbox in hurtboxes) { hurtbox.healthManager = manager; } }
protected override void Start() { base.Start(); team = StatAttribute.Create(1f, "Team"); maxHealth = StatAttribute.Create(10f, "MaxHealth"); health = FloatVariable.Create(FloatConstant.Create(maxHealth.Value), FloatConstant.Create(0), maxHealth, AttributeType.Create("Health")); armor = StatAttribute.Create(10f, "Armor"); speed = StatAttribute.Create(3f, "Speed"); sneakMultiplier = 0.7f; runMultiplier = 2f; jumpPower = 450f; weight = StatAttribute.Create(0, "Weight"); maxWeight = StatAttribute.Create(0, "MaxWeight"); slotCapacity = -1; }
protected abstract void TranslateFloatConstant(List <string> output, FloatConstant floatConstant);
public void SetValueFromDialog(ValueUI valueUI, IValue value) { SetValueDialog setDialog = Instantiate(_resourceProvider.SetValueDialog, _dialogLayer); string inputValue = "0"; bool isNumber = true; INumber number = value as INumber; if (number != null) { inputValue = number.Value.ToString(); } IBoolean boolean = value as IBoolean; if (boolean != null) { inputValue = boolean.IsTrue ? "1" : "0"; isNumber = false; } setDialog.Init("Set Constant", inputValue); setDialog.OnOk.AddListener( (valueString) => { if (isNumber) { if (float.TryParse(valueString, out float floatValue)) { FloatConstant constant = number as FloatConstant; if (constant != null) { number.Value = floatValue; } else { constant = new FloatConstant(); constant.Value = floatValue; _cursorTool.SetLabelTarget.Value = constant; if (_cursorTool.SetLabelTarget.Value.Parent == null) { _cursorTool.SetLabelValueUi.Value = _cursorTool.SetLabelTarget.Value; } } } } else { if (float.TryParse(valueString, out float floatValue)) { BoolConstant constant = boolean as BoolConstant; if (constant != null) { boolean.IsTrue = floatValue != 0; } else { constant = new BoolConstant(); constant.IsTrue = floatValue != 0; _cursorTool.SetLabelTarget.Value = constant; if (_cursorTool.SetLabelTarget.Value.Parent == null) { _cursorTool.SetLabelValueUi.Value = _cursorTool.SetLabelTarget.Value; } } } } valueUI.RebuildAnValue(); }); }
public FloatConstant makeFloatConstantNode(double value) { FloatConstant node = new FloatConstant(value); return(node); }
private static Expression ParseEntityWithoutSuffixChain(TokenStream tokens, Executable owner) { string next = tokens.PeekValue(); if (next == "null") { return(new NullConstant(tokens.Pop(), owner)); } if (next == "true") { return(new BooleanConstant(tokens.Pop(), true, owner)); } if (next == "false") { return(new BooleanConstant(tokens.Pop(), false, owner)); } Token peekToken = tokens.Peek(); if (next.StartsWith("'")) { return(new StringConstant(tokens.Pop(), StringConstant.ParseOutRawValue(peekToken), owner)); } if (next.StartsWith("\"")) { return(new StringConstant(tokens.Pop(), StringConstant.ParseOutRawValue(peekToken), owner)); } if (next == "new") { return(ParseInstantiate(tokens, owner)); } char firstChar = next[0]; if (VARIABLE_STARTER.Contains(firstChar)) { Token varToken = tokens.Pop(); return(new Variable(varToken, varToken.Value, owner)); } if (firstChar == '[') { Token bracketToken = tokens.PopExpected("["); List <Expression> elements = new List <Expression>(); bool previousHasCommaOrFirst = true; while (!tokens.PopIfPresent("]")) { if (!previousHasCommaOrFirst) { tokens.PopExpected("]"); // throws appropriate error } elements.Add(Parse(tokens, owner)); previousHasCommaOrFirst = tokens.PopIfPresent(","); } return(new ListDefinition(bracketToken, elements, owner)); } if (firstChar == '{') { Token braceToken = tokens.PopExpected("{"); List <Expression> keys = new List <Expression>(); List <Expression> values = new List <Expression>(); bool previousHasCommaOrFirst = true; while (!tokens.PopIfPresent("}")) { if (!previousHasCommaOrFirst) { tokens.PopExpected("}"); // throws appropriate error } keys.Add(Parse(tokens, owner)); tokens.PopExpected(":"); values.Add(Parse(tokens, owner)); previousHasCommaOrFirst = tokens.PopIfPresent(","); } return(new DictionaryDefinition(braceToken, keys, values, owner)); } if (next.Length > 2 && next.Substring(0, 2) == "0x") { Token intToken = tokens.Pop(); int intValue = IntegerConstant.ParseIntConstant(intToken, intToken.Value); return(new IntegerConstant(intToken, intValue, owner)); } if (Parser.IsInteger(next)) { Token numberToken = tokens.Pop(); string numberValue = numberToken.Value; if (tokens.IsNext(".")) { Token decimalToken = tokens.Pop(); if (decimalToken.HasWhitespacePrefix) { throw new ParserException(decimalToken, "Decimals cannot have whitespace before them."); } Token afterDecimal = tokens.Pop(); if (afterDecimal.HasWhitespacePrefix) { throw new ParserException(afterDecimal, "Cannot have whitespace after the decimal."); } if (!Parser.IsInteger(afterDecimal.Value)) { throw new ParserException(afterDecimal, "Decimal must be followed by an integer."); } numberValue += "." + afterDecimal.Value; double floatValue = FloatConstant.ParseValue(numberToken, numberValue); return(new FloatConstant(numberToken, floatValue, owner)); } int intValue = IntegerConstant.ParseIntConstant(numberToken, numberToken.Value); return(new IntegerConstant(numberToken, intValue, owner)); } if (tokens.IsNext(".")) { Token dotToken = tokens.PopExpected("."); string numberValue = "0."; Token postDecimal = tokens.Pop(); if (postDecimal.HasWhitespacePrefix || !Parser.IsInteger(postDecimal.Value)) { throw new ParserException(dotToken, "Unexpected dot."); } numberValue += postDecimal.Value; double floatValue; if (double.TryParse(numberValue, out floatValue)) { return(new FloatConstant(dotToken, floatValue, owner)); } throw new ParserException(dotToken, "Invalid float literal."); } throw new ParserException(tokens.Peek(), "Encountered unexpected token: '" + tokens.PeekValue() + "'"); }
protected override void TranslateFloatConstant(List <string> output, FloatConstant floatConstant) { output.Add(Util.FloatToString(floatConstant.Value)); }