/// <summary>
///
/// </summary>
/// <param name="str"></param>
public void SetStruct(HSDStruct str, SubactionGroup subGroup)
{
Struct = str;
Commands = GetCommands(Struct, subGroup);
ResetState();
SetFrame(0);
}
// Update is called once per frame
public virtual void Update()
{
/*
* if (sprite_rate != 0) // if it's zero, no need to animate
* {
* int sprite_number = Mathf.FloorToInt(current_frame / sprite_rate);
* if (sprite_rate < 0)
* sprite_number = Mathf.FloorToInt(current_frame / sprite_rate) - 1;
* if (loop)
* actor.SendMessage("ChangeSubimageWithLoop", sprite_number,SendMessageOptions.RequireReceiver);
* else
* actor.SendMessage("ChangeSubimage", sprite_number,SendMessageOptions.RequireReceiver);
* }
*/
executeSubGroup(SubactionGroup.BEFORE);
actor.SendMessage("ChangeSubimage", current_frame);
executeSubGroup(SubactionGroup.ONFRAME(current_frame));
executeSubGroup(SubactionGroup.AFTER);
//Sometimes, we might end up AFTER the last frame. For all intents and purposes, every frame after the last frame is also the last frame
if (current_frame >= last_frame)
{
executeSubGroup(SubactionGroup.LAST);
if (!isInBuilder)
{
if (exit_action != null && exit_action != "")
{
actor.SendMessage("DoAction", exit_action);
}
}
}
}
public static void EditSubactionData(ref byte[] data, EditSubaction edit, SubactionGroup group)
{
for (int i = 0; i < data.Length;)
{
var sa = SubactionManager.GetSubaction(data[i], group);
if (data[i] == 0)
{
break;
}
// get parameters
var p = sa.GetParameters(data, i);
// make changes
edit(sa, ref p);
// recompile
var test = sa.Compile(p);
for (int j = 0; j < test.Length; j++)
{
data[i + j] = test[j];
}
// advance to next action
i += sa.ByteSize;
}
}
/// <summary>
///
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public static Subaction GetSubaction(byte code, SubactionGroup group)
{
var sa = CustomSubactions.Find(e => e.Code == code && e.IsCustom);
if (sa == null)
{
sa = GetGroup(group).Find(e => e.Code == (code & 0xFC) && !e.IsCustom);
}
return(sa);
}
/// <summary>
///
/// </summary>
/// <param name="group"></param>
/// <returns></returns>
public static List <Subaction> GetGroup(SubactionGroup group)
{
switch (group)
{
case SubactionGroup.Item:
return(ItemSubactions);
case SubactionGroup.Color:
return(ColorSubactions);
default:
return(FighterSubactions);
}
}
public override void execute()
{
actionToModify = LegacyEditorData.instance.currentAction;
subGroupToModify = LegacyEditorData.instance.subactionGroup;
if (subGroupToModify == "Current Frame")
{
subGroupToModify = SubactionGroup.ONFRAME(LegacyEditorData.instance.currentFrame);
}
previousList = actionToModify.subactionCategories.GetIfKeyExists(subGroupToModify);
actionToModify.subactionCategories.Set(subGroupToModify, nextList);
LegacyEditorData.ChangedActionData();
}
public ConversationAction(ScriptedEvent parentEvent, XElement element) : base(parentEvent, element)
{
actionCount++;
Identifier = actionCount;
Options = new List <SubactionGroup>();
foreach (XElement elem in element.Elements())
{
if (elem.Name.LocalName.Equals("option", StringComparison.InvariantCultureIgnoreCase))
{
Options.Add(new SubactionGroup(ParentEvent, elem));
}
else if (elem.Name.LocalName.Equals("interrupt", StringComparison.InvariantCultureIgnoreCase))
{
Interrupted = new SubactionGroup(ParentEvent, elem);
}
}
}
public override void execute()
{
actionToAddTo = LegacyEditorData.instance.currentAction;
groupToAddTo = LegacyEditorData.instance.subactionGroup;
Debug.Log("CreateNewSubaction actionToAddTo: " + actionToAddTo);
Debug.Log("CreateNewSubaction groupToAddTo: " + groupToAddTo);
//Since we don't want to add THIS subactionData, but a copy of it, we reinstance the scriptable object
//subDataToAdd = Instantiate(subDataMaster) as SubactionData;
if (groupToAddTo == "Current Frame")
{
groupToAddTo = SubactionGroup.ONFRAME(LegacyEditorData.instance.currentFrame);
Debug.Log("Current Group: " + groupToAddTo);
}
subDataToAdd = subDataMaster.CreateSubactionData();
actionToAddTo.subactionCategories.GetIfKeyExists(groupToAddTo).Add(subDataToAdd);
Debug.Log(actionToAddTo.subactionCategories);
LegacyEditorData.ChangedActionData();
}
void UpdateCard()
{
//If we're updating, set the flags so we don't update multiple times in a row
lastKnownAction = editor.currentAction;
lastKnownFrame = editor.currentFrame;
lastKnownGroup = editor.subactionGroup;
//Get rid of our old list
foreach (GameObject child in children)
{
child.SendMessage("UnregisterListeners");
NGUITools.Destroy(child);
}
children.Clear(); //Empty the list for future use
//Create all the new buttons
DynamicAction action = LegacyEditorData.instance.currentAction;
string subGroup = LegacyEditorData.instance.subactionGroup;
if (subGroup == "Current Frame")
{
subGroup = SubactionGroup.ONFRAME(LegacyEditorData.instance.currentFrame);
}
if (action != null)
{
int index = 0;
//Create all the new buttons
foreach (SubactionData subData in action.subactionCategories.GetIfKeyExists(subGroup))
{
instantiateButton(subData, index);
index++;
}
//Realign the grid
grid.Reposition();
dragPanel.ResetPosition();
}
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static Subaction GetSubaction(string name, SubactionGroup group)
{
return(GetGroup(group).Find(e => e.Name == name));
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
private List <Command> GetCommands(HSDStruct str, SubactionGroup subGroup, Dictionary <HSDStruct, List <Command> > structToComman = null)
{
if (subGroup != SubactionGroup.Fighter)
{
return(new List <Command>());
}
if (structToComman == null)
{
structToComman = new Dictionary <HSDStruct, List <Command> >();
}
if (structToComman.ContainsKey(str))
{
return(structToComman[str]);
}
var data = str.GetData();
var Commands = new List <Command>();
structToComman.Add(str, Commands);
for (int i = 0; i < data.Length;)
{
var sa = SubactionManager.GetSubaction(data[i], subGroup);
var cmd = new Command();
foreach (var r in str.References)
{
if (r.Key >= i && r.Key < i + sa.ByteSize)
{
if (cmd.Reference != null)
{
throw new NotSupportedException("Multiple References not supported");
}
else
{
if (r.Value != str) // prevent self reference
{
cmd.Reference = r.Value;
cmd.ReferenceCommands = GetCommands(cmd.Reference, subGroup, structToComman);
}
}
}
}
var sub = new byte[sa.ByteSize];
if (i + sub.Length > data.Length)
{
break;
}
for (int j = 0; j < sub.Length; j++)
{
sub[j] = data[i + j];
}
cmd.Parameters = sa.GetParameters(sub);
cmd.Action = sa;
Commands.Add(cmd);
i += sa.ByteSize;
if (sa.Code == 0)
{
break;
}
}
return(Commands);
}
