public override EBTResult Tick()
{
EBTResult tmpResult = EBTResult.Running;
IsRunning = true;
do
{
if (!mRepeatForever)
{
++mCurrentCount;
}
if (mCurrentCount > mCount)
{
tmpResult = EBTResult.Success;
IsRunning = false;
break;
}
EBTResult tmpChildResult = ChildNode.Tick();
if (mEndOnFailure && EBTResult.Failed == tmpChildResult)
{
tmpResult = EBTResult.Failed;
IsRunning = false;
break;
}
} while (false);
return(tmpResult);
}
//c indicates where the child's parent is in relation to it
private void createChild(ShipChromosomeNode n, ChildNode c, ShipController s)
{
GameObject g = (GameObject)GameObject.Instantiate(
Resources.Load(n.isEngine ? Config.ENGINE_PREFAB_LOCATION : Config.HEAVY_BLOCK_PREFAB_LOCATION),
Vector3.zero,
Quaternion.identity);
if (n.isEngine)
{
EngineScript engine = g.GetComponent <EngineScript>();
engine.initialize(s, n.startEngageAngle, n.rangeEngageAngle);
}
g.transform.parent = transform;
g.transform.localPosition = Vector3.zero;
g.transform.localRotation = Quaternion.Euler(0, 0, n.relativeRotation);
Vector3 colliderSize = g.GetComponent <MeshCollider>().bounds.size;
switch (c)
{
case ChildNode.TOP:
g.transform.localPosition = g.transform.localPosition
+ rotateByThisRotation(new Vector3(0, -colliderSize.y, 0));
break;
case ChildNode.BOTTOM:
g.transform.localPosition = g.transform.localPosition
+ rotateByThisRotation(new Vector3(0, colliderSize.y, 0));
break;
case ChildNode.LEFT:
g.transform.localPosition = g.transform.localPosition
+ rotateByThisRotation(new Vector3(colliderSize.x, 0, 0));
break;
case ChildNode.RIGHT:
g.transform.localPosition = g.transform.localPosition
+ rotateByThisRotation(new Vector3(-colliderSize.x, 0, 0));
break;
}
if (Physics.OverlapSphere(g.transform.position,
(colliderSize.y < colliderSize.x
? colliderSize.y : colliderSize.x) / 2.1f).Length > 1)
{
GameObject.Destroy(g);
return;
}
//FixedJoint fixedJoint = g.AddComponent<FixedJoint>();
//fixedJoint.enableCollision = false;
//fixedJoint.connectedBody = rigidbody;
BlockScript b = g.GetComponent <BlockScript>();
b.initialize(n, s);
}
private void BuildIndexes(NRefactory.ArrayInitializerExpression initializer, INode currentNodeIndex)
{
initializer.Elements.ForEach(e => {
var childInitializer = e as NRefactory.ArrayInitializerExpression;
if (childInitializer != null)
{
var newIndex = new ChildNode {
ParentNode = currentNodeIndex
};
newIndex.Root = currentNodeIndex.Root;
newIndex.Index = currentNodeIndex.Nodes.Count;
currentNodeIndex.Nodes.Add(newIndex);
BuildIndexes(childInitializer, newIndex);
}
else
{
var newIndex = new LinqExpressionNode {
ParentNode = currentNodeIndex
};
newIndex.Root = currentNodeIndex.Root;
newIndex.Index = currentNodeIndex.Nodes.Count;
currentNodeIndex.Nodes.Add(newIndex);
newIndex.Value = e.AcceptVisitor(Visitor, ParentScope);
}
});
}
// evaluate the tree recursively
private double EvalTree(Node n)
{
if (n == null)
{
//Console.WriteLine("No expression entered.");
return(0);
}
else
{
if (n is ChildNode) // tree only has one const node
{
ChildNode n1 = (ChildNode)n;
return(n1.getVal());
}
else if (n is VarNode) // tree has one variable node
{
VarNode n2 = (VarNode)n;
return(_dict[n2.getVal()]); // return value assigned by user in the dictionary
}
else // m_root is a opNode
{
// need to evaluate the tree
double l;
double r;
OperatorNode op = (OperatorNode)n;
l = EvalTree(op.Left);
r = EvalTree(op.Right);
return(op.Eval(l, r));
}
}
}
public override void OnResponse(NetState state, RelayInfo info)
{
Mobile from = state.Mobile;
switch (info.ButtonID)
{
case 1:
{
if (m_Node.Parent != null)
{
from.SendGump(new SendToGump(0, from, m_Tree, m_Node.Parent));
}
break;
}
case 2:
{
if (m_Page > 0)
{
from.SendGump(new SendToGump(m_Page - 1, from, m_Tree, m_Node));
}
break;
}
case 3:
{
if ((m_Page + 1) * EntryCount < m_Node.Children.Length)
{
from.SendGump(new SendToGump(m_Page + 1, from, m_Tree, m_Node));
}
break;
}
default:
{
int index = info.ButtonID - 4;
if (index >= 0 && index < m_Node.Children.Length)
{
object o = m_Node.Children[index];
if (o is ParentNode)
{
from.SendGump(new SendToGump(0, from, m_Tree, (ParentNode)o));
}
else
{
ChildNode n = (ChildNode)o;
from.Target = new SendToTarget(n.Location, m_Tree.Map);
}
}
break;
}
}
}
public override void RemoveChild(BTNode aNode)
{
int index = ChildNode.IndexOf(aNode);
_results.RemoveAt(index);
base.RemoveChild(aNode);
}
private static IEnumerable <ChildNode> GetChildrenNodes(IPublishedContent source)
{
var pageInfoData = new List <ChildNode>();
var childrenNodes = source.Children;
if (!childrenNodes.HasAny())
{
return(pageInfoData);
}
foreach (var publishedContent in childrenNodes)
{
var isApiRequest = string.Empty.IsApiRequest();
var url = isApiRequest
? $"/{ApplicationConstants.ApiRoutePrefix}{publishedContent.Url()}"
: publishedContent.Url();
if (publishedContent.ContentType.Alias.Equals(NewsPage.ModelTypeAlias) && isApiRequest)
{
url = url.Replace($"{publishedContent.UrlSegment}", $"{publishedContent.Id}");
}
var urlWithDomain = $"{string.Empty.GetUrlWithDomain()}{url}";
var childNode = new ChildNode
{
Name = publishedContent.Name, Url = url, UrlWithDomain = urlWithDomain
};
pageInfoData.Add(childNode);
}
return(pageInfoData);
}
//Выбрать ряды для генерации
public IEnumerable <SubRows> SelectRows(TablsList dataTabls, SubRows parentRow)
{
IEnumerable <SubRows> rows = dataTabls.Tabls[_tablName].SubList;
rows = _condition == null ? rows : rows.Where(row => _condition.Generate(row).Boolean);
return(ChildNode == null ? rows : ChildNode.SelectRows(rows));
}
/// <summary>
/// Returns the value of the attribute for the specified child.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="relativePath">The relative path.</param>
/// <param name="index">The index.</param>
/// <param name="attributeId">The attribute id.</param>
/// <returns>The value of the attribute for the specified child.</returns>
private object GetAttributeValue(
ChildNode node,
IList <QualifiedName> relativePath,
int index,
uint attributeId)
{
if (index >= relativePath.Count)
{
if (node.NodeClass == NodeClass.Object && attributeId == Attributes.NodeId)
{
return(node.Value);
}
if (node.NodeClass == NodeClass.Variable && attributeId == Attributes.Value)
{
return(node.Value);
}
return(null);
}
for (int ii = 0; ii < node.Children.Count; ii++)
{
if (node.Children[ii].BrowseName == relativePath[index])
{
return(GetAttributeValue(node.Children[ii], relativePath, index + 1, attributeId));
}
}
return(null);
}
public static string GetJSON(DataTable dt)
{
List <ParentNode> parent = new List <ParentNode>();
for (int i = 0; i < dt.Rows.Count; i++)
{
var innerRow = dt.Rows[i]["Parent"];
var objParent = new ParentNode();
bool alreadyExists = parent.Any(x => x.Parent.Contains(innerRow.ToString()));
if (alreadyExists)
{
continue;
}
DataRow[] foundRows = dt.Select("[Parent]='" + innerRow + "'");
for (int k = 0; k < foundRows.Count(); k++)
{
var objChild = new ChildNode();
objChild.Child = foundRows[k]["Child"].ToString();
objParent.Child.Add(objChild);
}
objParent.Parent = innerRow.ToString();
parent.Add(objParent);
}
JavaScriptSerializer jsonString = new JavaScriptSerializer();
return(jsonString.Serialize(parent));
}
public override string?Render()
{
Content = ChildNode?.Render();
Content = Content != null ? $"<h5{GetAttributes()}>{Content}</h5>" : $"<h5{GetAttributes()}></h5>";
return(Content + SiblingNode?.Render());
}
/// <summary>
/// Creates a snapshot of a node.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="state">The state.</param>
/// <returns>A snapshot of a node.</returns>
private ChildNode CreateChildNode(ISystemContext context, BaseInstanceState state)
{
ChildNode node = new ChildNode();
node.NodeClass = state.NodeClass;
node.BrowseName = state.BrowseName;
BaseVariableState variable = state as BaseVariableState;
if (variable != null)
{
if (!StatusCode.IsBad(variable.StatusCode))
{
node.Value = Utils.Clone(variable.Value);
}
}
BaseObjectState instance = state as BaseObjectState;
if (instance != null)
{
node.Value = instance.NodeId;
}
node.Children = CreateChildNodes(context, state);
return(node);
}
public void SelectChildNode(ChildNode childNode, ushort updateID)
{
if (m_NodeDictionary.ContainsKey(new Tuple <uint, ushort>(childNode.Handle, updateID)))
{
TreeView.SelectedNode = m_NodeDictionary[new Tuple <uint, ushort>(childNode.Handle, updateID)];
}
}
public VyattaConfigObject AddObject(string Parent)
{
string[] Split = Parent.Split(new char[] { ':' }, 2);
foreach (var ChildNode in Children)
{
if (ChildNode.GetAttributeString() == Split[0])
{
if (Split.Length == 2)
{
return(ChildNode.AddObject(Split[1]));
}
else
{
return(ChildNode as VyattaConfigObject);
}
}
}
var NewNode = new VyattaConfigObject(new VyattaConfigAttribute(Split[0]));
Children.Add(NewNode);
if (Split.Length == 2)
{
return(NewNode.AddObject(Split[1]));
}
else
{
return(NewNode);
}
}
public override bool Run()
{
Transform Dragon = DragonManager.Instance.transform;
Transform Player = DragonManager.Instance.Player;
Vector3 Target = (Player.position - Dragon.position).normalized;
float Dot = Vector3.Dot(Dragon.forward, Target);
if (Dot >= Mathf.Cos(Mathf.Deg2Rad * 180.0f * 0.5f))
{
Vector3 cross = Vector3.Cross(Dragon.forward, Target);
float result = Vector3.Dot(cross, Vector3.up);
bool IsLeftPowAttack = BlackBoard.Instance.IsLeftPowAttack;
bool IsRightPowAttack = BlackBoard.Instance.IsRightPowAttack;
bool IsTailAttack = BlackBoard.Instance.IsTailAttack;
if ((result < 0.0f && !IsRightPowAttack && !IsTailAttack) || IsLeftPowAttack)
{
Debug.Log("Left_Pow_Decorator");
return(ChildNode.Run());
}
}
return(true);
}
public void addChild(ChildNode c)
{
if (child == null)
{
child = c;
}
}
//c indicates where the child's parent is in relation to it
public static ShipChromosomeNode generateRandomShip(int d, ChildNode c)
{
ShipChromosomeNode root = new ShipChromosomeNode();
root.depth = d;
root.parentPos = c;
root.isEngine = Random.Range(0, 2) == 1;
root.startEngageAngle = Random.Range(0, 360);
root.rangeEngageAngle = Random.Range(0, 360);
root.relativeRotation = Random.Range(-Config.MAX_CHILD_ROTATION, Config.MAX_CHILD_ROTATION);
float f;
if (root.depth < Config.MAX_SHIP_DEPTH)
{
//top
if (c != ChildNode.TOP)
{
f = Random.Range(0.0f, 1.0f);
if (f <= Config.CHANCE_OF_CHILD_NODE)
{
root.top = ShipChromosomeNode.generateRandomShip(root.depth + 1, ChildNode.BOTTOM);
}
}
//bottom
if (c != ChildNode.BOTTOM)
{
f = Random.Range(0.0f, 1.0f);
if (f <= Config.CHANCE_OF_CHILD_NODE)
{
root.bottom = ShipChromosomeNode.generateRandomShip(root.depth + 1, ChildNode.TOP);
}
}
//left
if (c != ChildNode.LEFT)
{
f = Random.Range(0.0f, 1.0f);
if (f <= Config.CHANCE_OF_CHILD_NODE)
{
root.left = ShipChromosomeNode.generateRandomShip(root.depth + 1, ChildNode.RIGHT);
}
}
//right
if (c != ChildNode.RIGHT)
{
f = Random.Range(0.0f, 1.0f);
if (f <= Config.CHANCE_OF_CHILD_NODE)
{
root.right = ShipChromosomeNode.generateRandomShip(root.depth + 1, ChildNode.LEFT);
}
}
}
return(root);
}
public ContentTree GetContentTree()
{
ContentTree contentTree = new ContentTree();
List<Item> contentItems = _itemRepository.GetAll().ToList();
if (contentItems == null)
return null;
ParentNode parentNode = null;
contentTree.ContentTreeNodes = new List<ParentNode>();
foreach (Item contentItem in contentItems)
{
if (contentItem.IsParentItem)
{
parentNode = new ParentNode();
parentNode.IsContentNode = contentItem.ParentItemId.HasValue ? false : true;
parentNode.NodeName = contentItem.DisplayName;
parentNode.NodeId = contentItem.Id;
parentNode.ChildNodes = new List<ChildNode>();
}
if (contentItem.IsParentItem)
{
foreach (Item childNode in contentItems)
{
if (parentNode != null)
{
if (childNode.ParentItemId.HasValue )
{
if (childNode.ParentItemId.Value == parentNode.NodeId)
{
ChildNode node = new ChildNode();
node.Id = childNode.Id;
node.ParentItemId = childNode.ParentItemId.Value;
node.ItemTypeId = childNode.ItemTypeId;
node.ItemName = childNode.ItemName;
node.DisplayName = childNode.DisplayName;
node.Created = childNode.Created;
node.ContentOwner = childNode.ContentOwner;
parentNode.ChildNodes.Add(node);
}
}
}
}
contentTree.ContentTreeNodes.Add(parentNode);
}
}
return contentTree;
}
public override W_BTNode RemoveChild(W_BTNode aNode)
{
int index = ChildNode.IndexOf(aNode);
_results.RemoveAt(index);
base.RemoveChild(aNode);
return(this);
}
//Выбрать ряды для генерации, узел запроса
public IEnumerable <SubRows> SelectRows(IEnumerable <SubRows> parentRows)
{
var rows = parentRows.SelectMany(row => Condition == null
? row.SubList
: row.SubList.Where(r => Condition.Generate(r).Boolean));
return(ChildNode == null ? rows : ChildNode.SelectRows(rows));
}
private void l_zNumericUpDown_ValueChanged(object sender, EventArgs e)
{
if (locationsTreeView.SelectedNode.Tag is ChildNode)
{
ChildNode node = locationsTreeView.SelectedNode.Tag as ChildNode;
node.Z = (int)zNumericUpDown.Value;
}
}
//Выбрать ряды для генерации, главный узел выражения подтаблицы
public IEnumerable <SubRows> SelectRows(TablsList dataTabls, SubRows parentRow)
{
IEnumerable <SubRows> rows = Condition == null
? parentRow.SubList
: parentRow.SubList.Where(row => Condition.Generate(row).Boolean);
return(ChildNode == null ? rows : ChildNode.SelectRows(rows));
}
public override bool Run()
{
if (DragonManager.Stat.HP <= 0)
{
return(ChildNode.Run());
}
return(false);
}
private void locationsTreeView_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
{
if (e.Node.Tag is ChildNode)
{
ChildNode node = e.Node.Tag as ChildNode;
SetLocation(node.Map, node.X, node.Y, node.Z);
}
}
public override int GetHashCode()
{
var guid = ChildNode.GetOptionalStringAttribute("guid", string.Empty);
return((guid == string.Empty)
? base.GetHashCode()
: guid.ToLowerInvariant().GetHashCode());
}
private void l_mapComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (locationsTreeView.SelectedNode.Tag is ChildNode)
{
ChildNode node = locationsTreeView.SelectedNode.Tag as ChildNode;
node.Map = (Maps)mapComboBox.SelectedIndex;
}
}
public void Sort()
{
ChildNodes = ChildNodes.OrderBy(x => x.Record.Name).ToList();
foreach (StreamNode ChildNode in ChildNodes)
{
ChildNode.Sort();
}
}
//you would use this instead of (Nodes.Remove)
public void RemoveNode(ChildNode node)
{
if (ChildNodes.Contains(node))
{
node.ParentNode = null;
ChildNodes.Remove(node);
PopulateChildren();
}
}
//you would use this instead of (Nodes.Add)
public void AddNode(ChildNode node)
{
if (!ChildNodes.Contains(node))
{
node.ParentNode = this;
ChildNodes.Add(node);
PopulateChildren();
}
}
/// <summary>
/// Returns a clone of the node of this state.
/// </summary>
/// <returns>The cloned node.</returns>
public override INode CloneNode()
{
INode NewNode = null;
NodeTreeHelperOptional.GetChildNode(Optional, out bool IsAssigned, out INode ChildNode);
if (ChildNode != null)
{
// Create a clone, initially empty and full of null references.
NewNode = NodeHelper.CreateEmptyNode(ChildNode.GetType());
// Clone and assign reference to all nodes, optional or not, list and block lists.
foreach (KeyValuePair <string, IReadOnlyInner> Entry in InnerTable)
{
string PropertyName = Entry.Key;
IReadOnlyInner Inner = Entry.Value;
((IReadOnlyInner <IReadOnlyBrowsingChildIndex>)Inner).CloneChildren(NewNode);
}
// Copy other properties.
foreach (KeyValuePair <string, ValuePropertyType> Entry in ValuePropertyTypeTable)
{
string PropertyName = Entry.Key;
ValuePropertyType Type = Entry.Value;
bool IsHandled = false;
switch (Type)
{
case ValuePropertyType.Boolean:
NodeTreeHelper.CopyBooleanProperty(Node, NewNode, Entry.Key);
IsHandled = true;
break;
case ValuePropertyType.Enum:
NodeTreeHelper.CopyEnumProperty(Node, NewNode, Entry.Key);
IsHandled = true;
break;
case ValuePropertyType.String:
NodeTreeHelper.CopyStringProperty(Node, NewNode, Entry.Key);
IsHandled = true;
break;
case ValuePropertyType.Guid:
NodeTreeHelper.CopyGuidProperty(Node, NewNode, Entry.Key);
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
}
// Also copy comments.
NodeTreeHelper.CopyDocumentation(Node, NewNode, cloneCommentGuid: true);
}
return(NewNode);
}
public void ChildReferencingParentTest()
{
ParentNode parent = new ParentNode();
ChildNode child = new ChildNode();
parent.Children.Add(child);
Assert.AreSame(parent, child.Parent);
parent.Children.Remove(child);
Assert.IsNull(child.Parent);
}
public void ChildReferencingParentTest()
{
ParentNode parent = new ParentNode();
ChildNode child1 = new ChildNode();
ChildNode child2 = new ChildNode();
parent.AdoptedChildren.Add(child1);
parent.AdoptedChildren.Add(child2);
Assert.AreSame(parent, child1.Parent);
Assert.AreSame(parent, child2.Parent);
Assert.AreSame(child1, parent.AdoptedChildren[0]);
Assert.AreSame(child2, parent.AdoptedChildren[1]);
parent.AdoptedChildren.Remove(child1);
Assert.IsNull(child1.Parent);
Assert.AreSame(parent, child2.Parent);
}
/// <summary>
/// Returns the value of the attribute for the specified child.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="relativePath">The relative path.</param>
/// <param name="index">The index.</param>
/// <param name="attributeId">The attribute id.</param>
/// <returns>The value of the attribute for the specified child.</returns>
private object GetAttributeValue(
ChildNode node,
IList<QualifiedName> relativePath,
int index,
uint attributeId)
{
if (index >= relativePath.Count)
{
if (node.NodeClass == NodeClass.Object && attributeId == Attributes.NodeId)
{
return node.Value;
}
if (node.NodeClass == NodeClass.Variable && attributeId == Attributes.Value)
{
return node.Value;
}
return null;
}
for (int ii = 0; ii < node.Children.Count; ii++)
{
if (node.Children[ii].BrowseName == relativePath[index])
{
return GetAttributeValue(node.Children[ii], relativePath, index+1, attributeId);
}
}
return null;
}
/// <summary>
/// Creates a snapshot of a node.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="state">The state.</param>
/// <returns>A snapshot of a node.</returns>
private ChildNode CreateChildNode(ISystemContext context, BaseInstanceState state)
{
ChildNode node = new ChildNode();
node.NodeClass = state.NodeClass;
node.BrowseName = state.BrowseName;
BaseVariableState variable = state as BaseVariableState;
if (variable != null)
{
if (!StatusCode.IsBad(variable.StatusCode))
{
node.Value = Utils.Clone(variable.Value);
}
}
BaseObjectState instance = state as BaseObjectState;
if (instance != null)
{
node.Value = instance.NodeId;
}
node.Children = CreateChildNodes(context, state);
return node;
}
/// <summary>
/// Sets the value for a child. Adds it if it does not already exist.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="browseName">The BrowseName.</param>
/// <param name="nodeClass">The node class.</param>
/// <param name="value">The value.</param>
private void SetChildValue(
ChildNode node,
QualifiedName browseName,
NodeClass nodeClass,
object value)
{
ChildNode child = null;
if (node.Children != null)
{
for (int ii = 0; ii < node.Children.Count; ii++)
{
child = node.Children[ii];
if (child.BrowseName == browseName)
{
break;
}
child = null;
}
}
else
{
node.Children = new List<ChildNode>();
}
if (child == null)
{
child = new ChildNode();
node.Children.Add(child);
}
child.BrowseName = browseName;
child.NodeClass = nodeClass;
child.Value = value;
}
