// Use this for initialization
void Start()
{
pointValue = 100;
health = 1;
AnchorInstance = (GameObject)Instantiate(PathAnchor, transform.position, Quaternion.Euler(0, 0, 180));
ThisAnchor = AnchorInstance.GetComponent <PathAnchor>();
ThisAnchor.ParentShip = this;
Physics2D.IgnoreCollision(GetComponent <Collider2D>(), ThisAnchor.GetComponent <Collider2D>());
}
public HierarchicalExpression(PathAnchor anchor, string[] segments, IMemberExpression accessor)
{
this.Anchor = anchor;
this.Accessor = accessor;
this.Segments = segments ?? Array.Empty <string>();
switch (anchor)
{
case PathAnchor.Root:
if (segments == null || segments.Length == 0)
{
this.Path = HierarchicalNode.PathSeparatorChar.ToString();
}
else
{
this.Path = HierarchicalNode.PathSeparatorChar + string.Join(HierarchicalNode.PathSeparatorChar, segments);
}
break;
case PathAnchor.Current:
if (segments == null || segments.Length == 0)
{
this.Path = ".";
}
else
{
this.Path = "." + HierarchicalNode.PathSeparatorChar + string.Join(HierarchicalNode.PathSeparatorChar, segments);
}
break;
case PathAnchor.Parent:
if (segments == null || segments.Length == 0)
{
this.Path = "..";
}
else
{
this.Path = ".." + HierarchicalNode.PathSeparatorChar + string.Join(HierarchicalNode.PathSeparatorChar, segments);
}
break;
default:
if (segments == null || segments.Length == 0)
{
this.Path = string.Empty;
}
else
{
this.Path = string.Join(HierarchicalNode.PathSeparatorChar, Segments);
}
break;
}
}
/// <summary>
/// 尝试解析路径。
/// </summary>
/// <param name="text">指定要解析的路径文本。</param>
/// <param name="scheme">返回解析成功的路径对应的文件系统<see cref="IFileSystem.Scheme"/>方案。</param>
/// <param name="path">返回解析成功的完整路径，更多信息请参考<see cref="Path.FullPath"/>属性文档。</param>
/// <param name="anchor">返回解析成功的路径锚点。</param>
/// <returns>如果解析成功则返回真(True)，否则返回假(False)。</returns>
public static bool TryParse(string text, out string scheme, out string path, out PathAnchor anchor)
{
path = null;
string[] segments;
if (ParseCore(text, false, out scheme, out segments, out anchor))
{
path = GetAnchorString(anchor, true) + string.Join("/", segments);
return(true);
}
return(false);
}
private static string GetAnchorString(PathAnchor anchor, bool slashed)
{
switch (anchor)
{
case PathAnchor.Root:
return("/");
case PathAnchor.Current:
return(slashed ? "./" : ".");
case PathAnchor.Parent:
return(slashed ? "../" : "..");
default:
return(string.Empty);
}
}
private Path(string scheme, string[] segments, PathAnchor anchor)
{
_scheme = scheme;
_segments = segments;
_anchor = anchor;
//计算并保存路径全称
_fullPath = GetAnchorString(anchor, true) + string.Join("/", segments);
if (segments.Length == 0)
{
_fileName = string.Empty;
_directoryName = GetAnchorString(anchor, true);
}
else
{
if (string.IsNullOrEmpty(segments[segments.Length - 1]))
{
_fileName = string.Empty;
_directoryName = _fullPath;
}
else
{
_fileName = segments[segments.Length - 1];
if (segments.Length == 1)
{
_directoryName = GetAnchorString(anchor, true);
}
else
{
_directoryName = GetAnchorString(anchor, true) + string.Join("/", segments, 0, segments.Length - 1) + "/";
}
}
}
}
private Path(string scheme, PathAnchor anchor, string[] segments)
{
_scheme = scheme;
_segments = segments;
_anchor = anchor;
}
/// <summary>
/// 解析路径。
/// </summary>
/// <param name="text">指定要解析的路径文本。</param>
/// <param name="throwException">指定无效的路径文本是否激发异常。</param>
/// <param name="scheme">返回解析成功的路径对应的文件系统<see cref="IFileSystem.Scheme"/>方案。</param>
/// <param name="segments">返回解析成功的路径节点数组，更多信息请参考<see cref="Path.Segments"/>属性文档。</param>
/// <param name="anchor">返回解析成功的路径锚点。</param>
/// <returns>如果解析成功则返回真(True)，否则返回假(False)。</returns>
private static bool ParseCore(string text, bool throwException, out string scheme, out string[] segments, out PathAnchor anchor)
{
const int PATH_NONE_STATE = 0; //状态机：初始态
const int PATH_SLASH_STATE = 1; //状态机：斜杠态（路径分隔符）
const int PATH_ANCHOR_STATE = 2; //状态机：锚点态
const int PATH_SEGMENT_STATE = 3; //状态机：内容态
scheme = null;
segments = null;
anchor = PathAnchor.None;
if (string.IsNullOrEmpty(text))
{
if (throwException)
{
throw new PathException("The path text is null or empty.");
}
return(false);
}
var state = 0;
var spaces = 0;
var part = string.Empty;
var parts = new List <string>();
for (int i = 0; i < text.Length; i++)
{
var chr = text[i];
switch (chr)
{
case ' ':
if (state == PATH_ANCHOR_STATE && anchor == PathAnchor.Current)
{
if (throwException)
{
throw new PathException("");
}
return(false);
}
if (part.Length > 0)
{
spaces++;
}
break;
case '\t':
case '\n':
case '\r':
break;
case ':':
//注意：当首次遇到冒号时，其为Scheme定语；否则即为普通字符
if (parts.Count == 0)
{
if (string.IsNullOrEmpty(part))
{
if (throwException)
{
throw new PathException("The scheme of path is empty.");
}
return(false);
}
//设置路径方案
scheme = part;
//重置空格计数器
spaces = 0;
//重置内容文本
part = string.Empty;
//设置当前状态为初始态
state = PATH_NONE_STATE;
}
else
{
//跳转到默认分支，即做普通字符处理
goto default;
}
break;
case '.':
switch (state)
{
case PATH_NONE_STATE:
anchor = PathAnchor.Current;
break;
case PATH_ANCHOR_STATE:
if (anchor == PathAnchor.Current)
{
anchor = PathAnchor.Parent;
}
else
{
if (throwException)
{
throw new PathException("Invalid anchor of path.");
}
return(false);
}
break;
default:
goto TEXT_LABEL;
}
state = PATH_ANCHOR_STATE;
break;
case '/':
case '\\':
switch (state)
{
case PATH_NONE_STATE:
anchor = PathAnchor.Root;
break;
case PATH_SLASH_STATE:
if (throwException)
{
throw new PathException("Invalid path text, it contains repeated slash character.");
}
return(false);
case PATH_SEGMENT_STATE:
if (string.IsNullOrEmpty(part))
{
if (throwException)
{
throw new PathException("Error occurred, The path parser internal error.");
}
return(false);
}
parts.Add(part);
break;
}
spaces = 0;
part = string.Empty;
state = PATH_SLASH_STATE;
break;
//注意：忽略对“?”、“*”字符的检验处理，因为需要支持对通配符模式路径的链接。
//case '?':
//case '*':
case '"':
case '|':
case '<':
case '>':
if (throwException)
{
throw new ArgumentException(string.Format("Invalid path, it contains '{0}' illegal character(s).", chr));
}
return(false);
default:
TEXT_LABEL:
if (spaces > 0)
{
part += new string(' ', spaces);
spaces = 0;
}
part += chr;
state = PATH_SEGMENT_STATE;
break;
}
}
if (state == PATH_SEGMENT_STATE && part.Length > 0)
{
parts.Add(part);
}
if (parts.Count == 0 && anchor == PathAnchor.None)
{
if (throwException)
{
throw new PathException("The path text is all whitespaces.");
}
return(false);
}
segments = new string[parts.Count + (state == PATH_SLASH_STATE && parts.Count > 0 ? 1 : 0)];
for (var i = 0; i < parts.Count; i++)
{
segments[i] = parts[i];
}
return(true);
}
/// <summary>
/// 尝试解析路径。
/// </summary>
/// <param name="text">指定要解析的路径文本。</param>
/// <param name="scheme">返回解析成功的路径对应的文件系统<see cref="IFileSystem.Scheme"/>方案。</param>
/// <param name="segments">返回解析成功的路径节点数组，更多信息请参考<see cref="Path.Segments"/>属性文档。</param>
/// <param name="anchor">返回解析成功的路径锚点。</param>
/// <returns>如果解析成功则返回真(True)，否则返回假(False)。</returns>
public static bool TryParse(string text, out string scheme, out string[] segments, out PathAnchor anchor)
{
return(ParseCore(text, false, out scheme, out segments, out anchor));
}
