void UnionGroupSwapLogicUnits(int unionGroupId,
MegaloScriptModelObjectHandle lhs, MegaloScriptModelObjectHandle rhs)
{
var union_group = UnionGroups[unionGroupId];
union_group.Swap(lhs, rhs);
}
protected override void SerializeValue <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s)
{
if ((model.TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.EmbedObjects) != 0)
{
using (s.EnterCursorBookmark("VT")) // have to nest or MegaloScriptModelObjectHandle will overwrite our Param ID with the VT's
MegaloScriptModelObjectHandle.SerializeForEmbed(s, model, ref mVirtualTriggerHandle);
}
else
{
if (s.IsReading)
{
int id = TypeExtensions.kNone; s.ReadCursor(ref id);
if (id < 0)
{
throw new System.IO.InvalidDataException(string.Format(Util.InvariantCultureInfo,
"VirtualTrigger value #{0} has an invalid value {1}", Id, id));
}
mVirtualTriggerHandle = model.VirtualTriggers[id].Handle;
}
else
{
s.WriteCursor(VirtualTriggerHandle.Id);
}
}
}
void NotifyItemsSwapped(int lhsValueIndex, MegaloScriptModelObjectHandle lhsValue,
int rhsValueIndex, MegaloScriptModelObjectHandle rhsValue)
{
CollectionChanged.SafeNotify(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move,
lhsValue, rhsValueIndex, lhsValueIndex)); // index: new <- old
CollectionChanged.SafeNotify(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move,
rhsValue, lhsValueIndex, rhsValueIndex)); // index: new <- old
}
internal void TriggerSwapLogicUnits(MegaloScriptModelObjectHandle triggerId,
MegaloScriptModelObjectHandle lhs, MegaloScriptModelObjectHandle rhs)
{
Contract.Requires(triggerId.Type == MegaloScriptModelObjectType.Trigger || triggerId.Type == MegaloScriptModelObjectType.VirtualTrigger);
Contract.Requires(triggerId.IsNotNone);
var trigger = (MegaloScriptTriggerBase)this[triggerId];
Contract.Assert(trigger != null);
ReferencesSwapLogicUnits(trigger.References, lhs, rhs);
}
/// <summary>Creates a new condition object and associates it with <paramref name="unionGroupId"/></summary>
/// <param name="unionGroupId">The preexisting union group</param>
/// <param name="evaluationBefore">Condition in the union group to evaluate this condition before, or NONE to just append</param>
/// <returns></returns>
public MegaloScriptCondition CreateConditionInUnionGroup(int unionGroupId, MegaloScriptModelObjectHandle evaluationBefore)
{
Contract.Requires(unionGroupId.IsNotNone());
Contract.Requires(evaluationBefore.Type == MegaloScriptModelObjectType.Condition);
Contract.Requires(evaluationBefore.IsNoneOrPositive);
var cond = CreateCondition();
var union_group = UnionGroups[unionGroupId];
union_group.Insert(cond, evaluationBefore);
return(cond);
}
public MegaloScriptModelObjectHandle CreateBeginAction(MegaloScriptModelObjectHandle virtualTriggerHandle)
{
var vt_action = CreateAction();
vt_action.InitializeForType(this, Database.BeginAction.DBID);
var vt_action_arg0 = CreateValue(Database.GetValueType("VirtualTrigger"))
as Megalo.Model.MegaloScriptVirtualTriggerValue;
vt_action_arg0.VirtualTriggerHandle = virtualTriggerHandle;
vt_action.Arguments.InitializeValues(vt_action_arg0);
return(vt_action.Handle);
}
public MegaloScriptModelObjectHandle CreateForEachAction(MegaloScriptModelObjectHandle triggerHandle)
{
var activate_action = CreateAction();
activate_action.InitializeForType(this, Database.ForEachAction.DBID);
var action_arg0 = CreateValue(Database.GetValueType("TriggerReference"))
as Megalo.Model.MegaloScriptIndexValue;
action_arg0.Value = triggerHandle.Id;
activate_action.Arguments.InitializeValues(action_arg0);
return(activate_action.Handle);
}
public override void Serialize(MegaloScriptModel model, IO.BitStream s)
{
MegaloScriptVirtualTrigger trigger;
if (s.IsReading)
{
trigger = model.CreateVirtualTrigger();
mVirtualTriggerHandle = trigger.Handle;
}
else
{
trigger = model.VirtualTriggers[VirtualTriggerHandle.Id];
}
trigger.Serialize(model, s);
}
void ReferencesSwapLogicUnits(MegaloScriptConditionActionReferences refs,
MegaloScriptModelObjectHandle lhs, MegaloScriptModelObjectHandle rhs)
{
Contract.Requires(lhs.IsNotNone);
Contract.Requires(rhs.IsNotNone);
refs.Swap(lhs, rhs);
if (lhs.Type == MegaloScriptModelObjectType.Condition && rhs.Type == MegaloScriptModelObjectType.Condition)
{
var lhs_cond = Conditions[lhs.Id];
var rhs_cond = Conditions[rhs.Id];
if (lhs_cond.UnionGroup == rhs_cond.UnionGroup)
{
UnionGroupSwapLogicUnits(lhs_cond.UnionGroup, lhs, rhs);
}
}
}
static void SerializeTriggerReferenceValue <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s,
MegaloScriptValueType valueType, ref int value)
where TDoc : class
where TCursor : class
{
var handle = s.IsWriting ? new MegaloScriptModelObjectHandle(MegaloScriptModelObjectType.Trigger, value) : MegaloScriptModelObjectHandle.Null;
if (s.IsWriting)
{
Contract.Assert(model.Triggers[handle.Id].TriggerType == MegaloScriptTriggerType.InnerLoop);
}
using (s.EnterCursorBookmark("T")) // have to nest or MegaloScriptModelObjectHandle will overwrite our Param ID with the Trigger's
MegaloScriptModelObjectHandle.SerializeForEmbed(s, model, ref handle);
if (s.IsReading)
{
value = handle.Id;
}
}
public MegaloScriptModelObject GetModelObjectFromHandle(MegaloScriptModelObjectHandle handle)
{
int id = handle.Id;
switch (handle.Type)
{
case MegaloScriptModelObjectType.None: return(null);
case MegaloScriptModelObjectType.Value: return(Values[id]);
case MegaloScriptModelObjectType.UnionGroup: return(UnionGroups[id]);
case MegaloScriptModelObjectType.Condition: return(Conditions[id]);
case MegaloScriptModelObjectType.Action: return(Actions[id]);
case MegaloScriptModelObjectType.Trigger: return(Triggers[id]);
case MegaloScriptModelObjectType.VirtualTrigger: return(VirtualTriggers[id]);
default: throw new KSoft.Debug.UnreachableException(handle.Type.ToString());
}
}
public MegaloScriptVirtualTriggerValue(MegaloScriptValueType valueType) : base(valueType)
{
Contract.Requires(valueType.BaseType == MegaloScriptValueBaseType.VirtualTrigger);
mVirtualTriggerHandle = MegaloScriptModelObjectHandle.Null;
}
public MegaloScriptModelObject this[MegaloScriptModelObjectHandle handle] => GetModelObjectFromHandle(handle);
void NotifyItemRemoved(int index, MegaloScriptModelObjectHandle value)
{
NotifyPropertyChanged(kCountChanged);
CollectionChanged.SafeNotify(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove,
value, index));
}
void NotifyItemChanged(int index, MegaloScriptModelObjectHandle oldValue, MegaloScriptModelObjectHandle newValue)
{
CollectionChanged.SafeNotify(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace,
oldValue, newValue, index));
}
