public void AddPointIfNotExists(JumpNode node)
{
if (!connectedNodes.Contains(node))
{
connectedNodes.Add(node);
}
}
private void OnPatch(CodeNode node, JumpNode from, LivenessTarget ltCur, LivenessTarget ltUnused, BitArray bCur, int bLen, ref int retPtr)
{
for (; ;)
{
if (node.Liveness == null)
{
throw new ArgumentNullException();
}
var bNode = node.Liveness;
if (!bNode.AddBitsDelSource(bCur, bLen))
{
OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
if (node.Type == CodeNodeType.Label)
{
OnTarget(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
if (node == _functionNode)
{
OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
node = node.Previous;
}
}
public static void JumpNode()
{
var a = new JumpNode("label");
var b = SerializationUtil.Reserialize(a);
Assert.AreEqual(a, b);
}
private void CreateInstructionNode(InstructionId instructionId, Operand[] operands)
{
var options = _assembler.GetInstructionOptionsAndReset();
if (instructionId.IsJump())
{
LabelNode target = null;
JumpNode next = null;
CodeNodeFlags flags = 0;
if (!options.IsSet(InstructionOptions.Unfollow))
{
if (operands[0].IsLabel())
{
target = _assembler.GetLabelData(operands[0].Id).ContextData;
}
else
{
options |= InstructionOptions.Unfollow;
}
}
flags |= instructionId == InstructionId.Jmp ? CodeNodeFlags.Jmp | CodeNodeFlags.Taken : CodeNodeFlags.Jcc;
if (target != null)
{
next = target.From;
}
// The 'jmp' is always taken, conditional jump can contain hint, we detect it.
if (instructionId == InstructionId.Jmp)
{
flags |= CodeNodeFlags.Taken;
}
else if (options.IsSet(InstructionOptions.Taken))
{
flags |= CodeNodeFlags.Taken;
}
var node = new JumpNode(instructionId, options, operands);
node.Flags |= flags;
node.Target = target;
if (target != null)
{
node.NextJump = next;
target.From = node;
target.ReferenceCount++;
}
AddNode(node);
return;
}
var inst = new InstructionNode(instructionId, options, operands);
AddNode(inst);
}
public CompiledWhile()
{
compiledStatement = new NodeLinkedList();
condition = new NodeLinkedList();
body = new NodeLinkedList();
var conditionalJumpNode = new ConditionalJumpNode(compiledStatement.Last, body.First);
var jumpBackNode = new JumpNode(compiledStatement.First);
compiledStatement.Add(condition);
compiledStatement.Add(conditionalJumpNode); // De body komt dus rechtstreeks na de conditionalJumpNode (dus op de .Next property)
compiledStatement.Add(body);
compiledStatement.Add(jumpBackNode);
}
private void OnDone(JumpNode from, LivenessTarget ltCur, LivenessTarget ltUnused, BitArray bCur, int bLen, ref int retPtr)
{
CodeNode node;
if (ltCur != null)
{
node = ltCur.Node;
from = ltCur.From;
OnTarget(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr, true);
return;
}
retPtr++;
if (retPtr >= _variableContext.ReturningList.Count)
{
return;
}
node = _variableContext.ReturningList[retPtr];
OnVisit(node, @from, null, ltUnused, bCur, bLen, ref retPtr);
}
private static CodeNode GetJccFlow(JumpNode jump)
{
return(jump.Flags.IsSet(CodeNodeFlags.Taken) ? jump.Target : jump.Next);
}
public void Visit(JumpNode node)
{
NextNode = node.JumpToNode;
}
public void visit(JumpNode jumpNode)
{
//devolgendenode = jumpNode.jump;
}
public void AddPoint(JumpNode node)
{
connectedNodes.Add(node);
node.AddPointIfNotExists(this);
}
private void OnVisit(CodeNode node, JumpNode from, LivenessTarget ltCur, LivenessTarget ltUnused, BitArray bCur, int bLen, ref int retPtr)
{
for (; ;)
{
if (node.Liveness != null)
{
if (bCur.AddBitsDelSource(node.Liveness, bCur, bLen))
{
OnPatch(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
var bTmp = new BitArray(bLen);
bTmp.CopyBits(bCur, bLen);
node.Liveness = bTmp;
var map = node.VariableMap;
if (map != null)
{
var vaCount = map.Attributes.Length;
var vaList = map.Attributes;
for (var i = 0; i < vaCount; i++)
{
var va = vaList[i];
var vd = va.VariableData;
var flags = va.Flags;
var localId = vd.LocalId;
if ((flags & VariableFlags.WAll) != 0 && (flags & VariableFlags.RAll) == 0)
{
// Write-Only.
bTmp.SetBit(localId);
bCur.DelBit(localId);
}
else
{
// Read-Only or Read/Write.
bTmp.SetBit(localId);
bCur.SetBit(localId);
}
}
}
if (node.Type == CodeNodeType.Label)
{
OnTarget(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
if (node == _functionNode)
{
OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
if (node.Previous == null)
{
throw new ArgumentNullException();
}
node = node.Previous;
}
}
private void OnTarget(CodeNode node, JumpNode from, LivenessTarget ltCur, LivenessTarget ltUnused, BitArray bCur, int bLen, ref int retPtr, bool jumpNext = false)
{
var label = node.As <LabelNode>();
if (label.ReferenceCount != 0 || jumpNext)
{
if (!jumpNext)
{
// Push a new LivenessTarget onto the stack if needed.
if (ltCur == null || ltCur.Node != node)
{
// Allocate a new LivenessTarget object (from pool or zone).
var ltTmp = ltUnused;
if (ltTmp != null)
{
ltUnused = ltUnused.Previous;
}
else
{
ltTmp = new LivenessTarget();
}
// Initialize and make current - ltTmp->from will be set later on.
ltTmp.Previous = ltCur;
ltTmp.Node = label;
ltCur = ltTmp;
from = label.From;
if (from == null)
{
throw new ArgumentNullException();
}
}
else
{
from = ltCur.From;
OnTarget(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr, true);
return;
// goto _OnJumpNext;
}
}
// Visit/Patch.
do
{
if (!jumpNext)
{
ltCur.From = from;
bCur.CopyBits(node.Liveness, bLen);
if (from.Liveness == null)
{
node = from;
OnVisit(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr);
}
// jumpNext = true;
}
// Issue #25: Moved '_OnJumpNext' here since it's important to patch
// code again if there are more live variables than before.
jumpNext = false;
if (bCur.DelBits(from.Liveness, bLen))
{
node = from;
OnPatch(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
from = from.NextJump;
} while (from != null);
{
// Pop the current LivenessTarget from the stack.
var ltTmp = ltCur;
ltCur = ltCur.Previous;
ltTmp.Previous = ltUnused;
ltUnused = ltTmp;
}
}
bCur.CopyBits(node.Liveness, bLen);
node = node.Previous;
if (node.Flags.IsSet(CodeNodeFlags.Jmp) || !node.IsFetched())
{
OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
if (node.Liveness == null)
{
OnVisit(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
if (bCur.DelBits(node.Liveness, bLen))
{
OnPatch(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr);
return;
}
OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr);
}
private Dictionary <char, JumpNode> computeGroups(int wordStartIndex, int wordEndIndex, string keys0, string prefix, List <JumpWord> jumpWords)
{
// SC-Tree algorithm from vim-easymotion script with minor changes
var wordCount = wordEndIndex - wordStartIndex + 1;
var keyCount = keys0.Length;
Dictionary <char, JumpNode> groups = new Dictionary <char, JumpNode>();
var keys = keys0; //Reverse(keys0);
var keyCounts = new int[keyCount];
var keyCountsKeys = new Dictionary <char, int>(keyCount);
var j = 0;
foreach (char key in keys)
{
keyCounts[j] = 0;
keyCountsKeys[key] = j;
j++;
}
var targetsLeft = wordCount;
var level = 0;
var i = 0;
while (targetsLeft > 0)
{
var childrenCount = level == 0 ? 1 : keyCount - 1;
foreach (char key in keys)
{
keyCounts[keyCountsKeys[key]] += childrenCount;
targetsLeft -= childrenCount;
if (targetsLeft <= 0)
{
keyCounts[keyCountsKeys[key]] += targetsLeft;
break;
}
i += 1;
}
level += 1;
}
var k = 0;
var keyIndex = 0;
Array.Reverse(keyCounts);
foreach (int KeyCount2 in keyCounts)
{
if (KeyCount2 > 1)
{
groups[keys[keyIndex]] = new JumpNode()
{
jumpWordIndex = -1,
childrenNodes = computeGroups(wordStartIndex + k, wordStartIndex + k + KeyCount2 - 1, Reverse(string.Copy(keys)),
prefix + keys[keyIndex], jumpWords)
};
}
else if (KeyCount2 == 1)
{
groups[keys[keyIndex]] = new JumpNode()
{
jumpWordIndex = wordStartIndex + k,
childrenNodes = null
};
var jw = jumpWords[wordStartIndex + k];
string jumpLabel = prefix + keys[keyIndex];
JumpLabelUserControl adornment = null;
if (jw.windowFrame == null) // winframe=null => regular textview navigation.
{
#if MEASUREEXECTIME
if (createAdornmentUIElem == null)
{
createAdornmentUIElem = Stopwatch.StartNew();
}
else
{
createAdornmentUIElem.Start();
}
#endif
adornment = JumpLabelUserControl.GetFreeUserControl();
adornment.setup(jumpLabel, jw.adornmentBounds, this.jumpLabelCachedSetupParams);
#if MEASUREEXECTIME
createAdornmentUIElem.Stop();
#endif
#if MEASUREEXECTIME
if (adornmentCreateStopwatch == null)
{
adornmentCreateStopwatch = Stopwatch.StartNew();
}
else
{
adornmentCreateStopwatch.Start();
}
#endif
//TraceLine("before AddAdornment");
this.layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, jw.span, null, adornment, JumpLabelAdornmentRemovedCallback);
#if DEBUG_LABEL_ALGO
Trace.WriteLine($"POS={jw.textViewPosDbg,5} Adding jumplabel adornment");
#endif
#if MEASUREEXECTIME
adornmentCreateStopwatch.Stop();
#endif
}
//Debug.WriteLine(jw.text + " -> |" + jumpLabel + "|");
var cj = new Jump(
span: jw.span,
label: jumpLabel,
labelAdornment: adornment,
windowFrame: jw.windowFrame,
vanillaTabCaption: jw.vanillaTabCaption,
windowPrimaryTextView: jw.windowPrimaryTextView
);
currentJumps.Add(cj);
}
else
{
continue;
}
keyIndex += 1;
k += KeyCount2;
}
return(groups);
}
void Update()
{
base.Update();
Vector2 result = Vector2.zero;
if (_shootTimer > 0)
{
_shootTimer -= Time.deltaTime;
}
if (_player)
{
Vector2 playerPosition = _player.transform.position;
Vector2 diff = playerPosition - (Vector2)transform.position;
result += (Vector2)transform.right * (diff.x * moveVelocity) * Time.fixedDeltaTime;
if (Mathf.Abs(result.x) > maxSpeed)
{
result.x = Mathf.Sign(result.x) * maxSpeed;
}
if (Mathf.Abs(diff.y) > 0.5f)
{
result.y = Physics2D.gravity.y * moveVelocity * Time.deltaTime;
}
if (_shootTimer <= 0f)
{
var target = Physics2D.Raycast((Vector2)transform.position + diff.normalized, diff.normalized, 15);
if (!target.collider || target.collider.tag == "Player")
{
_bulletShooter.Shoot((Vector2)transform.position + diff.normalized, diff * shootForce);
_shootTimer = shootCooldown;
}
}
}
else
{
if (targetNode == null)
{
JumpNode closest = null;
float minDistance = float.PositiveInfinity;
foreach (JumpNode node in _platformPathfinding.nodes)
{
if (node == null)
{
continue;
}
float dist = Vector2.Distance(node.transform.position, transform.position);
if (dist < minDistance)
{
closest = node;
minDistance = dist;
}
}
if (closest != null)
{
targetNode = closest;
}
}
else
{
if (Vector2.Distance(targetNode.transform.position, transform.position) < 0.5f)
{
int index = Enemy.rnd.Next(targetNode.connectedNodes.Count);
targetNode = targetNode.connectedNodes[index];
isJumping = false;
jumpTimer = 0f;
}
else
{
if (!isJumping && Mathf.Abs(targetNode.transform.position.y - transform.position.y) < 1f)
{
Vector2 diff = (Vector2)targetNode.transform.position - (Vector2)transform.position;
result += (Vector2)transform.right * (diff.normalized.x * moveVelocity) * Time.fixedDeltaTime;
if (Mathf.Abs(result.x) > maxSpeed)
{
result.x = Mathf.Sign(result.x) * maxSpeed;
}
}
else
{
if (!isJumping)
{
jumpTimer = 0;
startJumpPosition = transform.position;
midJumpPosition = (startJumpPosition + (Vector2)targetNode.transform.position) / 2;
midJumpPosition.y = targetNode.transform.position.y > startJumpPosition.y ? targetNode.transform.position.y + 2 : startJumpPosition.y + 2;
isJumping = true;
}
if (jumpTimer >= 1f)
{
isJumping = false;
}
if (jumpTimer <= 1f)
{
Vector2 endPosition = targetNode.transform.position;
Vector2 lerped = cubeBezier2(startJumpPosition, midJumpPosition, midJumpPosition, endPosition, jumpTimer);
Vector2 diff = lerped - (Vector2)transform.position;
_rb.position = lerped;
jumpTimer += Time.deltaTime;
}
}
}
}
}
_rb.velocity = result;
}
