/// <inheritdoc />
public override void VisitFloatValue(FloatValue value)
{
switch (operation)
{
case Operations.Mod:
// When dividend is true and divisor != +-1, result is 1, otherwise 0
result = ModuloOperation.LeftAbstractBooleanModulo(flow, value.Value);
break;
default:
var rightBoolean = TypeConversion.ToBoolean(value.Value);
result = Comparison.LeftAbstractBooleanCompare(OutSet, operation, rightBoolean);
if (result != null)
{
break;
}
result = ArithmeticOperation.LeftAbstractBooleanArithmetic(flow, operation, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation, rightBoolean);
if (result != null)
{
break;
}
base.VisitFloatValue(value);
break;
}
}
// Update is called once per frame
private void Update()
{
if (isStunned)
{
if (stunTimer < 0)
{
stunTimer = 3f;
agent.speed = 3.5f;
isStunned = false;
TakeDamage(2);
}
else
{
stunTimer -= Time.deltaTime;
agent.speed = 0;
}
}
else
{
//FloatValue.
AISelector.OnUpdate();
}
if (Input.GetKeyDown(KeyCode.Space))
{
TakeDamage(1);
}
FloatValue distance = BlackBoard.GetFloatVariableValue(VariableType.Distance);
FloatValue hp = BlackBoard.GetFloatVariableValue(VariableType.Health);
hp.Value = health;
distance.Value = (Player.playerLocation - transform.position).magnitude;
agent.SetDestination(targetPosition); //Deze werkt pas als de behaviours werken.
}
public SliderWrapper(Slider s, FloatValue v, FloatValue m, FloatValue mx)
{
slider = s;
value = v;
min = m;
max = mx;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JToken jFeatureValue = JToken.Load(reader);
JToken jValue = jFeatureValue["Value"];
Value featureValue = null;
// Depending on the type of the member "Value" a different subclass of Feature.Value is created.
if (jValue.Type == JTokenType.Float)
{
featureValue = new FloatValue()
{
Value = jValue.ToObject <double> (),
};
}
else if (jValue.Type == JTokenType.Integer)
{
featureValue = new IntValue()
{
Value = jValue.ToObject <Int64> (),
};
}
else /*if (jValue.Type == JTokenType.String)*/
{
featureValue = new StringValue()
{
Value = jValue.ToObject <String> (),
};
}
// The members Name and Unit are the same for all subclasses.
featureValue.Name = jFeatureValue["Name"].ToObject <String> ();
featureValue.Unit = jFeatureValue["Unit"]?.ToObject <String> (); // Unit may be null
return(featureValue);
}
public ZCPFModel(FloatValue _InputValue1, FloatValue _InputValue2, FloatValue _InputValue3, BitValue _OutputValue)
{
InputValue1 = _InputValue1;
InputValue2 = _InputValue2;
InputValue3 = _InputValue3;
OutputValue = _OutputValue;
}
/// <inheritdoc />
public override void VisitFloatValue(FloatValue value)
{
switch (operation)
{
case Operations.Mod:
SetWarning("Object cannot be converted to integer by modulo operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = ModuloOperation.AbstractModulo(flow, value.Value);
break;
default:
result = ArithmeticOperation.LeftAbstractArithmetic(flow, operation, value.Value);
if (result != null)
{
SetWarning("Object cannot be converted to integer by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), TypeConversion.ToBoolean(value.Value));
if (result != null)
{
break;
}
base.VisitFloatValue(value);
break;
}
}
// Start is called before the first frame update
void Start()
{
//gameSpeed = 1f;
isPaused = false;
gm = GameObject.FindWithTag("GameManager");
gameSpeed = gm.GetComponent <GameManager>().GameSpeed;
}
/// <inheritdoc />
public override void VisitFloatValue(FloatValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow, value.Value);
break;
default:
result = ArithmeticOperation.LeftAbstractArithmetic(flow, operation, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), TypeConversion.ToBoolean(value.Value));
if (result != null)
{
break;
}
base.VisitFloatValue(value);
break;
}
}
private static Constant Pow(List <Constant> args)
{
FloatValue x = args[0] as FloatValue;
FloatValue y = args[1] as FloatValue;
return(new FloatValue(Math.Pow(x.Value, y.Value)));
}
private static Constant Complex(List <Constant> args)
{
FloatValue re = args[0] as FloatValue;
FloatValue im = args[1] as FloatValue;
return(new ComplexValue(re.Value, im.Value));
}
private static Constant ComplexExp(List <Constant> args)
{
FloatValue magn = args[0] as FloatValue;
FloatValue arg = args[1] as FloatValue;
return(ComplexValue.FromExp(magn.Value, arg.Value));
}
private static Object ParseNumber(IRuleNode number, int factor)
{
var tokenType = GetSingleChildTokenType(number);
if (tokenType == EsperEPL2GrammarLexer.IntegerLiteral)
{
return(ParseIntLongByte(number.GetText(), factor));
}
else if (tokenType == EsperEPL2GrammarLexer.FloatingPointLiteral)
{
var numberText = number.GetText();
if (numberText.EndsWith("m"))
{
return(DecimalValue.ParseString(number.GetText()) * factor);
}
else if (numberText.EndsWith("f") || numberText.EndsWith("F"))
{
return(FloatValue.ParseString(number.GetText()) * factor);
}
else
{
return(DoubleValue.ParseString(number.GetText()) * factor);
}
}
throw ASTWalkException.From("Encountered unrecognized constant", number.GetText());
}
void InitializePanels()
{
foreach (var panel in panelPool)
{
panel.Pooled = true;
panel.gameObject.SetActive(false);
}
foreach (var coord in map.Grids())
{
Vector3 position = new Vector3(coord.x, 0, coord.y);
FloatValue value = map.GetValue(coord);
float v = (value == null) ? 0.5f : value.v + 0.5f;
Color color = new Color(v, 0, 0);
string text = v.ToString();
if (text.Length > 4)
{
text = text.Substring(0, 4);
}
Poolable panel = panelPool.Unpool();
panel.gameObject.SetActive(true);
panel.transform.position = position;
panel.GetComponent <Renderer>().material.color = color;
panel.GetComponentInChildren <TextMesh>().text = text;
}
}
protected override void Execute(CodeActivityContext executionContext)
{
var error = false;
try
{
var value = Convert.ToDouble(Value.Get <string>(executionContext));
FloatValue.Set(executionContext, value);
DecimalValue.Set(executionContext, Convert.ToDecimal(Math.Round(value, 2)));
MoneyValue.Set(executionContext, new Money {
Value = Convert.ToDecimal(Math.Round(value, 2))
});
TruncatedValue.Set(executionContext, Convert.ToInt32(Math.Truncate(value)));
RoundedValue.Set(executionContext, Convert.ToInt32(Math.Round(value, 0)));
}
catch
{
error = true;
}
ProcessingError.Set(executionContext, error);
}
void Update()
{
FloatValue distance = BlackBoard.GetFloatVariableValue(VariableType.Distance);
AISelector.OnUpdate();
agent.SetDestination(targetPosition);
}
internal static SliderWrapper IntSlider(FloatValue value, FloatValue min, FloatValue max, UnityAction <float, SliderWrapper> onSliderValueChanged)
{
var s = Slider(value, min, max, onSliderValueChanged);
s.slider.wholeNumbers = true;
return(s);
}
/// <inheritdoc />
public override void VisitFloatValue(FloatValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
case Operations.Mod:
result = ModuloOperation.Modulo(flow, leftOperand, value.Value);
break;
default:
result = Comparison.IntervalCompare(OutSet, operation,
TypeConversion.ToFloatInterval(OutSet, leftOperand), value.Value);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand, value.Value);
if (result != null)
{
break;
}
base.VisitFloatValue(value);
break;
}
}
public override int GetHashCode()
{
int hash = 1;
if (kindCase_ == KindOneofCase.StringValue)
{
hash ^= StringValue.GetHashCode();
}
if (kindCase_ == KindOneofCase.FloatValue)
{
hash ^= FloatValue.GetHashCode();
}
if (kindCase_ == KindOneofCase.DoubleValue)
{
hash ^= DoubleValue.GetHashCode();
}
if (kindCase_ == KindOneofCase.IntValue)
{
hash ^= IntValue.GetHashCode();
}
if (kindCase_ == KindOneofCase.UintValue)
{
hash ^= UintValue.GetHashCode();
}
if (kindCase_ == KindOneofCase.SintValue)
{
hash ^= SintValue.GetHashCode();
}
if (kindCase_ == KindOneofCase.BoolValue)
{
hash ^= BoolValue.GetHashCode();
}
hash ^= (int)kindCase_;
return(hash);
}
/// <summary>
/// Sets the value of one variable.
/// </summary>
/// <param name="name">The name of the variable to set.</param>
/// <param name="value">The value of the variable to use.</param>
public void SetVar(string name, object @object)
{
if (@object is bool)
{
vars[name] = new BoolValue((bool)@object);
}
else if (@object is int)
{
vars[name] = new IntValue((int)@object);
}
else if (@object is float)
{
vars[name] = new FloatValue((float)@object);
}
else if (@object is string)
{
vars[name] = new StringValue((string)@object);
}
else
{
vars[name] = new ObjectValue(@object);
}
if (OnSet != null)
{
OnSet(name, vars[name]);
}
}
public void Deserialize(string content)
{
var floatValues = content.Trim().Split(';');
Latitude = ObjectSerializer.Deserialize <FloatValue>(floatValues[0]);
Longitude = ObjectSerializer.Deserialize <FloatValue>(floatValues[1]);
}
public async Task<SerializableValue> Execute(PluginExecuteContext context) {
var parameters = new Dictionary<string, SerializableValue>();
string effectName = null;
var duration = 0.0F;
var easingType = EasingType.Linear;
foreach (var (key, value) in context.StringParameters) {
var name = key.ConvertToString(context.Language);
switch (name) {
case "Type":
effectName = StringValue.TryParse(value, context.Language);
break;
case "Duration":
duration = FloatValue.TryParse(value, context.Language);
break;
case "Easing": {
var easingName = StringValue.TryParse(value, context.Language);
if (!Enum.TryParse<EasingType>(easingName, true, out var easing)) {
throw new NotSupportedException($"Unable to create effect: ease type {easingName} is not supported");
}
easingType = easing;
break;
}
default:
parameters.Add(name, value);
break;
}
}
if (string.IsNullOrEmpty(effectName)) throw new NotSupportedException("Unable to create effect: missing effect type");
if (duration.Equals(0.0F)) throw new NotSupportedException("Unable to create effect: missing duration or duration less than/equals to 0");
var effect = Create(effectName, parameters, duration, easingType);
if (effect == null) throw new KeyNotFoundException($"Unable to create effect: expected effect name {effectName} not existed");
await effect.Initialize();
var result = new EffectValue(effectName, effect);
return result;
}
/// <inheritdoc />
public override void VisitFloatValue(FloatValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.Modulo(flow,
TypeConversion.ToNativeInteger(Snapshot, leftOperand), value.Value);
break;
default:
var leftBoolean = TypeConversion.ToNativeBoolean(Snapshot, leftOperand);
var rightBoolean = TypeConversion.ToBoolean(value.Value);
result = LogicalOperation.Logical(OutSet, operation, leftBoolean, rightBoolean);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation,
TypeConversion.ToNativeInteger(Snapshot, leftOperand), value.Value);
if (result == null)
{
base.VisitFloatValue(value);
}
break;
}
}
/// <summary>
/// Overriden. Returns a hash code for the current Object.
/// </summary>
/// <returns>A hash code for the current Object.</returns>
public override int GetHashCode()
{
switch (ValueType)
{
case ValueTypeDefinitionData.Reference:
return(ReferenceValue.GetHashCode());
case ValueTypeDefinitionData.DateTime:
return(DateTimeValue.GetHashCode());
case ValueTypeDefinitionData.Bool:
return(BoolValue.GetHashCode());
case ValueTypeDefinitionData.Float:
return(FloatValue.GetHashCode());
case ValueTypeDefinitionData.Int:
return(IntValue.GetHashCode());
case ValueTypeDefinitionData.StringNonUnicode:
return(StringNonUnicodeValue.GetHashCode());
default:
return(base.GetHashCode());
}
}
// Start is called before the first frame update
void Start()
{
Player = GameObject.FindGameObjectWithTag("Player").GetComponent <Player>();
ItemName = Name;
ItemDescription = Description;
PlayerHpFloatValue = Player.currentHealth;
PlayerHpFloatValue.RuntimeValue -= 3;
}
// Start is called before the first frame update
void Start()
{
Player = GameObject.FindGameObjectWithTag("Player").GetComponent <Player>();
ItemName = Name;
ItemDescription = Description;
PlayerHpFloatValue = Player.currentHealth;
DontDestroyOnLoad(gameObject);
}
static FloatValue PowerUpTimeObjCache = null; // object cache
public static FloatValue PowerUpTimeAsset()
{
if (PowerUpTimeObjCache == null)
{
PowerUpTimeObjCache = Resources.Load <FloatValue>("PowerUpTime");
}
return(PowerUpTimeObjCache);
} // end method PowerUpTimeAsset
private void TakeDamage(FloatValue damage)
{
Health -= damage.InitialValue;
if (Health <= 0)
{
this.gameObject.SetActive(false);
}
}
void SetHealthUI(FloatValue _float)
{
m_TextMesh.text = ((int)(m_HealthValue.GetRatio() * 100)).ToString();
if (m_HealthValue.GetRatio() <= 0.0f)
{
m_TextMesh.gameObject.SetActive(false);
}
}
private object ReadParameter(BitStream s, ParameterDefinition paramDefinition)
{
IParameter param = null;
switch (paramDefinition.ParameterType)
{
case ParameterType.Float: { param = new FloatValue(); } break;
case ParameterType.EntityFilter: { param = new EntityFilter(); } break;
case ParameterType.GenericReference: { param = new GenericReference(); } break;
case ParameterType.IntegerReference: { param = new IntegerReference(); } break;
case ParameterType.Meter: { param = new MeterData(); } break;
case ParameterType.ObjectReference: { param = new ObjectReference(); } break;
case ParameterType.PlayerReference: { param = new PlayerReference(); } break;
case ParameterType.Shape: { param = new BoundaryData(); } break;
case ParameterType.StringReference: { param = new StringReference(); } break;
case ParameterType.StringReferenceOneToken: { param = new StringReferenceOneToken(); } break;
case ParameterType.StringReferenceTwoTokens: { param = new StringReferenceTwoTokens(); } break;
case ParameterType.StringReferenceThreeTokens: { param = new StringReferenceThreeTokens(); } break;
case ParameterType.TargetReference: { param = new TargetReference(); } break;
case ParameterType.TeamReference: { param = new TeamReference(); } break;
case ParameterType.TimerReference: { param = new TimerReference(); } break;
case ParameterType.VirtualTrigger: { param = new VirtualTrigger(); } break;
case ParameterType.WaypointIcon: { param = new WaypointIconData(); } break;
case ParameterType.Coordinates3d: { param = new Coordinates3d(); } break;
case ParameterType.Boolean:
return(s.Reader.ReadBit());
default:
object value = 0;
StreamIntegerValue(s, paramDefinition, ref value);
return(value);
}
if (param != null)
{
param.SerializeObject(s, paramDefinition);
}
return(param);
}
public void prints_float_value()
{
double value = 3.33;
var val = new FloatValue(value);
var result = _printer.Visit(val);
result.ShouldBe(value.ToString("0.0##", NumberFormatInfo.InvariantInfo));
}
//Получения значения из строкового представления
public Value GetValueFromString(string part, string type)
{
ConverteType converteType = GetConverteType(type); //Преобразование строки типа в элемент обрабатываемого типа
//Выбор создания значения в зависимости от типа
try
{
switch (converteType)
{
case ConverteType.String: //Создание значения типа string
var stringValue = new Value<string>();
stringValue.OriginalValue = part; //Получение значения
return stringValue;
case ConverteType.Date: //Создание значения типа Datetime
var dateValue = new DateTimeValue();
dateValue.OriginalValue = DateTime.Parse(part); //Преобразование строкового значения в тип Datetime
return dateValue;
case ConverteType.Integer: //Создание значения типа Int32
var integerValue = new Value<int>();
integerValue.OriginalValue = Int32.Parse(part); //Преобразование строкового значения в тип Int32
return integerValue;
case ConverteType.Float: //Создание значения типа Float
var floatValue = new FloatValue();
floatValue.OriginalValue = float.Parse(part.Replace(',', '.')); //Преобразовани значения в тип Float
return floatValue;
default: //Switch должен вернуть значение
Debug.Fail(String.Format("Illegal value {0}", converteType));
Environment.FailFast(null);
return new Value<string>();
}
}
catch
{
Console.WriteLine("Невозможно преобразовать значение {0} в тип {1}", part, type);
Console.ReadKey();
Environment.Exit(1);
}
return new Value<string>(); //Метод должен вернуть значение
}
public FloatRange2(float value = 0f, float minBase = 0f, float maxBase = 0f) {
modifiers = new List<FloatModifier>();
min = new FloatRangeBoundry(this, minBase);
max = new FloatRangeBoundry(this, maxBase);
}
//Генерация случайного значения для всех ячеек, кроме ячеек заголовка
public Value GetRandomValue(int cellIndex)
{
var type = randomTypeList[cellIndex]; //Получения типа из листа случайных типов
//Создание значения соответствующего типа
switch (type)
{
case ConverteType.String: //Создание значения типа String
var stringValue = new Value<string>();
stringValue.OriginalValue = GetRandomString(); //Получение случайного значения string
return stringValue;
case ConverteType.Date: //Создание значения типа Date
var dateValue = new DateTimeValue();
dateValue.OriginalValue = GetRandomDate(); //Получение случайного значения Datetime
return dateValue;
case ConverteType.Integer: //Создание значения типа Integer
var integerValue = new Value<int>();
integerValue.OriginalValue = GetRandomInt(); //Получение случайной значения Integer
return integerValue;
case ConverteType.Float: //Создание значения типа Float
var floatValue = new FloatValue();
floatValue.OriginalValue = GetRandomFloat(); //Получение случайной значения Float
return floatValue;
default: //Switch должен вернуть значение
Debug.Fail(String.Format("Illegal value {0}", type));
Environment.FailFast(null);
return new Value<string>();
}
}
