public static BBMacro DeserializeMacro(BinaryReader reader)
{
BBMacro ret = null;
BBMacroType type = (BBMacroType)reader.ReadByte();
switch (type)
{
case BBMacroType.If:
ret = new BBIfMacro();
break;
case BBMacroType.Series:
ret = new BBSeriesMacro();
break;
case BBMacroType.Parallel:
ret = new BBParallelMacro();
break;
case BBMacroType.Normal:
ret = new BBMacro();
break;
}
ret.Deserialize(reader);
return(ret);
}
public override BBMacro Clone(bool deepClone)
{
BBParallelMacro macro = base.Clone(deepClone) as BBParallelMacro;
if (deepClone)
{
macro.items = new BBMacro[items.Length];
for (int i = 0; i < items.Length; i++)
{
macro.items[i] = items[i].Clone(deepClone);
}
}
return(macro);
}
private static BBMacro Load(BinaryReader reader)
{
BBMacro macro = BBMacro.DeserializeMacro(reader);
switch (macro.macroType)
{
case BBMacroType.If:
{
BBIfMacro ifmacro = macro as BBIfMacro;
int itemLen = reader.ReadInt32();
ifmacro.items = new BBMacro[itemLen];
for (int i = 0; i < itemLen; i++)
{
ifmacro.items[i] = Load(reader);
}
break;
}
case BBMacroType.Series:
{
BBSeriesMacro srmacro = macro as BBSeriesMacro;
int itemLen = reader.ReadInt32();
srmacro.items = new BBMacro[itemLen];
for (int i = 0; i < itemLen; i++)
{
srmacro.items[i] = Load(reader);
}
break;
}
case BBMacroType.Parallel:
{
BBParallelMacro prmacro = macro as BBParallelMacro;
int itemLen = reader.ReadInt32();
prmacro.items = new BBMacro[itemLen];
for (int i = 0; i < itemLen; i++)
{
prmacro.items[i] = Load(reader);
}
break;
}
}
if (reader.ReadBoolean())
{
macro.next = Load(reader);
}
return(macro);
}
private static void Save(BBMacro macro, BinaryWriter writer)
{
BBMacro.SerializedMacro(macro, writer);
switch (macro.macroType)
{
case BBMacroType.If:
{
BBIfMacro ifmacro = macro as BBIfMacro;
writer.Write(ifmacro.items.Length);
for (int i = 0; i < ifmacro.items.Length; i++)
{
Save(ifmacro.items[i], writer);
}
break;
}
case BBMacroType.Series:
{
BBSeriesMacro srmacro = macro as BBSeriesMacro;
writer.Write(srmacro.items.Length);
for (int i = 0; i < srmacro.items.Length; i++)
{
Save(srmacro.items[i], writer);
}
break;
}
case BBMacroType.Parallel:
{
BBParallelMacro prmacro = macro as BBParallelMacro;
writer.Write(prmacro.items.Length);
for (int i = 0; i < prmacro.items.Length; i++)
{
Save(prmacro.items[i], writer);
}
break;
}
}
if (macro.next != null)
{
writer.Write(true);
Save(macro.next, writer);
}
else
{
writer.Write(false);
}
}
private void Execute(BBMacro macro, out BBLoopAction action)
{
action = BBLoopAction.Continue;
switch (macro.macroType)
{
case BBMacroType.If:
BBIfMacro ifmacro = macro as BBIfMacro;
BBMacro future = null;
if (ifmacro.Test(out future))
{
BBMacroPlayer inserted = new BBMacroPlayer(mConfig, mModuleProxy);
inserted.Set(future);
inserted.Play();
mInterrupts.Add(inserted);
}
else
{
action = ifmacro.action;
}
break;
case BBMacroType.Series:
BBSeriesMacro srmacro = macro as BBSeriesMacro;
foreach (BBMacro item in srmacro.items)
{
BBMacroPlayer inserted = new BBMacroPlayer(mConfig, mModuleProxy);
inserted.Set(item);
mSeriesQueue.Enqueue(inserted);
}
break;
case BBMacroType.Parallel:
BBParallelMacro prmacro = macro as BBParallelMacro;
foreach (BBMacro item in prmacro.items)
{
BBMacroPlayer inserted = new BBMacroPlayer(mConfig, mModuleProxy);
inserted.Set(item);
inserted.Play();
mInterrupts.Add(inserted);
}
break;
default:
mEmulator.Set(Expand(macro));
break;
}
}
public virtual BBMacro Clone(bool deepClone)
{
BBMacro macro = null;
switch (macroType)
{
case BBMacroType.If:
macro = new BBIfMacro();
break;
case BBMacroType.Series:
macro = new BBSeriesMacro();
break;
case BBMacroType.Parallel:
macro = new BBParallelMacro();
break;
case BBMacroType.Normal:
macro = new BBMacro();
break;
}
macro.code = code;
macro.button = button;
macro.key = key;
macro.data = new float[data.Length];
Array.Copy(data, macro.data, data.Length);
macro.times = times;
macro.duration = duration;
macro.delay = delay;
macro.script = script;
macro.scriptData = scriptData;
if (deepClone)
{
if (next != null)
{
macro.next = next.Clone(deepClone);
}
}
return(macro);
}
