public override void AddChildren(IReadOnlyCollection <object> children, AddChildModifiers modifiers)
{
var subEntity = (EntityViewModel)children.First();
var command = TargetNode.GetCommand(SetEntityReferenceCommand.CommandName);
command.Execute(subEntity);
}
internal void Refresh([NotNull] IGraphNode ownerNode, NodeContainer nodeContainer, NodeIndex index)
{
var objectValue = ownerNode.Retrieve(index);
var boxedTarget = TargetNode as BoxedNode;
if (boxedTarget != null && objectValue?.GetType() == TargetNode.Type)
{
// If we are boxing a struct, and the targeted type didn't change, we reuse the same nodes and just overwrite the struct value.
boxedTarget.UpdateFromOwner(objectValue);
// But we still need to refresh inner references!
foreach (var member in TargetNode.Members.Where(x => x.IsReference))
{
nodeContainer?.UpdateReferences(member);
}
}
else if (TargetNode?.Retrieve() != objectValue)
{
// This call will recursively update the references.
var target = SetTarget(objectValue, nodeContainer);
if (target != null)
{
var boxedContent = target as BoxedNode;
boxedContent?.SetOwnerContent(ownerNode, index);
}
}
// This reference is not orphan anymore.
orphanObject = null;
}
private string BuildDot()
{
var builder = StringBuilderCache.Acquire();
var sourceIdentifier = SourcePort != null
? SourceNode + ":" + SourcePort
: SourceNode.ToString();
var targetIdentifier = TargetPort != null
? TargetNode + ":" + TargetPort
: TargetNode.ToString();
builder.Append(sourceIdentifier)
.Append(" -> ")
.Append(targetIdentifier);
if (EdgeAttributes.Any())
{
const string indent = " ";
builder.AppendLine(" [");
foreach (var edgeAttr in EdgeAttributes)
{
builder.Append(indent).AppendLine(edgeAttr.ToString());
}
builder.Append(']');
}
return(builder.GetStringAndRelease());
}
protected override void ExecuteCore()
{
Folder targetFolder = GetTargetNodeAncestorAsXenObjectOrGroupingTag <Folder>();
if (DraggedNodes != null)
{
foreach (VirtualTreeNode draggedNode in DraggedNodes)
{
if (GetItemsNotAlreadyInTargetFolder().Contains((IXenObject)draggedNode.Tag))
{
GreyAll(draggedNode);
}
}
}
new MoveToFolderAction(GetItemsNotAlreadyInTargetFolder(), targetFolder).RunAsync();
// need to now wait until the operation has finished... then we can expand the node.
ThreadPool.QueueUserWorkItem(delegate
{
for (int i = 0; i < 20 && TargetNode.Nodes.Count == 0; i++)
{
Thread.Sleep(100);
}
MainWindowCommandInterface.Invoke(delegate { TargetNode.Expand(); });
});
}
public override void AddChildren(IReadOnlyCollection <object> children, AddChildModifiers modifiers)
{
var symbol = (Symbol)children.Select(x => (NodeViewModel)x).First().NodeValue;
var command = TargetNode.GetCommand(SetSymbolReferenceCommand.CommandName);
command.Execute(symbol);
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
ProjectNode project = e.Node as ProjectNode;
if (project != null)
{
current_project = project;
textBoxProjectName.Text = project.Text;
//tabControl2.TabPages.Add( tabControl1.
SelectActivePage(tabPageProjectProperties);
}
TargetNode target = e.Node as TargetNode;
if (target != null)
{
SelectActivePage(tabPageTargetProperties);
comboBoxTargetType.SelectedValue = target.target["target_type"];
current_target = target;
//ProjectData.project_data_set.current_target = target.target;
}
TargetSourceNode target_source = e.Node as TargetSourceNode;
if (target_source != null)
{
}
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (TargetNode == null)
{
return(BehaviorResult.failed);
}
SetStarting();
BehaviorResult result = TargetNode.Exec(tree);
if (result == BehaviorResult.success)
{
SetCompleted();
return(BehaviorResult.success);
}
else if (result == BehaviorResult.failed)
{
SetFailed();
return(BehaviorResult.failed);
}
else if (result == BehaviorResult.running)
{
return(BehaviorResult.running);
}
SetAborted();
return(BehaviorResult.abort);
}
/// <summary>
///
/// </summary>
protected override void Apply()
{
if (TargetChildNodes == null || TargetChildNodes.Count == 0)
{
TargetNode.AppendChild(TransformNode);
}
else
{
XmlAttribute transformAtt = null;
foreach (XmlAttribute att in TransformNode.Attributes)
{
if (string.Equals(att.Name, AttributeName, StringComparison.OrdinalIgnoreCase))
{
transformAtt = att;
break;
}
}
if (transformAtt == null)
{
throw new InvalidOperationException("No target attribute to append");
}
foreach (XmlNode targetNode in TargetChildNodes)
{
var foundAttribute = false;
foreach (XmlAttribute att in targetNode.Attributes)
{
if (string.Equals(att.Name, AttributeName, StringComparison.OrdinalIgnoreCase))
{
foundAttribute = true;
if (string.IsNullOrEmpty(att.Value))
{
att.Value = transformAtt.Value;
}
else
{
// TODO: This doesn't compose well with insertOrAppend being applied on the TargetNode.
// The target node is created with the children it has in the transform, which means we would
// duplicate the value here.
if (att.Value == transformAtt.Value)
{
return;
}
att.Value = $"{att.Value};{transformAtt.Value}";
}
}
}
if (!foundAttribute)
{
var attribute = targetNode.OwnerDocument.CreateAttribute(AttributeName);
attribute.Value = transformAtt.Value;
targetNode.Attributes.Append(attribute);
}
}
}
}
protected override void Apply()
{
CommonErrors.ExpectNoArguments(Log, TransformNameShort, ArgumentString);
TargetNode.AppendChild(TransformNode);
Log.LogMessage(MessageType.Verbose, Resources.XMLTRANSFORMATION_TransformMessageInsert, TransformNode.Name);
}
// Add a new target node to the end of the list. Don't need all the points before we start traveling.
private void Event_SpawnedNode(TargetNode inNode)
{
if (DebugMsg)
{
Debug.Log("Player notified by spawned node");
}
nodeList.Add(inNode);
}
protected override void Apply()
{
CommonErrors.ExpectNoArguments(Log, TransformNameShort, ArgumentString);
if (TargetChildNodes is null || TargetChildNodes.Count == 0)
{
TargetNode.AppendChild(TransformNode);
Log.LogMessage(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformMessageInsert, TransformNode.Name);
}
}
/// <summary>
/// Spawns and configures a chain of target nodes towards the target position.
/// </summary>
public void BeginTargetting()
{
List <Vector3> linePositions = new List <Vector3>();
Vector3 toTarget = targetLocation - transform.position;
float distance = toTarget.magnitude;
toTarget.Normalize();
Vector3 toTargetPerp = Vector2.Perpendicular(toTarget).normalized;
TargetNode firstNode = null;
TargetNode lastNode = null;
int numNodes = Mathf.Min((int)(distance) + 7, 12);
float waveDistance = numNodes * 0.15f + Random.Range(-0.25f, 0.25f);
bool flipped = (Random.Range(0, 2) == 0);
for (int i = 0; i < numNodes; i++)
{
// Standard node init
TargetNode node = Instantiate(targetNodePrefab, MyGameManager.TargettingNodes).GetComponent <TargetNode>();
node.MyCannon = this;
if (lastNode != null)
{
lastNode.NextNode = node;
node.gameObject.SetActive(false);
}
if (firstNode == null)
{
firstNode = node;
}
lastNode = node;
// Position along a line straight back to cannon
float distanceRatio = 1f - ((float)i / (numNodes - 1));
Vector3 position = new Vector3(toTarget.x * distance * distanceRatio, toTarget.y * distance * distanceRatio);
// Add a simple sin wave
float angle = distanceRatio * 360f * Mathf.Deg2Rad;
Vector3 offset = new Vector3(toTargetPerp.x * Mathf.Sin(angle) * waveDistance, toTargetPerp.y * Mathf.Sin(angle) * waveDistance, 0f);
position += flipped ? offset : -offset;
//position += offset;
node.transform.position = position;
node.ProgressOnLink = distanceRatio;
node.TimeToSelect = 1f * (distanceRatio + 0.2f);
linePositions.Add(position);
}
firstNode.transform.position = targetLocation;
lastNode.transform.position = transform.position;
TargettingLine.positionCount = numNodes;
TargettingLine.SetPositions(linePositions.ToArray());
TargettingLine.gameObject.SetActive(true);
SetTargettingLineProgress(0f);
TargettingLineProgressAmount = 1f / numNodes;
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (TargetNode == null)
{
//Debug.LogError("missing target node");
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
return(BehaviorResult.failed);
}
}
SetStarting();
}
if (N == 0.0f)
{
N = tree.GameTime;
}
BehaviorResult result = TargetNode.Exec(tree);
if (result == BehaviorResult.success)
{
SetCompleted();
N = 0.0f;
return(BehaviorResult.success);
}
else if (result == BehaviorResult.failed)
{
SetFailed();
return(BehaviorResult.failed);
}
else if (result == BehaviorResult.running)
{
if (tree.GameTime - N < Interval)
{
return(BehaviorResult.running);
}
else
{
TargetNode.Abort();
N = 0.0f;
return(BehaviorResult.failed);
}
}
else
{
return(BehaviorResult.abort);
}
}
public override bool CanAddChildren(IReadOnlyCollection <object> children, AddChildModifiers modifiers, out string message)
{
AssetViewModel asset = null;
var singleChild = true;
foreach (var child in children)
{
if (!singleChild)
{
message = "Multiple assets selected";
return(false);
}
asset = child as AssetViewModel;
if (asset == null)
{
message = "The selection is not an asset";
return(false);
}
if (AssetRegistry.IsContentType(TargetNode.Type) || typeof(AssetReference).IsAssignableFrom(TargetNode.Type))
{
var isCompatible = false;
var resolvedAssetTypes = AssetRegistry.GetAssetTypes(TargetNode.Type);
foreach (var resolvedAssetType in resolvedAssetTypes)
{
if (resolvedAssetType.IsAssignableFrom(asset.AssetType))
{
isCompatible = true;
break;
}
}
if (!isCompatible)
{
message = "Incompatible asset";
return(false);
}
}
var command = TargetNode.GetCommand("SetContentReference");
var param = new SetContentReferenceCommand.Parameter {
Asset = asset, Type = TargetNode.Type
};
if (!command.CanExecute(param))
{
message = "The selection is not valid in this context";
return(false);
}
singleChild = false;
}
if (asset == null)
{
message = "The selection is not an asset";
return(false);
}
message = $"Reference {asset.Url}";
return(true);
}
public override void AddChildren(IReadOnlyCollection <object> children, AddChildModifiers modifiers)
{
var asset = (AssetViewModel)children.First();
var param = new SetContentReferenceCommand.Parameter {
Asset = asset, Type = TargetNode.Type
};
var command = TargetNode.GetCommand("SetContentReference");
command.Execute(param);
}
public void RemoveFirst()
{
if (_start.Target == null)
{
_start = null;
return;
}
_start = _start.Target;
}
protected override void OnEnable()
{
base.OnEnable();
TargetNode.SortShowViewsList();
TargetNode.SortHideViewsList();
m_infoMessageUnnamedNodeName = new InfoMessage(InfoMessage.MessageType.Error, UILabels.UnnamedNodeTitle, UILabels.UnnamedNodeMessage);
m_infoMessageDuplicateNodeName = new InfoMessage(InfoMessage.MessageType.Error, UILabels.DuplicateNodeTitle, UILabels.DuplicateNodeMessage);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override int GetHashCode()
{
if (TargetNode != null)
{
return(TargetNode.GetHashCode() + (int)Cost);
}
else
{
return((int)Cost);
}
}
private void Event_SpawnedNode(TargetNode inNode)
{
if (DebugMsg)
{
Debug.Log("Game Manager notified by spawn.");
}
if (OnSpawnedNode != null)
{
OnSpawnedNode(inNode);
}
}
private void chkFlagsTypeUnk0x8000_CheckedChanged(object sender, EventArgs e)
{
if (_updating)
{
return;
}
TargetNode.SignalPropertyChange();
foreach (CollisionPlane p in _selectedPlanes)
{
p.IsTypeUnknown0x8000 = chkFlagsTypeUnk0x8000.Checked;
}
}
protected override void OnNodeGUI()
{
if (TargetNode.MaxChance <= 0)
{
TargetNode.UpdateMaxChance();
}
TargetNode.UpdateConnectedOutputSockets();
DrawNodeBody();
DrawSocketsList(Node.InputSockets);
DrawSocketsList(Node.OutputSockets);
DrawAddSocketButton(SocketDirection.Output, ConnectionMode.Override, typeof(WeightedConnection));
}
public override void AddChildren(IReadOnlyCollection <object> children, AddChildModifiers modifiers)
{
var subEntity = (EntityViewModel)children.First();
var index = subEntity.Components.IndexOf(x => TargetNode.Type.IsInstanceOfType(x));
if (index >= 0)
{
var command = TargetNode.GetCommand(SetComponentReferenceCommand.CommandName);
command.Execute(new SetComponentReferenceCommand.Parameter {
Entity = subEntity, Index = index
});
}
}
private void chkTypeRightWall_CheckedChanged(object sender, EventArgs e)
{
if (_updating)
{
return;
}
TargetNode.SignalPropertyChange();
foreach (CollisionPlane p in _selectedPlanes)
{
p.IsRightWall = chkTypeRightWall.Checked;
}
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (TargetNode == null)
{
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
return(BehaviorResult.failed);
}
}
SetStarting();
}
while (true)
{
if (N == 0.0f)
{
N = tree.GameTime;
}
while (tree.GameTime - N < CDTime)
{
return(BehaviorResult.running);
}
BehaviorResult result = TargetNode.Exec(tree);
if (result == BehaviorResult.success)
{
Reset();
}
else if (result == BehaviorResult.failed)
{
Reset();
}
else if (result == BehaviorResult.running)
{
return(BehaviorResult.running);
}
}
}
public void RemoveLast()
{
if (_start.Target == null)
{
_start = null;
return;
}
var node = _start;
while (node.Target?.Target != null)
{
node = node.Target;
}
node.Target = null;
}
protected override void Apply()
{
if (TargetChildNodes == null)
{
return;
}
foreach (var element in TargetChildNodes.OfType <XmlElement>())
{
if (element.ChildNodes.Cast <XmlNode>()
.Any(n => n.NodeType != XmlNodeType.Whitespace &&
n.NodeType != XmlNodeType.Comment &&
n.NodeType != XmlNodeType.Attribute))
{
continue;
}
TargetNode.RemoveChild(element);
}
}
public void Add(float x, float y)
{
var target = new TargetNode(x, y);
if (_start == null)
{
_start = target;
return;
}
var t = _start;
while (t.Target != null)
{
t = t.Target;
}
t.Target = target;
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (TargetNode == null)
{
// Debug.LogError("missing target node");
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
return(BehaviorResult.failed);
}
}
SetStarting();
}
while (true)
{
BehaviorResult result = TargetNode.Exec(tree);
if (result == BehaviorResult.success)
{
SetCompleted();
return(BehaviorResult.success);
}
else if (result == BehaviorResult.running)
{
return(BehaviorResult.running);
}
else if (result == BehaviorResult.failed)
{
return(BehaviorResult.running);
}
}
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (TargetNode == null)
{
return(BehaviorResult.failed);
}
SetStarting();
while (LoopCount < 0 || m_CounterLoop < LoopCount)
{
BehaviorResult result = TargetNode.Exec(tree);
if (result == BehaviorResult.success)
{
if (LoopCount > 0)
{
m_CounterLoop++;
}
//return BehaviorResult.running;
}
else if (result == BehaviorResult.failed)
{
if (LoopCount > 0)
{
m_CounterLoop++;
}
}
else if (result == BehaviorResult.running)
{
//return BehaviorResult.running;
}
return(BehaviorResult.running);
}
SetCompleted();
return(BehaviorResult.success);
}
public IHttpActionResult Post([FromBody] List <Target> targets)
{
try
{
int[,] adj = Algorithms.Algorithms.GetAdjacencyMatrix(targets);
if (Algorithms.Algorithms.ContainsCycle(adj, new List <int>(), new List <List <int> >(), 0))
{
throw new Exception("Target graph must not contain cycles");
}
TargetNode root = Algorithms.Algorithms.BuildTargetTree(targets);
List <TargetNode> nodes = Algorithms.Algorithms.TopologicalSort(root);
return(Ok(nodes.Select(x => new
{
Name = x.Title
})));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
/// <summary>
/// Do unit selection.
/// </summary>
/// <param name="searchConfig">Search configuration.</param>
/// <returns>The best path.</returns>
public List<PathNodeInfo> UnitSelecting(SearchConfig searchConfig)
{
ILatticeProvider latticeProvider = searchConfig.LatticeProvider;
ITargetCostCalculator targetCostCalculator = searchConfig.TargetCostCalculator;
IJoinCalculator joinCostCalculator = searchConfig.JoinCostCalculator;
int targetCount = latticeProvider.GetColumnCount();
if (targetCount == 0)
{
string message = Helper.NeutralFormat("The ILatticeProvider contains 0 targets!");
throw new InvalidDataException(message);
}
List<PathNodeInfo> bestPath = new List<PathNodeInfo>(targetCount);
TargetNode[] targets = new TargetNode[targetCount];
LatticeNode[][] lattice = new LatticeNode[targetCount][];
for (int i = 0; i < targetCount; i++)
{
int candidateCount = latticeProvider.GetRowCount(i);
if (candidateCount == 0)
{
string message = Helper.NeutralFormat("The ILatticeProvider contains 0 candidates for target {0}!", i);
throw new InvalidDataException(message);
}
targets[i] = new TargetNode(latticeProvider.GetTarget(i), candidateCount);
lattice[i] = new LatticeNode[candidateCount];
for (int j = 0; j < candidateCount; j++)
{
PathNodeInfo pathNodeInfo = new PathNodeInfo(latticeProvider.GetCandidate(i, j), float.PositiveInfinity, float.PositiveInfinity);
lattice[i][j] = new LatticeNode(pathNodeInfo, float.PositiveInfinity, -1);
}
}
for (int i = 0; i < targets[0].CandidateCount; i++)
{
LatticeNode nodeCur = lattice[0][i];
float targetCost = targetCostCalculator.GetTargetCost(targets[0].Target, nodeCur.PathNodeInfo.Candidate);
nodeCur.BestScore = targetCost;
nodeCur.PathNodeInfo.TargetCost = targetCost;
}
for (int col = 1; col < targetCount; col++)
{
TargetNode targetCur = targets[col];
TargetNode targetLeft = targets[col - 1];
for (int i = 0; i < targetCur.CandidateCount; i++)
{
LatticeNode nodeCur = lattice[col][i];
LatticeNode nodeLeft = lattice[col - 1][0];
float joinCost = joinCostCalculator.GetJoinCost(targetLeft.Target, targetCur.Target,
nodeLeft.PathNodeInfo.Candidate, nodeCur.PathNodeInfo.Candidate);
float bestPreScore = nodeLeft.BestScore + joinCost;
int bestPreNodeIndex = 0;
float bestJoinCost = joinCost;
for (int j = 1; j < targets[col - 1].CandidateCount; j++)
{
nodeLeft = lattice[col - 1][j];
joinCost = joinCostCalculator.GetJoinCost(targetLeft.Target, targetCur.Target,
nodeLeft.PathNodeInfo.Candidate, nodeCur.PathNodeInfo.Candidate);
float preCost = nodeLeft.BestScore + joinCost;
if (preCost < bestPreScore)
{
bestPreScore = preCost;
bestPreNodeIndex = j;
bestJoinCost = joinCost;
}
}
float targetCost = targetCostCalculator.GetTargetCost(targetCur.Target, nodeCur.PathNodeInfo.Candidate);
nodeCur.BestScore = bestPreScore + targetCost;
nodeCur.BestPreNodeIndex = bestPreNodeIndex;
nodeCur.PathNodeInfo.TargetCost = targetCost;
nodeCur.PathNodeInfo.JoinCost = bestJoinCost;
}
}
int columnIndex = targetCount - 1;
LatticeNode bestNode = lattice[columnIndex][0];
float bestScore = bestNode.BestScore;
for (int i = 1; i < targets[columnIndex].CandidateCount; i++)
{
LatticeNode curNode = lattice[columnIndex][i];
if (curNode.BestScore < bestScore)
{
bestNode = curNode;
bestScore = bestNode.BestScore;
}
}
while (true)
{
bestPath.Add(bestNode.PathNodeInfo);
columnIndex--;
if (columnIndex < 0)
{
break;
}
bestNode = lattice[columnIndex][bestNode.BestPreNodeIndex];
}
bestPath.Reverse();
return bestPath;
}
