protected override BitwiseStream InternalValueToBitStream()
{
if (mutationFlags.HasFlag(MutateOverride.TypeTransform) && MutatedValue != null)
{
return((BitStream)MutatedValue);
}
if (InternalValue.GetVariantType() == Variant.VariantType.BitStream)
{
return((BitwiseStream)InternalValue);
}
var str = TryFormatNumber(InternalValue);
var buf = encoding.GetRawBytes(str);
var bs = new BitStream();
bs.Write(buf, 0, buf.Length);
if (!_hasLength && nullTerminated)
{
buf = encoding.GetRawBytes("\0");
bs.Write(buf, 0, buf.Length);
}
bs.SeekBits(0, System.IO.SeekOrigin.Begin);
return(bs);
}
/// <summary>
/// Implementation of IComparable
/// </summary>
/// <param name="obj">The other object to compare with.</param>
/// <returns>The result of the comparison</returns>
public override int CompareTo(object obj)
{
if (obj is DateValue)
{
return(ToDateTime().CompareTo(((DateValue)obj).ToDateTime()));
}
else if (obj is DateTimeValue)
{
return(ToDateTime().CompareTo(((DateTimeValue)obj).ToDateTime()));
}
else if (obj is DateTime)
{
return(ToDateTime().CompareTo((DateTime)obj));
}
else
{
DateTime otherDate;
if (DateTime.TryParse(obj.ToString(), out otherDate))
{
return(ToDateTime().CompareTo(otherDate));
}
else
{
return(InternalValue.CompareTo(obj.ToString()));
}
}
}
public override string ToString()
{
if (InternalValue == null)
{
return("<null>");
}
return(InternalValue.ToString());
}
public virtual bool TrySetValue(TemplateContext context, SourceSpan span, string member, object value, bool readOnly)
{
if (!CanWrite(member))
{
return(false);
}
this.AssertNotReadOnly();
Store[member] = new InternalValue(value, readOnly);
return(true);
}
public override string ToString()
{
if (Type != GlobalVariableType.None)
{
return(string.Format("{0}{1}", Value, Type));
}
else
{
return(InternalValue.ToString());
}
}
public void Set(String key, String value)
{
if (!InternalValue.ContainsKey(key))
{
InternalValue.Add(LowerCaseKeyIfCaseInsensitive(key), value);
}
else
{
InternalValue[LowerCaseKeyIfCaseInsensitive(key)] = value;
}
}
private String ObtainUniqueKey(String key)
{
String lookupKey = LowerCaseKeyIfCaseInsensitive(key);
Int32 occ = 0;
while (InternalValue.ContainsKey(lookupKey))
{
occ++;
lookupKey = "{0} [{1}]".FormatX(key, occ);
}
return(lookupKey);
}
/// <summary>
/// Implementation of IComparable
/// </summary>
/// <param name="obj">The other object to compare with.</param>
/// <returns>The result of the comparison</returns>
public override int CompareTo(object obj)
{
if (obj is IntegerNumberValue)
{
return(integerValue.CompareTo(((IntegerNumberValue)obj).integerValue));
}
else if (obj is int)
{
return(integerValue.CompareTo((int)obj));
}
else
{
long otherInt;
if (long.TryParse(obj.ToString(), out otherInt))
{
return(integerValue.CompareTo(otherInt));
}
else
{
return(InternalValue.CompareTo(obj.ToString()));
}
}
}
/// <summary>
/// Implementation of IComparable
/// </summary>
/// <param name="obj">The other object to compare with.</param>
/// <returns>The result of the comparison</returns>
public override int CompareTo(object obj)
{
if (obj is FloatNumberValue)
{
return(floatValue.CompareTo(((FloatNumberValue)obj).floatValue));
}
else if (obj is int)
{
return(floatValue.CompareTo((double)obj));
}
else
{
double otherFloat;
if (double.TryParse(obj.ToString(), out otherFloat))
{
return(floatValue.CompareTo(otherFloat));
}
else
{
return(InternalValue.CompareTo(obj.ToString()));
}
}
}
public Boolean ContainsKey(String key)
{
return(InternalValue.ContainsKey(LowerCaseKeyIfCaseInsensitive(key)));
}
public Boolean Remove(String key)
{
return(InternalValue.Remove(LowerCaseKeyIfCaseInsensitive(key)));
}
public void Add(String key, String value)
{
InternalValue.Add(LowerCaseKeyIfCaseInsensitive(key), value);
}
/// <summary>
///
/// </summary>
/// <param name="op"></param>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns>true if basic, false otherwise</returns>
private bool GetInstr(out int op, out InternalValue a, out InternalValue b)
{
ushort instr = Memory[PC++];
if ((instr & 0xf) == 0)
{
//non-basic
op = (instr >> 4) & 0x3f;
a = CreateValue((ushort)(instr >> 10));
b = default(InternalValue);
return false;
}
else
{
//basic
op = instr & 0xf;
a = CreateValue((ushort)((instr >> 4) & 0x3f));
b = CreateValue((ushort)(instr >> 10));
return true;
}
}
IEnumerator <KeyValuePair <String, String> > IEnumerable <KeyValuePair <String, String> > .GetEnumerator()
{
return(InternalValue.GetEnumerator());
}
public Boolean ContainsValue(String value)
{
return(InternalValue.ContainsValue(value));
}
private bool IsValidValue() => InternalValue != null && !InternalValue.Equals("");
public void SetValue(string member, object value, bool readOnly)
{
Store[member] = new InternalValue(value, readOnly);
}
public void GetObjectData
(SerializationInfo info, StreamingContext context)
{
info.AddValue <Type>("type", InternalValue.GetType());
info.AddValue <object>("value", InternalValue);
}
/// <summary>
/// Sets the value and readonly state of the specified member. This method overrides previous readonly state.
/// </summary>
/// <param name="context"></param>
/// <param name="span"></param>
/// <param name="member">The member.</param>
/// <param name="value">The value.</param>
/// <param name="readOnly">if set to <c>true</c> the value will be read only.</param>
public virtual void SetValue(TemplateContext context, SourceSpan span, string member, object value, bool readOnly)
{
this.AssertNotReadOnly();
Store[member] = new InternalValue(value, readOnly);
}
internal void Update(long now, bool enabled)
{
if ((Flags & CameraValueFlags.NoModifiers) != CameraValueFlags.None)
{
return;
}
if ((Flags & CameraValueFlags.DontUpdateIfDisabled) != CameraValueFlags.None)
{
if (enabled)
{
UpdatedCountWhenDisabled = 0;
}
else
{
if (UpdatedCountWhenDisabled > 0)
{
return;
}
UpdatedCountWhenDisabled++;
}
}
for (var i = Modifiers.Count - 1; i >= 0; i--)
{
var m = Modifiers[i];
if (m.RemoveTimer.HasValue)
{
var timer = m.RemoveTimer.Value;
if (timer < 0)
{
m.RemoveTimer = now - m.RemoveTimer.Value;
}
else if (now >= m.RemoveTimer.Value)
{
m.Remove();
}
}
}
var wantValue = DefaultValue;
double?forceValue = null;
foreach (var x in Modifiers)
{
switch (x.Type)
{
case CameraValueModifier.ModifierTypes.Set:
wantValue = x.Amount;
forceValue = null;
break;
case CameraValueModifier.ModifierTypes.SetIfPreviousIsLowerThanThis:
if (x.Amount > wantValue)
{
wantValue = x.Amount;
forceValue = null;
}
break;
case CameraValueModifier.ModifierTypes.SetIfPreviousIsHigherThanThis:
if (x.Amount < wantValue)
{
wantValue = x.Amount;
forceValue = null;
}
break;
case CameraValueModifier.ModifierTypes.Add:
wantValue += x.Amount;
forceValue = null;
break;
case CameraValueModifier.ModifierTypes.Multiply:
wantValue *= x.Amount;
forceValue = null;
break;
case CameraValueModifier.ModifierTypes.Force:
forceValue = x.Amount;
wantValue = x.Amount;
break;
default:
throw new NotImplementedException();
}
}
if (wantValue != TargetValue)
{
TargetValue = wantValue;
var shouldTween = !forceValue.HasValue && (Flags & CameraValueFlags.NoTween) == CameraValueFlags.None;
if (shouldTween && wantValue > LastValue &&
(Flags & CameraValueFlags.IncreaseInstantly) != CameraValueFlags.None)
{
shouldTween = false;
}
if (shouldTween && wantValue < LastValue &&
(Flags & CameraValueFlags.DecreaseInstantly) != CameraValueFlags.None)
{
shouldTween = false;
}
if (shouldTween)
{
InternalValue = new TValue(LastValue, double.MinValue, double.MaxValue);
InternalValue.TweenTo(wantValue, ChangeSpeed, Formula, true);
}
else
{
CurrentValue = wantValue;
LastValue = wantValue;
}
}
else if (InternalValue != null)
{
InternalValue.Update(now);
LastValue = InternalValue.CurrentAmount;
CurrentValue = LastValue;
if (LastValue == wantValue)
{
InternalValue = null;
}
}
else
{
var hasNow = CurrentValue;
if (hasNow != wantValue)
{
CurrentValue = wantValue;
LastValue = wantValue;
}
}
}
public void Add(KeyValuePair <String, String> item)
{
InternalValue.Add(ObtainUniqueKey(item.Key), item.Value);
}
public Boolean TryGetValue(String key, out String value)
{
return(InternalValue.TryGetValue(LowerCaseKeyIfCaseInsensitive(key), out value));
}
public void SetInternal(int index, InternalValue value)
{
m_internalValues[index] = value;
}
public IEnumerator GetEnumerator()
{
return(InternalValue.GetEnumerator());
}
public Boolean Contains(KeyValuePair <String, String> item)
{
return(InternalValue.Contains(item));
}
public override string ToString()
{
return(InternalValue.ToString());
}
public void Clear()
{
InternalValue.Clear();
}
public Boolean Remove(KeyValuePair <String, String> item)
{
return(InternalValue.Remove(item.Key));
}
