private static void CreateOrUpdateAbstractNodeFromConcreteNode(
ConcreteNode srcNode,
Cluster cluster,
ref int abstractNodeId,
int level,
Dictionary <Id <ConcreteNode>, AbstractNodeInfo> abstractNodes)
{
AbstractNodeInfo abstractNodeInfo;
if (!abstractNodes.TryGetValue(srcNode.NodeId, out abstractNodeInfo))
{
cluster.AddEntrance(
Id <AbstractNode> .From(abstractNodeId),
new Position(srcNode.Info.Position.X - cluster.Origin.X, srcNode.Info.Position.Y - cluster.Origin.Y));
abstractNodeInfo = new AbstractNodeInfo(
Id <AbstractNode> .From(abstractNodeId),
level,
cluster.Id,
new Position(srcNode.Info.Position.X, srcNode.Info.Position.Y),
srcNode.NodeId);
abstractNodes[srcNode.NodeId] = abstractNodeInfo;
abstractNodeId++;
}
else if (level > abstractNodeInfo.Level)
{
abstractNodeInfo.Level = level;
}
}
public void DetermineLevel_WhenOnEdgeOfLevel2Cluster_ReturnLevel2(Orientation orientation, int x, int y, int maxLevel, int expectedLevel)
{
var srcNode = new ConcreteNode(Id <ConcreteNode> .From(1), new ConcreteNodeInfo(false, 1, new Position(x, y)));
var entrance = new Entrance(Id <Entrance> .From(1), null, null, srcNode, null, orientation);
Assert.AreEqual(expectedLevel, entrance.GetEntranceLevel(10, maxLevel));
}
void Start()
{
m_concreteNodeContainer = transform.Find("ConcreteNodeContainer");
m_clusterContainer = transform.Find("ClusterContainer");
m_levelChooser.onValueChanged.AddListener(OnChooseLevel);
m_concreteMap = new ConcreteMap(m_width, m_height);
int nodeId = 0;
for (int y = 0; y < m_height; y++)
{
for (int x = 0; x < m_width; x++)
{
GameObject go = GameObject.Instantiate(m_concreteNodePrefab);
go.name = $"ConcreteNode({x}, {y})";
go.transform.SetParent(m_concreteNodeContainer);
go.transform.localPosition = new Vector3(x, y, 0);
ConcreteNode node = go.GetComponent <ConcreteNode>();
node.Init(nodeId++, x, y);
m_concreteMap.AddNode(x, y, node);
}
}
m_startNode = m_concreteMap.GetNode(0, m_height / 2);
m_startNode.SetSearchType(SearchType.Start);
m_goalNode = m_concreteMap.GetNode(m_width - 1, m_height / 2);
m_goalNode.SetSearchType(SearchType.Goal);
}
public EntrancePoint AddEntrancePoint(int abstractId, ConcreteNode node)
{
EntrancePoint point = new EntrancePoint(abstractId, node);
EntrancePoints.Add(point);
return(point);
}
public Entrance(Cluster cluster1, Cluster cluster2, ConcreteNode node1, ConcreteNode node2, Orientation orientation)
{
Cluster1 = cluster1;
Cluster2 = cluster2;
Node1 = node1;
Node2 = node2;
Orientation = orientation;
}
private void RemoveObstacle()
{
ConcreteNode node = GetMouseOverNode();
if (node != null && node != m_startNode && node != m_goalNode)
{
node.SetCost(Define.c_costGround);
}
}
public Entrance(Id <Entrance> id, Cluster cluster1, Cluster cluster2, ConcreteNode srcNode, ConcreteNode destNode, Orientation orientation)
{
Id = id;
Cluster1 = cluster1;
Cluster2 = cluster2;
SrcNode = srcNode;
DestNode = destNode;
Orientation = orientation;
}
private void DragGoalNode()
{
ConcreteNode node = GetMouseOverNode();
if (node == null)
{
return;
}
m_goalNode.SetSearchType(SearchType.None, false);
m_goalNode = node;
m_goalNode.SetSearchType(SearchType.Goal);
}
private ConcreteNode GetMouseOverNode()
{
ConcreteNode result = null;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out RaycastHit hit))
{
result = hit.collider.GetComponent <ConcreteNode>();
}
return(result);
}
private void CreateEntranceImpl(List <ConcreteNode> prevNodes, List <ConcreteNode> curtNodes, Cluster prevCluster, Cluster curtCluster, Orientation orientation, List <Entrance> result)
{
int size = 0;
ConcreteNode prevBegin = null, curtBegin = null;
for (int i = 0; i < prevNodes.Count; i++)
{
ConcreteNode prev = prevNodes[i];
ConcreteNode curt = curtNodes[i];
if (prevBegin == null)
{
prevBegin = prev;
curtBegin = curt;
}
if (!prev.IsObstacle && !curt.IsObstacle)
{
size++;
}
if ((prev.IsObstacle || curt.IsObstacle || i == prevNodes.Count - 1) && size > 0)
{
if (size >= c_maxEntranceSize)
{
//取两边
result.Add(new Entrance(prevCluster, curtCluster, prevBegin, curtBegin, orientation));
result.Add(new Entrance(prevCluster, curtCluster, prev, curt, orientation));
}
else
{
//取中间
int centerX = (prevBegin.Pos.x + prev.Pos.x) / 2;
int centerY = (prevBegin.Pos.y + prev.Pos.y) / 2;
ConcreteNode prevCenter = m_concreteMap.GetNode(centerX, centerY);
centerX = (curtBegin.Pos.x + curt.Pos.x) / 2;
centerY = (curtBegin.Pos.y + curt.Pos.y) / 2;
ConcreteNode curtCenter = m_concreteMap.GetNode(centerX, centerY);
result.Add(new Entrance(prevCluster, curtCluster, prevCenter, curtCenter, orientation));
}
//清理
prevBegin = curtBegin = null;
size = 0;
}
}
}
private bool TryAddNode(Vector2Int curtPos, int dx, int dy, List <INode> result)
{
int x = curtPos.x + dx;
int y = curtPos.y + dy;
ConcreteNode node = GetNode(x, y);
if (node != null && !node.IsObstacle)
{
result.Add(node);
return(true);
}
else
{
return(false);
}
}
public IList <ConcreteNode> ParseChunk(IList <ScriptToken> tokens)
{
IList <ConcreteNode> nodes = new List <ConcreteNode>();
ConcreteNode node = null;
foreach (var token in tokens)
{
switch (token.type)
{
case Tokens.Variable:
node = new ConcreteNode();
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Variable;
node.File = token.file;
node.Line = token.line;
node.Parent = null;
break;
case Tokens.Word:
node = new ConcreteNode();
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Word;
node.File = token.file;
node.Line = token.line;
node.Parent = null;
break;
case Tokens.Quote:
node = new ConcreteNode();
node.Token = token.lexeme.Substring(1, token.lexeme.Length - 2);
node.Type = ConcreteNodeType.Quote;
node.File = token.file;
node.Line = token.line;
node.Parent = null;
break;
default:
throw new Exception(String.Format("unexpected token {0} at line {1}.", token.lexeme, token.line));
}
if (node != null)
{
nodes.Add(node);
}
}
return(nodes);
}
void Update()
{
if (Input.GetMouseButtonDown(0))
{
ConcreteNode node = GetMouseOverNode();
if (node == m_startNode)
{
m_dragStartNode = true;
}
else if (node == m_goalNode)
{
m_dragGoalNode = true;
}
}
else if (Input.GetMouseButtonUp(0))
{
m_dragStartNode = m_dragGoalNode = false;
}
else if (Input.GetMouseButton(0))
{
if (m_dragStartNode)
{
DragStartNode();
}
else if (m_dragGoalNode)
{
DragGoalNode();
}
else
{
AddObstacle();
}
}
else if (Input.GetMouseButton(1))
{
RemoveObstacle();
}
else if (Input.GetKeyDown(KeyCode.Space))
{
Reset();
Generate();
}
}
private void CreateOrUpdateAbstractNode(ConcreteNode node, Cluster cluster, int level, Dictionary <Vector2Int, AbstractNode> abstractDict, ref int abstractId)
{
AbstractNode abstractNode;
if (abstractDict.TryGetValue(node.Pos, out abstractNode))
{
if (level > abstractNode.Level)
{
abstractNode.Level = level;
}
}
else
{
cluster.AddEntrancePoint(abstractId, node);
abstractNode = HPADemo.Instance.CreateAbstractNode(level, node.Pos);
abstractNode.Init(abstractId, level, cluster.Id, node.Pos);
abstractDict[node.Pos] = abstractNode;
abstractId++;
}
}
public IList<ConcreteNode> Parse( IList<ScriptToken> tokens )
{
var nodes = new List<ConcreteNode>();
var state = ParserState.Ready;
ScriptToken token;
ConcreteNode parent = null, node = null;
var iter = 0;
var end = tokens.Count;
while ( iter != end )
{
token = tokens[ iter ];
switch ( state )
{
#region Ready
case ParserState.Ready:
switch ( token.type )
{
#region Word
case Tokens.Word:
switch ( token.lexeme )
{
#region "import"
case "import":
node = new ConcreteNode();
node.Token = token.lexeme;
node.File = token.file;
node.Line = token.line;
node.Type = ConcreteNodeType.Import;
// The next token is the target
iter++;
if ( iter == end || ( tokens[ iter ].type != Tokens.Word && tokens[ iter ].type != Tokens.Quote ) )
{
throw new Exception( String.Format( "Expected import target at line {0}", node.Line ) );
}
var temp = new ConcreteNode();
temp.Parent = node;
temp.File = tokens[ iter ].file;
temp.Line = tokens[ iter ].line;
temp.Type = tokens[ iter ].type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
if ( temp.Type == ConcreteNodeType.Quote )
{
temp.Token = tokens[ iter ].lexeme.Substring( 1, token.lexeme.Length - 2 );
}
else
{
temp.Token = tokens[ iter ].lexeme;
}
node.Children.Add( temp );
// The second-next token is the source
iter++; // "from"
iter++;
if ( iter == end || ( tokens[ iter ].type != Tokens.Word && tokens[ iter ].type != Tokens.Quote ) )
{
throw new Exception( String.Format( "Expected import source at line {0}", node.Line ) );
}
temp = new ConcreteNode();
temp.Parent = node;
temp.File = tokens[ iter ].file;
temp.Line = tokens[ iter ].line;
temp.Type = tokens[ iter ].type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
if ( temp.Type == ConcreteNodeType.Quote )
{
temp.Token = tokens[ iter ].lexeme.Substring( 1, token.lexeme.Length - 2 );
}
else
{
temp.Token = tokens[ iter ].lexeme;
}
node.Children.Add( temp );
// Consume all the newlines
iter = SkipNewlines( tokens, iter, end );
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
node = null;
break;
#endregion "import"
#region "set"
case "set":
node = new ConcreteNode();
node.Token = token.lexeme;
node.File = token.file;
node.Line = token.line;
node.Type = ConcreteNodeType.VariableAssignment;
// The next token is the variable
++iter;
if ( iter == end || tokens[ iter ].type != Tokens.Variable )
{
throw new Exception( string.Format( "expected variable name at line {0}", node.Line ) );
}
temp = new ConcreteNode();
temp.Parent = node;
temp.File = tokens[ iter ].file;
temp.Line = tokens[ iter ].line;
temp.Type = ConcreteNodeType.Variable;
temp.Token = tokens[ iter ].lexeme;
node.Children.Add( temp );
// The next token is the assignment
++iter;
if ( iter == end || ( tokens[ iter ].type != Tokens.Word && tokens[ iter ].type != Tokens.Quote ) )
{
throw new Exception( string.Format( "expected variable name at line {0}", node.Line ) );
}
temp = new ConcreteNode();
temp.Parent = node;
temp.File = tokens[ iter ].file;
temp.Line = tokens[ iter ].line;
temp.Type = tokens[ iter ].type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
if ( temp.Type == ConcreteNodeType.Quote )
{
temp.Token = tokens[ iter ].lexeme.Substring( 1, tokens[ iter ].lexeme.Length - 2 );
}
else
{
temp.Token = tokens[ iter ].lexeme;
}
node.Children.Add( temp );
// Consume all the newlines
iter = SkipNewlines( tokens, iter, end );
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
node = null;
break;
#endregion "set"
default:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Type = token.type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
if ( node.Type == ConcreteNodeType.Quote )
{
node.Token = token.lexeme.Substring( 1, token.lexeme.Length - 2 );
}
else
{
node.Token = token.lexeme;
}
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
// Set the parent
parent = node;
// Switch states
state = ParserState.Object;
node = null;
break;
}
break;
#endregion Word
#region RightBrace
case Tokens.RightBrace:
// Go up one level if we can
if ( parent != null )
{
parent = parent.Parent;
}
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.RightBrace;
// Consume all the newlines
iter = SkipNewlines( tokens, iter, end );
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
// Move up another level
if ( parent != null )
{
parent = parent.Parent;
}
node = null;
break;
#endregion RightBrace
}
break;
#endregion Ready
#region Object
case ParserState.Object:
switch ( token.type )
{
#region Newline
case Tokens.Newline:
// Look ahead to the next non-newline token and if it isn't an {, this was a property
var next = SkipNewlines( tokens, iter, end );
if ( next == end || tokens[ next ].type != Tokens.LeftBrace )
{
// Ended a property here
if ( parent != null )
{
parent = parent.Parent;
}
state = ParserState.Ready;
}
node = null;
break;
#endregion Newline
#region Colon
case Tokens.Colon:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Colon;
// The following token are the parent objects (base classes).
// Require at least one of them.
var j = iter + 1;
j = SkipNewlines( tokens, j, end );
if ( j == end || ( tokens[ j ].type != Tokens.Word && tokens[ j ].type != Tokens.Quote ) )
{
throw new Exception( String.Format( "Expected object identifier at line {0}", node.Line ) );
}
while ( j != end && ( tokens[ j ].type == Tokens.Word || tokens[ j ].type == Tokens.Quote ) )
{
var tempNode = new ConcreteNode();
tempNode.Token = tokens[ j ].lexeme;
tempNode.File = tokens[ j ].file;
tempNode.Line = tokens[ j ].line;
tempNode.Type = tokens[ j ].type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
tempNode.Parent = node;
node.Children.Add( tempNode );
++j;
}
// Move it backwards once, since the end of the loop moves it forwards again anyway
j--;
iter = j;
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
node = null;
break;
#endregion Colon
#region LeftBrace
case Tokens.LeftBrace:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.LeftBrace;
// Skip newlines
iter = SkipNewlines( tokens, iter, end );
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
// Set the parent
parent = node;
// Change the state
state = ParserState.Ready;
node = null;
break;
#endregion LeftBrace
#region RightBrace
case Tokens.RightBrace:
// Go up one level if we can
if ( parent != null )
{
parent = parent.Parent;
}
// If the parent is currently a { then go up again
if ( parent != null && parent.Type == ConcreteNodeType.LeftBrace && parent.Parent != null )
{
parent = parent.Parent;
}
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.RightBrace;
// Skip newlines
iter = SkipNewlines( tokens, iter, end );
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
//Move up another level
if ( parent != null )
{
parent = parent.Parent;
}
node = null;
state = ParserState.Ready;
break;
#endregion RightBrace
#region Variable
case Tokens.Variable:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Variable;
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
node = null;
break;
#endregion Variable
#region Quote
case Tokens.Quote:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme.Substring( 1, token.lexeme.Length - 2 );
node.Type = ConcreteNodeType.Quote;
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
node = null;
break;
#endregion Quote
#region Word
case Tokens.Word:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Word;
// Insert the node
if ( parent != null )
{
node.Parent = parent;
parent.Children.Add( node );
}
else
{
node.Parent = null;
nodes.Add( node );
}
node = null;
break;
#endregion Word
}
break;
#endregion Object
}
iter++;
}
return nodes;
}
public IList<ConcreteNode> ParseChunk( IList<ScriptToken> tokens )
{
IList<ConcreteNode> nodes = new List<ConcreteNode>();
ConcreteNode node = null;
foreach ( var token in tokens )
{
switch ( token.type )
{
case Tokens.Variable:
node = new ConcreteNode();
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Variable;
node.File = token.file;
node.Line = token.line;
node.Parent = null;
break;
case Tokens.Word:
node = new ConcreteNode();
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Word;
node.File = token.file;
node.Line = token.line;
node.Parent = null;
break;
case Tokens.Quote:
node = new ConcreteNode();
node.Token = token.lexeme.Substring( 1, token.lexeme.Length - 2 );
node.Type = ConcreteNodeType.Quote;
node.File = token.file;
node.Line = token.line;
node.Parent = null;
break;
default:
throw new Exception( String.Format( "unexpected token {0} at line {1}.", token.lexeme, token.line ) );
}
if ( node != null )
{
nodes.Add( node );
}
}
return nodes;
}
public IList <ConcreteNode> Parse(IList <ScriptToken> tokens)
{
var nodes = new List <ConcreteNode>();
var state = ParserState.Ready;
ScriptToken token;
ConcreteNode parent = null, node = null;
var iter = 0;
var end = tokens.Count;
while (iter != end)
{
token = tokens[iter];
switch (state)
{
#region Ready
case ParserState.Ready:
switch (token.type)
{
#region Word
case Tokens.Word:
switch (token.lexeme)
{
#region "import"
case "import":
node = new ConcreteNode();
node.Token = token.lexeme;
node.File = token.file;
node.Line = token.line;
node.Type = ConcreteNodeType.Import;
// The next token is the target
iter++;
if (iter == end || (tokens[iter].type != Tokens.Word && tokens[iter].type != Tokens.Quote))
{
throw new Exception(String.Format("Expected import target at line {0}", node.Line));
}
var temp = new ConcreteNode();
temp.Parent = node;
temp.File = tokens[iter].file;
temp.Line = tokens[iter].line;
temp.Type = tokens[iter].type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
if (temp.Type == ConcreteNodeType.Quote)
{
temp.Token = tokens[iter].lexeme.Substring(1, token.lexeme.Length - 2);
}
else
{
temp.Token = tokens[iter].lexeme;
}
node.Children.Add(temp);
// The second-next token is the source
iter++; // "from"
iter++;
if (iter == end || (tokens[iter].type != Tokens.Word && tokens[iter].type != Tokens.Quote))
{
throw new Exception(String.Format("Expected import source at line {0}", node.Line));
}
temp = new ConcreteNode();
temp.Parent = node;
temp.File = tokens[iter].file;
temp.Line = tokens[iter].line;
temp.Type = tokens[iter].type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
if (temp.Type == ConcreteNodeType.Quote)
{
temp.Token = tokens[iter].lexeme.Substring(1, token.lexeme.Length - 2);
}
else
{
temp.Token = tokens[iter].lexeme;
}
node.Children.Add(temp);
// Consume all the newlines
iter = SkipNewlines(tokens, iter, end);
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
node = null;
break;
#endregion "import"
#region "set"
case "set":
node = new ConcreteNode();
node.Token = token.lexeme;
node.File = token.file;
node.Line = token.line;
node.Type = ConcreteNodeType.VariableAssignment;
// The next token is the variable
++iter;
if (iter == end || tokens[iter].type != Tokens.Variable)
{
throw new Exception(string.Format("expected variable name at line {0}", node.Line));
}
temp = new ConcreteNode();
temp.Parent = node;
temp.File = tokens[iter].file;
temp.Line = tokens[iter].line;
temp.Type = ConcreteNodeType.Variable;
temp.Token = tokens[iter].lexeme;
node.Children.Add(temp);
// The next token is the assignment
++iter;
if (iter == end || (tokens[iter].type != Tokens.Word && tokens[iter].type != Tokens.Quote))
{
throw new Exception(string.Format("expected variable name at line {0}", node.Line));
}
temp = new ConcreteNode();
temp.Parent = node;
temp.File = tokens[iter].file;
temp.Line = tokens[iter].line;
temp.Type = tokens[iter].type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
if (temp.Type == ConcreteNodeType.Quote)
{
temp.Token = tokens[iter].lexeme.Substring(1, tokens[iter].lexeme.Length - 2);
}
else
{
temp.Token = tokens[iter].lexeme;
}
node.Children.Add(temp);
// Consume all the newlines
iter = SkipNewlines(tokens, iter, end);
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
node = null;
break;
#endregion "set"
default:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Type = token.type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
if (node.Type == ConcreteNodeType.Quote)
{
node.Token = token.lexeme.Substring(1, token.lexeme.Length - 2);
}
else
{
node.Token = token.lexeme;
}
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
// Set the parent
parent = node;
// Switch states
state = ParserState.Object;
node = null;
break;
}
break;
#endregion Word
#region RightBrace
case Tokens.RightBrace:
// Go up one level if we can
if (parent != null)
{
parent = parent.Parent;
}
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.RightBrace;
// Consume all the newlines
iter = SkipNewlines(tokens, iter, end);
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
// Move up another level
if (parent != null)
{
parent = parent.Parent;
}
node = null;
break;
#endregion RightBrace
}
break;
#endregion Ready
#region Object
case ParserState.Object:
switch (token.type)
{
#region Newline
case Tokens.Newline:
// Look ahead to the next non-newline token and if it isn't an {, this was a property
var next = SkipNewlines(tokens, iter, end);
if (next == end || tokens[next].type != Tokens.LeftBrace)
{
// Ended a property here
if (parent != null)
{
parent = parent.Parent;
}
state = ParserState.Ready;
}
node = null;
break;
#endregion Newline
#region Colon
case Tokens.Colon:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Colon;
// The following token are the parent objects (base classes).
// Require at least one of them.
var j = iter + 1;
j = SkipNewlines(tokens, j, end);
if (j == end || (tokens[j].type != Tokens.Word && tokens[j].type != Tokens.Quote))
{
throw new Exception(String.Format("Expected object identifier at line {0}", node.Line));
}
while (j != end && (tokens[j].type == Tokens.Word || tokens[j].type == Tokens.Quote))
{
var tempNode = new ConcreteNode();
tempNode.Token = tokens[j].lexeme;
tempNode.File = tokens[j].file;
tempNode.Line = tokens[j].line;
tempNode.Type = tokens[j].type == Tokens.Word ? ConcreteNodeType.Word : ConcreteNodeType.Quote;
tempNode.Parent = node;
node.Children.Add(tempNode);
++j;
}
// Move it backwards once, since the end of the loop moves it forwards again anyway
j--;
iter = j;
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
node = null;
break;
#endregion Colon
#region LeftBrace
case Tokens.LeftBrace:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.LeftBrace;
// Skip newlines
iter = SkipNewlines(tokens, iter, end);
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
// Set the parent
parent = node;
// Change the state
state = ParserState.Ready;
node = null;
break;
#endregion LeftBrace
#region RightBrace
case Tokens.RightBrace:
// Go up one level if we can
if (parent != null)
{
parent = parent.Parent;
}
// If the parent is currently a { then go up again
if (parent != null && parent.Type == ConcreteNodeType.LeftBrace && parent.Parent != null)
{
parent = parent.Parent;
}
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.RightBrace;
// Skip newlines
iter = SkipNewlines(tokens, iter, end);
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
//Move up another level
if (parent != null)
{
parent = parent.Parent;
}
node = null;
state = ParserState.Ready;
break;
#endregion RightBrace
#region Variable
case Tokens.Variable:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Variable;
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
node = null;
break;
#endregion Variable
#region Quote
case Tokens.Quote:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme.Substring(1, token.lexeme.Length - 2);
node.Type = ConcreteNodeType.Quote;
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
node = null;
break;
#endregion Quote
#region Word
case Tokens.Word:
node = new ConcreteNode();
node.File = token.file;
node.Line = token.line;
node.Token = token.lexeme;
node.Type = ConcreteNodeType.Word;
// Insert the node
if (parent != null)
{
node.Parent = parent;
parent.Children.Add(node);
}
else
{
node.Parent = null;
nodes.Add(node);
}
node = null;
break;
#endregion Word
}
break;
#endregion Object
}
iter++;
}
return(nodes);
}
public EntrancePoint(int abstractId, ConcreteNode concreteNode)
{
AbstractId = abstractId;
ConcreteNode = concreteNode;
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ConcreteNode obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public void AddNode(int x, int y, ConcreteNode node)
{
m_nodes[y, x] = node;
}
private bool NodesAreBlocked(ConcreteNode node1, ConcreteNode node2)
{
return(node1.Info.IsObstacle || node2.Info.IsObstacle);
}
