private Body(Body copy)
{
Initialize();
this.ignoresCollisionResponce = copy.ignoresCollisionResponce;
this.shape = copy.shape;
this.massInfo = copy.massInfo;
this.coefficients = copy.coefficients;
this.collisionIgnorer = copy.collisionIgnorer;
this.matrices = copy.matrices.Duplicate();
this.state = copy.state.Duplicate();
this.lifetime = copy.lifetime.Duplicate();
this.transformation = copy.transformation;
this.linearDamping = copy.linearDamping;
this.angularDamping = copy.angularDamping;
this.ignoresCollisionResponce = copy.ignoresCollisionResponce;
this.ignoresGravity = copy.ignoresGravity;
this.ignoresPhysicsLogics = copy.ignoresPhysicsLogics;
this.isTransformed = copy.isTransformed;
this.isCollidable = copy.isCollidable;
this.isEventable = copy.isEventable;
this.tag = copy.tag;
}
private void Delete(CollidingRulesNode crn)
{
var answer = MessageBox.Query("Delete Rules", "Which colliding rule do you want to delete?", "Ignore", "Update", "Both", "Cancel");
if (answer == 0 || answer == 2)
{
// tell ignorer to forget about this rule
if (Ignorer.Delete(crn.IgnoreRule))
{
Remove(crn);
}
else
{
CouldNotDeleteRule();
}
}
if (answer == 1 || answer == 2)
{
// tell Updater to forget about this rule
if (!Updater.Delete(crn.UpdateRule))
{
CouldNotDeleteRule();
}
else
//no point removing it from UI twice
if (answer != 2)
{
Remove(crn);
}
}
}
private void Next()
{
if (_valuePane.CurrentFailure == null)
{
return;
}
int skipped = 0;
int updated = 0;
try
{
while (CurrentReport.Next())
{
var next = CurrentReport.Current;
//prefer rules that say we should update the database with redacted over rules that say we should ignore the problem
if (!Updater.OnLoad(null, next, out _))
{
updated++;
}
else if (!Ignorer.OnLoad(next, out _))
{
skipped++;
}
else
{
SetupToShow(next);
break;
}
}
}
catch (Exception e)
{
ShowException("Error moving to next record", e);
}
if (CurrentReport.Exhausted)
{
ShowMessage("End", "End of Failures");
}
StringBuilder info = new StringBuilder();
info.Append(CurrentReport.DescribeProgress());
if (skipped > 0)
{
info.Append(" Skipped " + skipped);
}
if (updated > 0)
{
info.Append(" Auto Updated " + updated);
}
_info.Text = info.ToString();
}
internal void OnCollision(Body other, object customIntersectionInfo)
{
if (Collided != null &&
(eventIgnorer == null ||
Ignorer.CanCollide(eventIgnorer, other.eventIgnorer)))
{
Collided(this, new CollisionEventArgs(other, customIntersectionInfo));
}
}
internal void OnCollision(Body other, ReadOnlyCollection <IContactInfo> contacts)
{
if (Collided != null &&
(eventIgnorer == null ||
Ignorer.CanCollide(eventIgnorer, other.eventIgnorer)))
{
Collided(this, new CollisionEventArgs(other, contacts));
}
}
internal void OnCollision(TimeStep step, Body other, object customIntersectionInfo)
{
if (Collided != null &&
other.IsEventable &&
(eventIgnorer == null ||
Ignorer.CanCollide(this, other, eventIgnorer, other.eventIgnorer)))
{
Collided(this, new CollisionEventArgs(step, other, customIntersectionInfo));
}
}
internal void OnCollision(TimeStep step, Body other, IContact contact)
{
if (Collided != null &&
other.IsEventable &&
(eventIgnorer == null ||
Ignorer.CanCollide(this, other, eventIgnorer, other.eventIgnorer)))
{
Collided(this, new CollisionEventArgs(step, other, contact));
}
}
async internal void OnColliding(TimeStep step, Body other, IContact contact)
{
if (Colliding != null &&
other.IsEventable &&
(eventIgnorer == null ||
Ignorer.CanCollide(this, other, eventIgnorer, other.eventIgnorer)))
{
await using var obj = new CollisionEventArgs(step, other, contact);
Colliding(this, obj);
}
}
/**
*
* The FindShortest() method searches the node structure for a match,
* skipping any characters that the Ignorer says to ignore and using the
* Comparator to compare characters. If the word is found in the structure
* then the final Node is returned, otherwise it returns null
*
* @param word
* word to find
* @param pos
* position in word to start at
* @param comp
* Comparator to use
* @param ig
* Ignorer to use
* @return Node in the Tree of last character of the matching word, or null
* if no match
*/
public TreeNode findShortest(String word, int pos, Comparator comp,
Ignorer ig)
{
TreeNode cur = null;
if (word.Length > pos)
{
cur = this;
for (int p = pos; p < word.Length; ++p)
{
char c = word[p];
if (!ig.isIgnored(c))
{
cur = cur.hasChild(c, comp);
if (cur == null)
{
return(null);
}
// abort the scan if we found a node which represents the
// end of a
// word.
if (cur.getFlags() != null)
{
break;
}
}
}
}
// Only return nodes that have a non-zero GetFlags() - this means it is
// a
// complete match
if (cur != null)
{
if (cur.getFlags() == null)
{
cur = null;
}
}
return(cur);
}
/**
*
* Construct a Tree object which utilizes the provided Comparator and
* Ignorer
*
* @param comp
* Comparator to use with this Tree
* @param ig
* Ignorer to use with this Tree
*/
public Tree(Comparator comp, Ignorer ig)
{
log.Information(5, "Creating Tree " + this);
comparator = comp;
ignorer = ig;
// create the 128 top Node's.
top = new TreeNode[128];
// populate the top nodes with their default values, which match their
// index
// number.
for (int i = 0; i < 128; ++i)
{
top[i] = new TreeNode();
top[i].clear();
top[i].setValue((char)i);
}
}
/**
* <summary> The Add() method adds the string to the current node, creating
* children nodes as needed. The specified word_flags is attached to the
* final node. Any characters that the Ignorer says are to be ignored are
* skipped. Any comparisons are done with the Comparator. The final Node of
* the word is returned.
*
* @param word
* Word to add
* @param word_flags
* flags to associate with word
* @param comp
* Comparator to use
* @param ig
* Ignorer to use
* @return Node in the Tree of last character in the word
*/
public TreeNode add(String word, TreeFlag word_flags, Comparator comp,
Ignorer ig)
{
TreeNode cur = this;
for (int p = 0; p < word.Length; ++p)
{
char c = word[p];
if (!ig.isIgnored(c))
{
cur = cur.addChild(c, comp);
}
}
cur.flags = word_flags;
return(cur);
}
private void Ignore()
{
if (_valuePane.CurrentFailure == null)
{
return;
}
try
{
Ignorer.Add(_valuePane.CurrentFailure);
History.Push(new MainWindowHistory(CurrentReport.CurrentIndex, Ignorer));
}
catch (OperationCanceledException)
{
//if user cancels adding the ignore then stay on the same record
return;
}
Next();
}
public static bool CanCollide(Body body1, Body body2)
{
if (body1 == null)
{
throw new ArgumentNullException("body1");
}
if (body2 == null)
{
throw new ArgumentNullException("body2");
}
return
(body1.isCollidable &&
body2.isCollidable &&
(body1.collisionIgnorer == null ||
(Ignorer.CanCollide(body1, body2, body1.collisionIgnorer, body2.collisionIgnorer)))
&&
(body2.collisionIgnorer == null ||
!body2.collisionIgnorer.BothNeeded ||
(Ignorer.CanCollide(body2, body1, body2.collisionIgnorer, body1.collisionIgnorer))));
}
private Body(Body copy)
{
this.proxies = new LinkedList <BodyProxy>();
this.ignoresCollisionResponce = copy.ignoresCollisionResponce;
this.shape = copy.shape;
this.massInfo = copy.massInfo;
this.coefficients = copy.coefficients;
this.collisionIgnorer = copy.collisionIgnorer;
this.matrices = copy.matrices.Duplicate();
this.state = copy.state.Duplicate();
this.lifetime = copy.lifetime.Duplicate();
this.transformation = copy.transformation;
this.linearDamping = copy.linearDamping;
this.angularDamping = copy.angularDamping;
this.ignoresCollisionResponce = copy.ignoresCollisionResponce;
this.ignoresGravity = copy.ignoresGravity;
this.isCollidable = copy.isCollidable;
this.ignoresGravity = copy.ignoresGravity;
this.isTransformed = copy.isTransformed;
this.tag = (copy.tag is ICloneable) ? (((ICloneable)copy.tag).Clone()) : (copy.tag);
}
private void Ignore(OutstandingFailureNode ofn)
{
Ignorer.Add(ofn.Failure);
Remove(ofn);
}
public override bool CanCollide(IPhysicsBody thisBody, IPhysicsBody otherBody, Ignorer other)
{
if (otherBody.IgnoresPhysicsLogics)
// || otherBody.IsBroadPhaseOnly)
{
return(true);
}
return(thisBody.Position.Y - depthAllowed > otherBody.Position.Y);
}
/// <summary>
/// Asettaa törmäyksenvälttelyryhmän.
/// </summary>
/// <param name="ignorer"></param>
public void SetCollisionIgnorer(Ignorer ignorer)
{
this.CollisionIgnorer = ignorer;
}
/**
*
* The FindLongest() method searches the node structure for a match,
* skipping any characters that the Ignorer says to ignore and using the
* Comparator to compare characters. If the word is found in the structure
* then the final Node is returned, otherwise it returns null
*
* @param word
* word to find
* @param pos
* position in word to start at
* @param comp
* Comparator to use
* @param ig
* Ignorer to use
* @return Node in the Tree of last character of the matching word, or null
* if no match
*/
public TreeNode findLongest(String word, int pos, Comparator comp,
Ignorer ig)
{
TreeNode cur = null;
char c;
if (word.Length > pos)
{
cur = this;
for (int i = pos; i < word.Length; ++i)
{
c = word[i];
if (!ig.isIgnored(c))
{
cur = cur.hasChild(c, comp);
// No child matches, so we stop searching at this point
if (cur == null)
{
break;
}
// if the child matches we may have a match. But if there
// are more
// chars in the string,
// we must continue down the children to see if there is a
// longer
// match that is better.
// If we do find a longer match, we return that.
// If we do not find a longer match, we return our match.
if ((cur.getFlags() != null) && (i < word.Length - 1))
{
TreeNode possible_match = cur.findLongest(word, i + 1,
comp, ig);
if (possible_match != null)
{
cur = possible_match;
}
// at this point, break out of our loop. cur is either
// the match we
// found or
// is the longer match that the last child of the short
// match found.
break;
}
}
}
}
// Only return nodes that have a non-zero GetFlags() - this means it is
// a
// complete match
if (cur != null)
{
if (cur.getFlags() == null)
{
cur = null;
}
}
return(cur);
}
public PatternExpanderUrl(PatternExpanderTarget target) : base(target)
{
ignorer = new IgnorerWhiteSpace();
//common_prefix = "[,www.]";
common_prefix = "";
}
