public byte[] MoveDown(AnimationCommand command, ref int topOffset)
{
if (selectedNode.NextNode == null)
{
return(null);
}
if (command.Opcode == 0x07 ||
command.Opcode == 0x11 ||
command.Opcode == 0x5E)
{
return(null);
}
AnimationCommand nextCommand = (AnimationCommand)selectedNode.NextNode.Tag;
if (nextCommand.Opcode == 0x07 ||
nextCommand.Opcode == 0x11 ||
nextCommand.Opcode == 0x5E)
{
return(null);
}
if (selectedNode.Parent != null)
{
if (selectedNode.Index >= selectedNode.Parent.Nodes.Count - 1)
{
return(null);
}
}
else if (selectedNode.Index >= treeView.Nodes.Count - 1)
{
return(null);
}
return(Reverse(command, nextCommand, ref topOffset, 0));
}
public byte[] MoveUp(AnimationCommand command, ref int topOffset)
{
if (selectedNode.PrevNode == null)
{
return(null);
}
if (command.Opcode == 0x07 ||
command.Opcode == 0x11 ||
command.Opcode == 0x5E)
{
return(null);
}
AnimationCommand prevCommand = (AnimationCommand)selectedNode.PrevNode.Tag;
if (prevCommand.Opcode == 0x07 ||
prevCommand.Opcode == 0x11 ||
prevCommand.Opcode == 0x5E)
{
return(null);
}
if (selectedNode.Index == 0)
{
return(null);
}
return(Reverse(prevCommand, command, ref topOffset, 1));
}
private byte[] Reverse(AnimationCommand commandA, AnimationCommand commandB, ref int topOffset, int selectedIndex)
{
byte[] byteA = Bits.Copy(commandB.CommandData);
byte[] byteB = Bits.Copy(commandA.CommandData);
commandA.CommandData = byteA;
commandB.CommandData = byteB;
//
int offset = commandA.InternalOffset;
topOffset = commandA.InternalOffset;
byte[] changes = new byte[commandA.Length + commandB.Length];
for (int i = 0; i < byteA.Length; i++, offset++)
{
changes[i] = commandA.CommandData[i];
}
int temp = commandB.InternalOffset;
commandB.InternalOffset = commandA.InternalOffset;
commandA.InternalOffset = offset;
int index = byteA.Length;
for (int i = 0; i < byteB.Length; i++, offset++)
{
changes[index++] = commandB.CommandData[i];
}
commandA.Offset = commandA.OriginalOffset = commandA.InternalOffset;
commandB.Offset = commandB.OriginalOffset = commandB.InternalOffset;
// check multiple instances of command in current script, and change each accordingly
return(changes);
}
/// <summary>
/// Selects a node in the treeView with a specified internalOffset.
/// </summary>
/// <param name="internalOffset">The internal offset of the node's command.</param>
/// <param name="index">The full parent index of the node.</param>
public void SelectNode(int internalOffset, int fullParentIndex)
{
selectedNode = null;
int parentIndex = -1; // root has no parent
int index = 0; // the current full index
foreach (TreeNode node in this.treeView.Nodes)
{
AnimationCommand asc = (AnimationCommand)node.Tag;
if (internalOffset == asc.InternalOffset && parentIndex == fullParentIndex)
{
selectedNode = node;
break;
}
else
{
SelectChildNode(node, internalOffset, fullParentIndex, ref index);
}
if (selectedNode != null)
{
break;
}
}
this.treeView.SelectedNode = selectedNode;
}
// treeview managers
private void AddCommand(AnimationCommand command)
{
// Add node
this.treeView.Nodes.Add("[" + (command.Offset).ToString("X6") + "] " + command.ToString());
TreeNode node = treeView.Nodes[treeView.Nodes.Count - 1];
node.Tag = command;
//
switch (command.Opcode)
{
case 0x07:
case 0x11:
case 0x5E:
node.BackColor = Color.FromArgb(255, 255, 255, 160);
break;
case 0x09:
case 0x10:
case 0x5D:
case 0x64:
case 0x68:
node.BackColor = Color.FromArgb(255, 192, 224, 255);
AddNode(command, node);
break;
default:
if (command.Opcode >= 0x24 && command.Opcode <= 0x2B)
{
node.BackColor = Color.FromArgb(255, 192, 224, 255);
AddNode(command, node);
}
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="asc">The command being modified.</param>
/// <param name="offset">The offset of the data.</param>
/// <param name="internalOffset">The internal offset of the command.</param>
/// <param name="data">The ROM data.</param>
public AnimationEdit(AnimationScripts form, AnimationCommand asc, int offset, byte[] data)
{
this.form = form;
this.asc = asc;
this.offset = offset;
this.data = data;
Execute(true);
}
internal void Animation(string animName)
{
AnimationCommand cmd = CommandManager.Instance.CreateCommand("animation") as AnimationCommand;
cmd.Load(animName);
cmd.Execute(m_Instance, m_DeltaTime);
}
void Start()
{
rb = this.GetComponent <Rigidbody>();
animator = GetComponentInChildren <Animator>();
idelAnimation = new IdleAnimation();
deadAnimation = new DeadAnimation();
walkAnimation = new IdleAnimation();
walkAnimation.Animate(animator, true);
}
public void Execute(bool push)
{
for (int i = 0; i < data.Length; i++)
{
byte temp = Model.ROM[offset + i];
Model.ROM[offset + i] = data[i];
data[i] = temp;
}
if (!push)
{
AnimationCommand temp = this.asc;
this.asc = this.form.ASC;
this.form.ASC = temp;
}
}
IEnumerator showGraphicCoroutine(EffectGraphic graphic, AnimationCommand cmd)
{
timePassed = 0;
showGraphic(graphic);
while (timePassed < DISPLAY_TIME)
{
newX = remainingTimeDefaultWidth - remainingTimeDefaultWidth * timePassed / DISPLAY_TIME;
cachedV2.Set(newX, remainingTimeGraphic.size.y);
remainingTimeGraphic.size = cachedV2;
timePassed += Time.deltaTime * timePassedCoeff;
yield return(null);
}
cvGameObject.SetActive(false);
cmd.finished = true;
}
private void btnAdd_Click(object sender, EventArgs e)
{
int indexLamp = lbLamps.SelectedIndex;
int indexAction = lbActions.SelectedIndex;
if (indexLamp > -1 && indexAction > -1)
{
Lamp l = (Lamp)lbLamps.Items[indexLamp];
Object o = lbActions.Items[indexAction];
if (o is Power)
{
PowerCommand pc = new PowerCommand(l, Convert.ToBoolean(o));
cal.AddAnimation(pc);
}
else if (o is Color)
{
AnimationCommand ac = new AnimationCommand(l, (Color)o);
cal.AddAnimation(ac);
}
}
}
private void SelectChildNode(TreeNode parent, int internalOffset, int fullParentIndex, ref int index)
{
int parentIndex = parent.Nodes.Count > 0 ? index++ : index;
foreach (TreeNode child in parent.Nodes)
{
AnimationCommand asc = (AnimationCommand)child.Tag;
if (internalOffset == asc.InternalOffset && parentIndex == fullParentIndex)
{
selectedNode = child;
break;
}
else
{
SelectChildNode(child, internalOffset, fullParentIndex, ref index);
}
if (selectedNode != null)
{
break;
}
}
}
private void AddNode(AnimationCommand command, TreeNode node)
{
TreeNode childNode;
foreach (AnimationCommand childCommand in command.Commands)
{
node.Nodes.Add("[" + (childCommand.Offset).ToString("X6") + "] " + childCommand.ToString());
childNode = node.Nodes[node.Nodes.Count - 1];
childNode.Tag = childCommand;
//
switch (childCommand.Opcode)
{
case 0x07:
case 0x11:
case 0x5E:
childNode.BackColor = Color.FromArgb(255, 255, 255, 160);
break;
case 0x09:
case 0x10:
case 0x5D:
case 0x64:
case 0x68:
childNode.BackColor = Color.FromArgb(255, 192, 224, 255);
AddNode(childCommand, childNode);
break;
default:
if (childCommand.Opcode >= 0x24 && childCommand.Opcode <= 0x2B)
{
childNode.BackColor = Color.FromArgb(255, 192, 224, 255);
AddNode(childCommand, childNode);
}
break;
}
}
}
/// <summary>
/// Update the actual animation (should be after all requests).
/// </summary>
public void update()
{
switch (m_requestedCommand)
{
case AnimationCommand.Play:
play();
break;
case AnimationCommand.Idle:
idle();
break;
default:
throw new Exception("Shouldn't reach here");
}
m_requestedCommand = AnimationCommand.Idle;
}
/// <summary>
/// Callers use this to suggest an animation to play. Priority checks
/// are made to determine whether to accept the suggestion or keep
/// playing the old animation.
/// </summary>
/// <param name="animName">Name of animation to play.</param>
/// <param name="comm">What to do with that animation.</param>
public void requestAnimation(string animName, AnimationCommand command)
{
int requestedAnimIdx = findAnimationIdx(animName);
Animation requestedAnim = m_animSet.anims[requestedAnimIdx];
if (requestedAnim == CurrentAnimation)
{
m_requestedCommand = command;
return;
}
if (CurrentAnimation.priority == 0 ||
requestedAnim.priority > CurrentAnimation.priority ||
m_isIdle)
{
m_currentAnimIdx = requestedAnimIdx;
m_currentSpriteIdx = 0;
m_requestedCommand = command;
return;
}
}
// functions
private void ParseScript(byte[] rom)
{
int offset = baseOffset, length = 0;
AnimationCommand temp;
if (type == 8)
{
offset = baseOffset + 2;
if (index == 22)
{
offset = baseOffset + 4;
}
if (index == 70)
{
offset = baseOffset + 6;
}
if (index == 85)
{
offset = baseOffset + 6;
}
}
if (this.commands == null)
{
this.commands = new List <AnimationCommand>();
}
while (offset < rom.Length)
{
if (offset == 0x3A6BA1) // another annoying rare case
{
break;
}
//
length = GetOpcodeLength(rom, offset);
temp = new AnimationCommand(Bits.GetBytes(rom, offset, length), offset, this, null);
// memory modifiying commands
switch (temp.Opcode)
{
case 0x20:
case 0x21: if ((temp.Param1 & 0x0F) == 0)
{
amem = temp.CommandData[2];
}
break;
case 0x2C:
case 0x2D: if ((temp.Param1 & 0x0F) == 0)
{
amem += temp.CommandData[2];
}
break;
case 0x2E:
case 0x2F: if ((temp.Param1 & 0x0F) == 0)
{
amem -= temp.CommandData[2];
}
break;
case 0x30:
case 0x31: if ((temp.Param1 & 0x0F) == 0)
{
amem++;
}
break;
case 0x32:
case 0x33: if ((temp.Param1 & 0x0F) == 0)
{
amem--;
}
break;
case 0x34:
case 0x35: if ((temp.Param1 & 0x0F) == 0)
{
amem = 0;
}
break;
case 0x6A:
case 0x6B: if ((temp.Param1 & 0x0F) == 0)
{
amem = (byte)(temp.CommandData[2] - 1);
}
break;
}
commands.Add(temp);
// termination commands
if (rom[offset] == 0x07 || // end animation packet
rom[offset] == 0x09 || // jump directly to address (thus ending this)
rom[offset] == 0x11 || // end subroutine
rom[offset] == 0x5E) // end sprite subroutine
{
break;
}
//
offset += length;
}
}
public void Add(AnimationCommand command)
{
commands.Add(command);
}
