internal OAProperties(NodeProperties target)
{
System.Diagnostics.Debug.Assert(target != null);
this.target = target;
this.AddPropertiesFromType(target.GetType());
}
protected override void OnPointerUp()
{
base.OnPointerUp();
NodeProperties nodeBehaviour = this.GetComponent <NodeProperties>();
if (nodeBehaviour.m_nodeType == NodeProperties.NodeType.Simple)
{
if (m_attachedAnchor == null)
{
if (m_snappedAnchor != null)
{
m_attachedAnchor = m_snappedAnchor;
m_snappedAnchor.Spread();
Destroy(nodeBehaviour.m_deactivatedGUIItem);
}
else
{
Destroy(this.gameObject);
nodeBehaviour.m_deactivatedGUIItem.SetActive(true);
}
}
}
else if (nodeBehaviour.m_nodeType == NodeProperties.NodeType.TargetIndicator)
{
if (m_snappedAnchor != null)
{
this.m_parentNode.GetComponent <NodeMovement>().MoveParentNodeToAnchor(m_snappedAnchor);
}
Destroy(this.gameObject); //destroy the target indicator node
Destroy(m_parentNode.GetComponent <NodeTouchHandler>().m_targetIndicatorBridge); //destroy the target indicator node
}
}
void IConfigDialogView.UpdateNodePropertiesControls(NodeProperties props)
{
descriptionLabel.Text = props?.Description ?? "";
updateLocked = true;
if ((colorComboBox.Enabled = props != null && props.Color != null) == true)
{
if (colorComboBox.Items.Count == 0)
{
colorComboBox.Items.AddRange(props.Palette.Select(c => (object)c).ToArray());
}
colorComboBox.SelectedIndex = props.Palette.IndexOf(c => c.Argb == props.Color.Value.Argb).GetValueOrDefault(-1);
}
if ((markerComboBox.Enabled = props != null && props.Marker != null) == true)
{
if (markerComboBox.Items.Count == 0)
{
markerComboBox.Items.AddRange(typeof(MarkerType).GetEnumValues().OfType <object>().ToArray());
}
markerComboBox.SelectedIndex = typeof(MarkerType).GetEnumValues().OfType <MarkerType>().IndexOf(c => c == props.Marker.Value).GetValueOrDefault(-1);
}
if ((drawLineCheckBox.Enabled = props?.DrawLine != null) == true)
{
drawLineCheckBox.Checked = props.DrawLine.Value;
}
else
{
drawLineCheckBox.Checked = true;
}
updateLocked = false;
}
public OAProperties(NodeProperties target)
{
Utilities.ArgumentNotNull("target", target);
this.target = target;
this.AddPropertiesFromType(target.GetType());
}
private void NodeUpdatedCB(Node obj, NodeProperties prop)
{
if (prop == NodeProperties.POINT)
{
EdgeUpdated?.Invoke(this);
}
}
public void SetupProperties()
{
if (_scene != null)
{
NodeProperties nodeProperties = new NodeProperties();
nodeProperties.Name = _name;
nodeProperties.BaseEntity = this;
nodeProperties.Scene = _scene;
nodeProperties.Enabled = true;
nodeProperties.Node = _node;
nodeProperties.Position = _position;
nodeProperties.PulsarApplication = _scene.MainApplication;
nodeProperties.Rotation = new Quaternion(_rotation.X, _rotation.Y, _rotation.Z);
nodeProperties.Scale = _scale;
nodeProperties.InCreation = false;
nodeProperties.PulsarComponentClass = PulsarComponent.ComponentClass.Properties;
nodeProperties.PulsarComponentType = PulsarComponent.ComponentType.NodeProperties;
if (_componentProperties != null)
{
Debug.Print("BaseEntity.SetupBaseNodeProperties - Added nodeProperties to _componentProperties");
_componentProperties.Add(nodeProperties);
}
ProcessExtendedProperties();
}
}
public OAProperties(NodeProperties target)
{
System.Diagnostics.Debug.Assert(target != null);
this.target = target;
this.AddPropertiesFromType(target.GetType());
}
public void SetupProperties()
{
if (_scene != null)
{
NodeProperties nodeProperties = new NodeProperties
{
Name = _name,
BaseEntity = this,
Scene = _scene,
Enabled = true,
Node = _node,
Position = _position,
PulsarApplication = _scene.MainApplication,
Rotation = new Quaternion(_rotation.X, _rotation.Y, _rotation.Z),
Scale = _scale,
InCreation = false,
PulsarComponentClass = PulsarComponent.ComponentClass.Properties,
PulsarComponentType = PulsarComponent.ComponentType.NodeProperties
};
if (_componentProperties != null)
{
_componentProperties.Add(nodeProperties);
}
ProcessExtendedProperties();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Message" /> class.
/// </summary>
/// <param name="sender">The sender of this message.</param>
/// <param name="data">The data contained in this message.</param>
/// <param name="messageId">The id of this message.</param>
/// <param name="awaitingResponse">
/// A value indicating whether the sender is awaiting a response.
/// </param>
/// <param name="inResponseToMessage">
/// A value indicating whether this message is in response to another.
/// </param>
internal Message(NodeProperties sender, string data, uint messageId, bool awaitingResponse, bool inResponseToMessage)
{
_sender = sender;
_data = data;
_messageId = messageId;
_awaitingResponse = awaitingResponse;
_inResponseToMessage = inResponseToMessage;
}
public NodeProperties[] GetNodes()
{
NodeProperties[] outputArray = new NodeProperties[node.Count];
for (int i = 0; i < outputArray.Length; i++)
{
outputArray[i] = node[i]._nodeProp;
}
return(outputArray);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnaryOperatorNode"/> class.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="argument">The argument.</param>
protected UnaryOperatorNode(NodeTypes type, Node argument)
: base(type)
{
Argument = argument.ThrowIfNull(nameof(argument));
if ((Argument.Properties & NodeProperties.Constant) != 0)
{
Properties = NodeProperties.Constant;
}
}
internal void FireEvent(MapNode node, NodeProperties property, object oldValue)
{
var args = new NodePropertyChangedEventArgs()
{
ChangedProperty = property,
OldValue = oldValue
};
NodePropertyChanged(node, args);
}
public OAProperties(NodeProperties target)
{
System.Diagnostics.Debug.Assert(target != null);
if (target == null)
{
throw new ArgumentNullException("target");
}
this.target = target;
this.AddPropertiesFromType(target.GetType());
}
public OAProperties(NodeProperties target)
{
System.Diagnostics.Debug.Assert(target != null);
if (target == null)
{
throw new ArgumentNullException("target");
}
this.target = target;
this.AddPropertiesFromType(target.GetType());
}
void IConfigDialogView.UpdateNodePropertiesControls(NodeProperties props)
{
nodeDescriptionTextView.Value = props?.Description ?? "";
if (colorPopup.Menu.Count == 0 && props != null)
{
foreach (var c in props.Palette)
{
colorPopup.Menu.AddItem(colorItems[c.Argb] = CreateGraphicsMenuItem((g, r) =>
{
using (var b = new Brush(c.ToColor()))
g.FillRectangle(b, r);
}, () => evts.OnColorChanged(c)));
}
}
if (markerPopup.Menu.Count == 0 && props != null)
{
foreach (var m in Enum.GetValues(typeof(MarkerType)))
{
markerPopup.Menu.AddItem(markerItems[(MarkerType)m] = CreateGraphicsMenuItem((g, r) =>
{
Drawing.DrawLegendSample(g, resources,
new ModelColor(0xff, 0, 0, 0), (MarkerType)m, r);
}, () => evts.OnMarkerChanged((MarkerType)m)));
}
}
if ((colorPopup.Enabled = (props != null && props.Color != null)) == true)
{
colorPopup.SelectItem(colorItems[props.Color.Value.Argb]);
}
else
{
colorPopup.SelectItem((NSMenuItem)null);
}
if ((markerPopup.Enabled = (props != null && props.Marker != null)) == true)
{
markerPopup.SelectItem(markerItems[props.Marker.Value]);
}
else
{
markerPopup.SelectItem((NSMenuItem)null);
}
if ((drawLineCheckbox.Enabled = (props != null && props.DrawLine != null)) == true)
{
drawLineCheckbox.State = props.DrawLine.Value ? NSCellStateValue.On : NSCellStateValue.Off;
}
else
{
drawLineCheckbox.State = NSCellStateValue.On;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BinaryOperatorNode"/> class.
/// </summary>
/// <param name="type">The node type.</param>
/// <param name="left">The left argument.</param>
/// <param name="right">The right argument.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="left"/> or <paramref name="right"/> is <c>null</c>.</exception>
protected BinaryOperatorNode(NodeTypes type, Node left, Node right)
: base(type)
{
Left = left.ThrowIfNull(nameof(left));
Right = right.ThrowIfNull(nameof(right));
// If both are constant, the result is also constant
if ((Left.Properties & NodeProperties.Constant) != 0 && (Right.Properties & NodeProperties.Constant) != 0)
{
Properties |= NodeProperties.Constant;
}
}
public OAProperties(NodeProperties target)
{
Debug.Assert(target != null);
if (target == null)
{
throw new ArgumentNullException("target");
}
Target = target;
AddPropertiesFromType(target.GetType());
}
public async Task <bool> HashesMatch(DbConnection con, string tableName, TypeMap typeMap)
{
const string HASH_COLUMN = "Hash";
string getHashRecord = $"select {HASH_COLUMN} from AnalyzedModelHashes where TableName='{tableName}'";
string existingHash = await con.RunCommandGetString(getHashRecord, HASH_COLUMN);
string newHash = typeMap.EncodeToBase64();
if (existingHash == newHash)
{
return(true);
}
if (existingHash == string.Empty)
{
await CreateTableFromTypeMap(con, tableName, typeMap);
return(false);
}
TypeMap existing = TypeMap.DecodeFromBase64(existingHash);
TypeMapDifferences differences = existing.GetDifferences(typeMap);
foreach (TypeMapDifference difference in differences)
{
if (difference.DifferenceType == DifferenceType.DataTypeChange)
{
throw new Exception($"Difference types {nameof(DifferenceType.DataTypeChange)}, " +
$" not supported. \n" +
$"Column: {difference.ColumnKey}");
}
if (difference.DifferenceType == DifferenceType.ChangedColumnOrder)
{
//TODO: Better handling.
//ignore for now
}
if (difference.DifferenceType == DifferenceType.AddedColumn)
{
NodeProperties node = typeMap[difference.ColumnKey];
string alterState = $"ALTER TABLE {typeMap.Name} ADD COLUMN {difference.ColumnKey} {SqlTranslator.SqlTypeFromInternalType(node.InternalType, this).SqlType};";
await con.RunCommandAsync(alterState);
}
}
return(false);
}
private Node ParseNode(Lexer lexer)
{
Node result = null;
if (lexer.Peek().Type == LexemeType.Semicolon)
{
lexer.Read();
NodeProperties properties = ParseNodeProperties(lexer);
result = new Node(properties);
}
return(result);
}
private NodeProperties ParseNodeProperties(Lexer lexer)
{
NodeProperties result = new NodeProperties();
NodeProperty property = ParseNodeProperty(lexer);
while (property != null)
{
result.Add(property);
property = ParseNodeProperty(lexer);
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="TernaryOperatorNode"/> class.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="condition">The condition.</param>
/// <param name="ifTrue">If true.</param>
/// <param name="ifFalse">If false.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="condition"/>, <paramref name="ifTrue"/> or <paramref name="ifFalse"/> is <c>null</c>.</exception>
protected TernaryOperatorNode(NodeTypes type, Node condition, Node ifTrue, Node ifFalse)
: base(type)
{
Condition = condition.ThrowIfNull(nameof(condition));
IfTrue = ifTrue.ThrowIfNull(nameof(ifTrue));
IfFalse = ifFalse.ThrowIfNull(nameof(ifFalse));
if (((Condition.Properties & NodeProperties.Constant) != 0) &&
((IfTrue.Properties & NodeProperties.Constant) != 0) &&
((IfFalse.Properties & NodeProperties.Constant) != 0))
{
Properties = NodeProperties.Constant;
}
}
string BuildInfoString()
{
NodeProperties np = this.GetComponent <NodeProperties>();
string info = "<b>" + np.LongName + "</b>\n\n";
info += "Layer: " + np.Layer + "\n";
info += "Critically: " + np.Critically + "\n";
info += "Desirability: " + np.Desirability + "\n";
info += "Business Area: " + np.BusinessArea + "\n";
info += "Business Function: " + np.BusinessFunction + "\n";
info += "IsMarkets: " + np.IsMarkets.ToString();
return(info);
}
public static NodeProperties FromString(string s)
{
NodeProperties props = new NodeProperties();
Dictionary <string, string> pairs = new Dictionary <string, string>();
foreach (string segment in s.Split('&'))
{
var segArr = segment.Split('=');
pairs.Add(segArr[0], segArr[1]);
}
props.InternalType = new InternalType(pairs[SQLTYPEKEY]);
props.NodeName = pairs[NODENAMEKEY] != "NULL"? pairs["node_name"] : null;
props.ServiceName = pairs[SERVICENAMEKEY] != "NULL"? pairs[SERVICENAMEKEY] : null;
props.Unique = bool.Parse(pairs[UNIQUEKEY]);
return(props);
}
private void _populateTypeMaps(NodeProperties props, string key, bool overwrite = false)
{
if (key.Length > KeyLengthLimit)
{
KeyLengthLimitSurpassed = true;
}
if (!TypeMap.ContainsKey(key))
{
props.Name = key;
TypeMap[key] = props;
return;
}
TypeMap[key].Update(props);
}
public bool this[NodeProperties p]
{
get
{
return(Properties.HasFlag(p));
}
set
{
if (value)
{
Properties |= p;
}
else
{
Properties &= ~p;
}
}
}
private void NodeUpdatedCB(Node n, NodeProperties prop)
{
if (prop == NodeProperties.HIGHLIGHT)
{
if (n.Highlight)
{
nodeEllipse.Fill = Brushes.YellowGreen;
}
else
{
nodeEllipse.Fill = selected ? Brushes.Green :
visited ? Brushes.Blue:
Brushes.White;
}
}
else if (prop == NodeProperties.VIZUALIZED)
{
if (n.Visualized)
{
nodeEllipse.Fill = Brushes.Red;
}
else
{
nodeEllipse.Fill = selected ? Brushes.Green :
visited ? Brushes.Blue :
Brushes.White;
}
}
else if (prop == NodeProperties.VISITED)
{
Visited = n.Visited;
}
else if (prop == NodeProperties.SHORTESTDISTANCE)
{
if (n.ShortestDistance == int.MaxValue)
{
ShortestDistanceText = "";
}
else
{
ShortestDistanceText = n.ShortestDistance.ToString();
}
}
}
/**
* Drag a playable item onto the scene by destroying the GUI item itself and creating a game object
* **/
public void DragOntoScene()
{
//create a cloned game object
Vector2 guiNodePosition = this.GetComponent <RectTransform>().anchoredPosition;
Vector3 clonedNodePosition = CoordinatesUtils.SharedInstance.GetScreenCoordinatesInWorldPoint(guiNodePosition);
clonedNodePosition.z = NodeProperties.NODE_Z_VALUE;
GameObject clonedNode = (GameObject)Instantiate(m_simpleNodePrefab, clonedNodePosition, Quaternion.identity);
NodeProperties clonedNodeBehaviour = clonedNode.GetComponent <NodeProperties>();
clonedNodeBehaviour.m_nodeType = NodeProperties.NodeType.Simple;
NodeMovement clonedNodeMovement = clonedNode.GetComponent <NodeMovement>();
clonedNodeMovement.m_movementPoints = this.GetComponent <NodeMovement>().m_movementPoints;
//deactivate the gui element
this.gameObject.SetActive(false);
clonedNodeBehaviour.m_deactivatedGUIItem = this.gameObject;
}
/// <summary>
/// Initializes a new instance of the <see cref="FunctionNode"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="arguments">The arguments.</param>
protected FunctionNode(string name, IReadOnlyList <Node> arguments)
: base(NodeTypes.Function)
{
Name = name.ThrowIfNull(nameof(name));
Arguments = arguments.ThrowIfNull(nameof(arguments));
// Check for constant arguments
var isConstant = true;
foreach (var arg in arguments)
{
arg.ThrowIfNull(nameof(arg));
if ((arg.Properties & NodeProperties.Constant) == 0)
{
isConstant = false;
break;
}
}
Properties = isConstant ? NodeProperties.Constant : NodeProperties.None;
}
private static Dictionary <string, PropertyInfo> GetNodeProperties <TNode>() where TNode : IGraphElement
{
var nodeType = typeof(TNode).Name;
lock (NodeProperties)
{
if (NodeProperties.TryGetValue(nodeType, out Dictionary <string, PropertyInfo> result))
{
return(result);
}
var nodePropsDic = typeof(TNode)
.GetProperties()
.Where(x => x.CanRead && x.CanWrite)
.Where(x => x.MemberType == MemberTypes.Property && x.PropertyType.IsPublic)
.Where(x => !x.PropertyType.IsSubclassOf(typeof(IEnumerable)))
.Where(x => x.GetSetMethod() != null && (x.GetSetMethod().Attributes & MethodAttributes.Static) == 0)
.ToDictionary(x => x.Name, x => x);
NodeProperties[nodeType] = nodePropsDic;
return(nodePropsDic);
}
}
public void UpdateNearestNodeToCylinderCenter(int lineIndex)
{
float beta, deltaR;
NodeProperties nodeA = node[line[lineIndex]._lineProp.node1]._nodeProp;
NodeProperties nodeB = node[line[lineIndex]._lineProp.node2]._nodeProp;
float lineLength = Vector3.Magnitude(nodeB.position - nodeA.position);
activeLineLength = lineLength;
float smallestNodeRadius, largestNodeRadius;
if (nodeA.maxRadius > nodeB.maxRadius)
{
smallestNodeRadius = nodeB.maxRadius;
largestNodeRadius = nodeA.maxRadius;
}
else if (nodeA.maxRadius == nodeB.maxRadius)
{
beta = 0;
activeBeta = beta;
line[lineIndex]._lineProp.AC = 0;
line[lineIndex]._lineProp.BD = 0;
return;
}
else
{
smallestNodeRadius = nodeA.maxRadius;
largestNodeRadius = nodeB.maxRadius;
}
deltaR = largestNodeRadius - smallestNodeRadius;
beta = Mathf.Asin((deltaR) / lineLength);
activeBeta = beta * Mathf.Rad2Deg;
line[lineIndex]._lineProp.AC = smallestNodeRadius * deltaR / lineLength;
line[lineIndex]._lineProp.BD = largestNodeRadius * deltaR / lineLength;
line[lineIndex]._lineProp.CE = Mathf.Sqrt(Mathf.Pow(smallestNodeRadius, 2) - Mathf.Pow(line[lineIndex]._lineProp.AC, 2));
line[lineIndex]._lineProp.DF = Mathf.Sqrt(Mathf.Pow(largestNodeRadius, 2) - Mathf.Pow(line[lineIndex]._lineProp.BD, 2));
}
//Updates the bottom UI component to reflect target node properties
public void UpdateNodePopUp(NodeProperties nProp)
{
string output = "";
switch (nProp.NodeEvent)
{
case (NodeProperties.EventType.COMBAT):
output += "There are enemies near this location. Brace for combat!";
break;
case (NodeProperties.EventType.NARRATIVECORE):
output += "Continue your story upon venturing here.";
output += ResourceModToString(nProp.ResourceMod);
break;
case (NodeProperties.EventType.NARRATIVE):
output += "There seems to be something interesting happening here.";
output += ResourceModToString(nProp.ResourceMod);
break;
}
ChangePopUp.GetComponent <Text>().text = output;
}
void DrawNodes()
{
for (int i = 0; i < _nodeProps.Count; i++)
{
NodeProperties node = _nodeProps[i];
Vector3 position = new Vector3(node.X, node.Y, node.Z) * radius;
Vector3 sphericalCoordinates = GetSphericalCoordinates(position);
_nodeProps[i].X = sphericalCoordinates.x;
_nodeProps[i].Y = sphericalCoordinates.y;
_nodeProps[i].Z = sphericalCoordinates.z;
GameObject nodeObj = Instantiate(_nodePrefab, sphericalCoordinates, Quaternion.identity, transform);
nodeObj.name = node.No;
nodeObj.tag = "Node";
Node n = nodeObj.GetComponent <Node>();
n.pos = new Vector3(sphericalCoordinates.x, sphericalCoordinates.y, sphericalCoordinates.z);
n.num = node.No;
_nodes.Add(n);
}
}
/// <summary>
/// Initializes new instance of OANestedProjectProperties object based on specified ProjectNode.
/// </summary>
/// <param name="project">The Project Node.</param>
internal OANestedProjectProperties(NodeProperties nodeProperties)
: base(nodeProperties)
{
this.AddProperties();
}
protected override NodeProperties CreatePropertiesObject()
{
return(_nodeproperties = new SQFileNodeProperties(this));
}
internal void FireEvent(MapNode node, NodeProperties property, object oldValue)
{
var args = new NodePropertyChangedEventArgs()
{
ChangedProperty = property,
OldValue = oldValue
};
NodePropertyChanged(node, args);
}
/// <summary>
/// Initializes a new instance of the <see cref="ApprovedNodeDetails"/> structure.
/// </summary>
/// <param name="node">The node that needs to be acted on.</param>
/// <param name="approvalGranted">A value indicating whether approval was granted or received.</param>
public ApprovedNodeDetails(NodeProperties node, bool approvalGranted)
{
_node = node;
_approvalGranted = approvalGranted;
}
public OAProperties(NodeProperties target) {
Utilities.ArgumentNotNull("target", target);
this.target = target;
this.AddPropertiesFromType(target.GetType());
}