public void AddOperandException()
{
var rootNode = new ConnectorNode(ConnectorType.IMPLY);
rootNode.AddOperand(new AtomNode('A'));
Assert.Throws(typeof(Exception), () => rootNode.AddOperand(new AtomNode('B')));
}
public Loader(TerminalNode startNode, TerminalNode endNode, string filePath)
{
this.startNode = startNode;
this.endNode = endNode;
XmlDocument doc = new XmlDocument();
try
{
doc.Load(filePath);
ConnectorNode con = startNode.OutConnector;
addBlockNodes(doc.DocumentElement.ChildNodes, startNode, startNode);
}
catch (Exception ex)
{}
}
private static void AttachMapPieceToConnectorNode(ConnectorNode connectNode)
{
Vector3 nodeVect = connectNode.NodeStaticLocation;
int mapSize = connectNode.NodeSize;
int rotation = connectNode.NodeStaticRotation;
int mapType = connectNode.NodeMapType;
int mapPiece = connectNode.NodeMapPiece;
GridBuilder.BuildLocationGrid(connectNode, mapSize);
List <Vector3> mapPieceNodes = GridBuilder.GetGridNodeStartPositions();
MapPieceBuilder.AttachMapPieceToMapNode(connectNode, mapPieceNodes, mapSize, mapType, mapPiece, rotation);
MapPieceBuilder.SetPanelsNeighbours();
//connectNode.mapFloorData = _mapPieceBuilder.GetMapFloorData();
//connectNode.mapVentData = _mapPieceBuilder.GetMapVentData();
}
private Node.Node SetAtomRelationsFromRPN(string rulesRPN)
{
var stack = new Stack <Node.Node>();
foreach (var ruleRPN in rulesRPN)
{
if (!Operators.Contains(ruleRPN))
{
stack.Push(Atoms[ruleRPN]);
}
else if (ruleRPN == '!')
{
stack.Push(new NegativeNode(stack.Pop()));
}
else
{
ConnectorNode newConnector;
var atom1 = stack.Pop();
var atom2 = stack.Pop();
if (atom1.GetType() == typeof(ConnectorNode) &&
((ConnectorNode)atom1).Type == ListOperations[ruleRPN])
{
((ConnectorNode)atom1).AddOperand(atom2);
newConnector = (ConnectorNode)atom1;
Connectors.Pop();
}
else if (atom2.GetType() == typeof(ConnectorNode) &&
((ConnectorNode)atom2).Type == ListOperations[ruleRPN])
{
((ConnectorNode)atom2).AddOperand(atom1);
newConnector = (ConnectorNode)atom2;
Connectors.Pop();
}
else
{
newConnector = new ConnectorNode(ListOperations[ruleRPN]);
newConnector.AddOperands(new[] { atom1, atom2 });
}
Connectors.Push(newConnector);
stack.Push(newConnector);
}
}
return(stack.Pop());
}
//////////////////////////////////////////
/// THESE NEED TO BE IN A DIFFFERNT SCRIPT
private void AttachMapPieceToConnectorNode(ConnectorNode connectNode)
{
Vector3 nodeVect = connectNode.nodeLocation;
int mapSize = connectNode.nodeSize;
int layerCount = connectNode.nodeLayerCount;
int rotation = connectNode.nodeRotation;
int mapType = connectNode.nodeMapType;
int mapPiece = connectNode.nodeMapPiece;
_gridBuilder.BuildLocationGrid(connectNode, mapSize);
List <Vector3> mapPieceNodes = _gridBuilder.GetGridNodePositions();
_mapPieceBuilder.AttachMapPieceToMapNode(connectNode, mapPieceNodes, layerCount, mapSize, mapType, mapPiece, rotation);
_locationManager.AddCubeScriptToLocationLookup(_gridBuilder.GetGridLocations()); // needs to be after AttachMapPieceToMapNode
_mapPieceBuilder.SetPanelsNeighbours();
//connectNode.mapFloorData = _mapPieceBuilder.GetMapFloorData();
//connectNode.mapVentData = _mapPieceBuilder.GetMapVentData();
}
public Project_Loader(TerminalNode startNode, TerminalNode endNode, string filePath)
{
this.startNode = startNode;
this.endNode = endNode;
XmlDocument doc = new XmlDocument();
try
{
doc.Load(filePath);
//doc.Validate(onValidateEnd);
ConnectorNode con = startNode.OutConnector;
addBlockNodes(doc.DocumentElement.ChildNodes, startNode, startNode);
// foreach (Pair pair in blockNodes)
// setAttributes(pair.XmlNode, pair.BaseNode);
}
catch (Exception ex) {
}
}
//////////////////////////////////////////
/// THESE NEED TO BE IN A DIFFFERNT SCRIPT
public void AttachMapToNode <T>(T node) where T : BaseNode
{
if (node.thisNodeType == NodeTypes.WorldNode)
{
WorldNode worldNode = node as WorldNode;
AttachMapPiecesToWorldNode(worldNode);
}
if (node.thisNodeType == NodeTypes.MapNode)
{
MapNode mapNode = node as MapNode;
AttachMapPieceToMapNode(mapNode);
}
if (node.thisNodeType == NodeTypes.ConnectorNode)
{
ConnectorNode connectNode = node as ConnectorNode;
AttachMapPieceToConnectorNode(connectNode);
}
}
private void SetAtomsRelations(ArrayList rules)
{
foreach (ExpertSystemRule rule in rules)
{
var left = SetAtomRelationsFromRPN(rule.NpiLeft);
var right = SetAtomRelationsFromRPN(rule.NpiRight);
var connectorImply = new ConnectorNode(ConnectorType.IMPLY);
right.AddChildren(connectorImply);
connectorImply.AddOperand(left);
Implication.Add(new ImplicationData(left, right));
if (rule.Type != ImplicationType.EQUAL)
{
continue;
}
var connectorEqual = new ConnectorNode(ConnectorType.IMPLY);
left.AddChildren(connectorEqual);
connectorEqual.AddOperand(right);
Implication.Add(new ImplicationData(right, left));
}
}
////////////////////////////////////////////////
////////////////////////////////////////////////
public static void AttachMapToNode <T>(T node) where T : BaseNode
{
if (node.NodeType == NodeTypes.WorldNode)
{
WorldNode worldNode = node as WorldNode;
AttachMapPiecesToWorldNode(worldNode);
}
if (node.NodeType == NodeTypes.MapNode)
{
MapNode mapNode = node as MapNode;
AttachMapPieceToMapNode(mapNode);
}
if (node.NodeType == NodeTypes.ConnectorNode)
{
ConnectorNode connectNode = node as ConnectorNode;
AttachMapPieceToConnectorNode(connectNode);
}
// Debug.Log("AttachMapToNode FINISHED");
}
////////////////////////////////////////////////////////////////////////////
// Create Connector Nodes ////////////////////////////////////////////////
private Dictionary <WorldNode, List <ConnectorNode> > CreateConnectorNodes(Dictionary <WorldNode, List <KeyValuePair <Vector3, int> > > connectorVects)
{
// Wrap map Nodes around around Initial
Dictionary <WorldNode, List <ConnectorNode> > worldNodeAndConnectorNodes = new Dictionary <WorldNode, List <ConnectorNode> >();
foreach (WorldNode worldNode in connectorVects.Keys)
{
List <ConnectorNode> connectorNodes = new List <ConnectorNode>();
List <KeyValuePair <Vector3, int> > vectsAndRot = connectorVects[worldNode];
foreach (KeyValuePair <Vector3, int> pair in vectsAndRot)
{
Vector3 vector = pair.Key;
int rotation = pair.Value;
int mapType = MAPTYPE_CONNECTOR;
int mapPiece = 0; // only 1 connector map piece atm for both vertical and horizontal pieces
ConnectorNode connectorNode = CreateNode <ConnectorNode>(worldNode.gameObject.transform, vector, rotation, mapType, mapPiece, NodeTypes.ConnectorNode);
_nodeBuilder.AttachCoverToNode(connectorNode, connectorNode.gameObject, CoverTypes.ConnectorCover);
connectorNode.nodeSize = 1;
connectorNode.neighbours = new int[6];
for (int i = 0; i < connectorNode.neighbours.Length; i++)
{
connectorNode.neighbours[i] = 1;
}
connectorNode.worldNodeParent = worldNode;
connectorNodes.Add(connectorNode);
if (rotation == 4)
{
connectorNode.connectorUp = true;
connectorNode.nodeMapType = MAPTYPE_CONNECTOR_UP;
}
}
worldNode.connectorNodes = connectorNodes;
worldNodeAndConnectorNodes.Add(worldNode, connectorNodes);
///// Connector Neighbours << This is a bit annoying is only using worldnode neighbours atm, might be cool to just use map neighbours instead... something to do
int[] worldNodeNeighbours = worldNode.neighbours;
if (worldNode.nodeSize == 1)
{
foreach (ConnectorNode connectorNode in worldNode.connectorNodes)
{
int[] connectorNeighbours = connectorNode.neighbours;
for (int i = 0; i < worldNodeNeighbours.Length; i++)
{
if (worldNodeNeighbours[i] != -1)
{
connectorNeighbours[i] = 1;
}
else
{
connectorNeighbours[i] = -1;
connectorNode.entranceSides.Add(i);
}
}
}
}
////////
}
return(worldNodeAndConnectorNodes);
}
////////////////////////////////////////////////////////////////////////////
// Create Connector Nodes ////////////////////////////////////////////////
public static Dictionary <WorldNode, List <ConnectorNode> > CreateConnectorNodes(Dictionary <WorldNode, List <KeyValuePair <Vector3, int> > > connectorVects)
{
// Wrap map Nodes around around Initial
Dictionary <WorldNode, List <ConnectorNode> > worldNodeAndConnectorNodes = new Dictionary <WorldNode, List <ConnectorNode> >();
foreach (WorldNode worldNode in connectorVects.Keys)
{
List <ConnectorNode> connectorNodes = new List <ConnectorNode>();
List <KeyValuePair <Vector3, int> > vectsAndRot = connectorVects[worldNode];
foreach (KeyValuePair <Vector3, int> pair in vectsAndRot)
{
Vector3 vector = pair.Key;
int rotation = pair.Value;
int mapType = MapSettings.MAPTYPE_CONNECT_FLOOR;
int mapPiece = 0; // only 1 connector map piece atm for both vertical and horizontal pieces
int nodeLayerCount = -1;
ConnectorNode connectorNode = WorldBuilder._nodeBuilder.CreateNode <ConnectorNode>(worldNode.gameObject.transform, vector, rotation, mapType, mapPiece, NodeTypes.ConnectorNode);
WorldBuilder._nodeBuilder.AttachCoverToNode(connectorNode, connectorNode.gameObject, CoverTypes.ConnectorCover, new Vector3(0, rotation * 90, 0));
connectorNode.NodeSize = 1;
connectorNode.neighbours = new int[6];
for (int i = 0; i < connectorNode.neighbours.Length; i++)
{
connectorNode.neighbours[i] = 1;
}
connectorNode.worldNodeParent = worldNode;
connectorNodes.Add(connectorNode);
// Up connector
if (rotation == 4)
{
connectorNode.connectorUp = true;
connectorNode.NodeMapType = MapSettings.MAPTYPE_CONNECT_UP_FLOOR;
connectorNode.transform.localEulerAngles = new Vector3(0, rotation * 90, 0);
Transform nodeCover = connectorNode.transform.Find("ConnectorCoverPrefab(Clone)");
nodeCover.localPosition = new Vector3(0, 0, 0); // to fix annoying vertical connector
nodeCover.localScale = new Vector3(8, 8, 8);
nodeCover.Find("Select").transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
}
if (worldNode.NodeSize == 1)
{
nodeLayerCount = worldNode.NodeLayerCount + 4; // 4 total layers in 1 map and vent piece
}
else
{
Debug.LogError("something weird here");
}
connectorNode.NodeLayerCount = nodeLayerCount;
LayerManager.AddNodeToLayer(connectorNode); // for camera layers
}
worldNode.connectorNodes = connectorNodes;
worldNodeAndConnectorNodes.Add(worldNode, connectorNodes);
///// Connector Neighbours << This is a bit annoying is only using worldnode neighbours atm, might be cool to just use map neighbours instead... something to do
int[] worldNodeNeighbours = worldNode.neighbours;
if (worldNode.NodeSize == 1)
{
foreach (ConnectorNode connectorNode in worldNode.connectorNodes)
{
int[] connectorNeighbours = connectorNode.neighbours;
for (int i = 0; i < worldNodeNeighbours.Length; i++)
{
if (worldNodeNeighbours[i] != -1)
{
connectorNeighbours[i] = 1;
}
else
{
connectorNeighbours[i] = -1;
//connectorNode.entranceSides.Add(i);
}
}
}
}
////////
}
return(worldNodeAndConnectorNodes);
}
