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));
}
