public Pattern(string glob, PatternFlags flags)
{
Debug.Assert(glob != null);
Glob = glob;
Flags = flags;
}
/// <summary>
/// Create an individual ignore rule for the specified pattern
/// </summary>
/// <param name="pattern">A glob pattern specifying file(s) this rule should ignore</param>
/// <param name="flags">Optional flags determining pattern matching behaviour</param>
public IgnoreRule(string pattern, MatchFlags flags = MatchFlags.PATHNAME)
{
if (Utils.IsNullOrWhiteSpace(pattern))
{
throw new ArgumentNullException(nameof(pattern));
}
// Keep track of the original pattern before modifications (for display purposes)
OriginalPattern = pattern;
Pattern = pattern;
MatchFlags = flags;
// First, let's figure out some things about the pattern and set flags to pass to our match function
PatternFlags = PatternFlags.NONE;
// If the pattern starts with an exclamation mark, it's a negation pattern
// Once we know that, we can remove the exclamation mark (so the pattern behaves just like any other),
// then just negate the match result when we return it
if (Pattern.StartsWith("!", sc))
{
PatternFlags |= PatternFlags.NEGATION;
Pattern = Pattern.Substring(1);
}
// If the pattern starts with a forward slash, it should only match an absolute path
if (Pattern.StartsWith("/", sc))
{
PatternFlags |= PatternFlags.ABSOLUTE_PATH;
Pattern = Pattern.Substring(1);
}
// If the pattern ends with a forward slash, it should only match a directory
// Again though, once we know that we can remove the slash to normalise the pattern
if (Pattern.EndsWith("/", sc))
{
PatternFlags |= PatternFlags.DIRECTORY;
Pattern = Pattern.Substring(0, Pattern.Length - 1);
}
_wildcardIndex = Pattern.IndexOfAny(new char[] { '*', '[', '?' });
// If CASEFOLD is set, string comparisons should ignore case too
if (MatchFlags.HasFlag(MatchFlags.CASEFOLD))
{
sc = StringComparison.OrdinalIgnoreCase;
}
// If PATHNAME is set, single asterisks should not match slashes
if (!MatchFlags.HasFlag(MatchFlags.PATHNAME))
{
MatchFlags |= MatchFlags.PATHNAME;
}
// TODO: Currently, we are just setting PATHNAME for every rule, because it seems to match the original behaviour
// See here for a clue: https://github.com/git/git/blob/c2c5f6b1e479f2c38e0e01345350620944e3527f/dir.c#L99
}
public static Mesh GetPatternMesh(WarriorPattern pattern, PatternFlags flags, Vector2 position, bool inverted = false)
{
List <Vector2> locations = pattern.GetLocationsForFlags(flags, inverted);
int sizeX = GameData.CurrentBattle.Board.Width;
Vector3[] vertices = new Vector3[locations.Count * 4];
int[] triangles = new int[locations.Count * 6];
Vector2[] uv = new Vector2[vertices.Length];
position = BoardUtils.BoardToWorldPosition(position);
int count = 0;
foreach (Vector2 location in locations)
{
int x = ((int)position.x + (int)location.x); //TODO
int y = ((int)position.y - (int)location.y); //TODO
if (!BoardUtils.IsInsideBoard(new Vector2(x, y)))
{
continue;
}
int vX = count * 4;
vertices[vX] = new Vector3(x, y);
vertices[vX + 1] = new Vector3(x + 1, y);
vertices[vX + 2] = new Vector3(x + 1, y + 1);
vertices[vX + 3] = new Vector3(x, y + 1);
int tX = count * 6;
triangles[tX] = vX;
triangles[tX + 1] = vX + 1;
triangles[tX + 2] = vX + 2;
triangles[tX + 3] = vX;
triangles[tX + 4] = vX + 2;
triangles[tX + 5] = vX + 3;
//TODO varies depending on the X
float xOffset = (flags & PatternFlags.Attack) == PatternFlags.Attack ? 0.5f : 0.75f;
uv[vX] = new Vector2(xOffset, 0);
uv[vX + 1] = new Vector2(xOffset + 0.25f, 0);
uv[vX + 2] = new Vector2(xOffset + 0.25f, 1);
uv[vX + 3] = new Vector2(xOffset, 1);
count++;
}
Mesh mesh = new Mesh();
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.uv = uv;
mesh.RecalculateNormals();
return(mesh);
}
public List <Vector2> GetLocationsForFlags(PatternFlags flags, bool xInverted = false)
{
List <Vector2> locations = new List <Vector2>();
for (int y = 0; y < PATTERN_HEIGHT; y++)
{
for (int x = 0; x < PATTERN_WIDTH; x++)
{
if ((grid[y * PATTERN_WIDTH + x] & flags) == flags)
{
locations.Add(GetRelativePosition(x, y, xInverted));
}
}
}
return(locations);
}
/// <summary>
/// Check if a path matches the rule pattern.
/// </summary>
/// <param name="path">String representing the path to check.</param>
/// <param name="pathIsDirectory">Should be set True if the path represents
/// a directory, False if it represents a file.</param>
/// <returns>True if the file or directory path matches the rule pattern.</returns>
public bool IsMatch(string path, bool pathIsDirectory)
{
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentException("Path cannot be null or empty", nameof(path));
}
// .gitignore files use Unix paths (with a forward slash separator),
// so make sure our input also uses forward slashes
path = path.NormalisePath().TrimStart('/');
// Shortcut return if the pattern is directory-only and the path isn't a directory
// This has to be determined by the OS (at least that's the only reliable way),
// so we pass that information in as a boolean so the consuming code can provide it
if (PatternFlags.HasFlag(PatternFlags.DIRECTORY) && pathIsDirectory == false)
{
return(false);
}
// If the pattern is an absolute path pattern, the path must start with the part of the pattern
// before any wildcards occur. If it doesn't, we can just return a negative match
var patternBeforeFirstWildcard = _wildcardIndex != -1
? Pattern.Substring(0, _wildcardIndex)
: Pattern;
if (PatternFlags.HasFlag(PatternFlags.ABSOLUTE_PATH) &&
!path.StartsWith(patternBeforeFirstWildcard, _sc))
{
return(false);
}
// If we got this far, we can't figure out the match with simple
// string matching, so use our regex match function
// If the *pattern* does not contain any slashes, it should match *any*
// occurence, *anywhere* within the path (e.g. '*.jpg' should match
// 'a.jpg', 'a/b.jpg', 'a/b/c.jpg'), so try matching before each slash
if (!Pattern.Contains("/") && path.Contains("/"))
{
return(path.Split('/').Any(segment => Matcher.TryMatch(_rx, segment)));
}
// If the *path* doesn't contain any slashes, we should skip over the conditional above
return(Matcher.TryMatch(_rx, path));
}
public static GameObject GetVisualObject(this WarriorPattern pattern, PatternFlags flags, Vector2 referencePosition, bool inverted = false)
{
GameObject patternObject = new GameObject("_PATTERN_" + flags.ToString());
patternObject.transform.position = new Vector3(patternObject.transform.position.x, patternObject.transform.position.y, -5); //TODO
MeshFilter meshFilter = (MeshFilter)patternObject.AddComponent(typeof(MeshFilter));
meshFilter.mesh = MeshGenerator.GetPatternMesh(pattern, flags, referencePosition, inverted);
MeshRenderer renderer = patternObject.AddComponent(typeof(MeshRenderer)) as MeshRenderer;
renderer.material.shader = Shader.Find("Sprites/Default");
Texture2D texture = (Texture2D)Resources.Load("Sprites/board");
renderer.material.mainTexture = texture;
return(patternObject);
}
public void SetFlagsAt(int x, int y, PatternFlags flags)
{
grid [GetIndexFromRelativePosition(x, y)] = flags;
}
public Pattern(string glob, PatternFlags flags)
{
Glob = glob;
Flags = flags;
}
internal static bool TryParsePattern(string line, StringBuilder reusableBuffer, [NotNullWhen(true)] out string?glob, out PatternFlags flags)
{
glob = null;
flags = PatternFlags.None;
// Trailing spaces are ignored unless '\'-escaped.
// Leading spaces are significant.
// Other whitespace (\t, \v, \f) is significant.
int e = line.Length - 1;
while (e >= 0 && line[e] == ' ')
{
e--;
}
e++;
// Skip blank line.
if (e == 0)
{
return(false);
}
// put trailing space back if escaped:
if (e < line.Length && line[e] == ' ' && line[e - 1] == '\\')
{
e++;
}
int s = 0;
// Skip comment.
if (line[s] == '#')
{
return(false);
}
// Pattern negation.
if (line[s] == '!')
{
flags |= PatternFlags.Negative;
s++;
}
if (s == e)
{
return(false);
}
if (line[e - 1] == '/')
{
flags |= PatternFlags.DirectoryPattern;
e--;
}
if (s == e)
{
return(false);
}
if (line.IndexOf('/', s, e - s) >= 0)
{
flags |= PatternFlags.FullPath;
}
if (line[s] == '/')
{
s++;
}
if (s == e)
{
return(false);
}
int escape = line.IndexOf('\\', s, e - s);
if (escape < 0)
{
glob = line.Substring(s, e - s);
return(true);
}
reusableBuffer.Clear();
reusableBuffer.Append(line, s, escape - s);
int i = escape;
while (i < e)
{
var c = line[i++];
if (c == '\\' && i < e)
{
c = line[i++];
}
reusableBuffer.Append(c);
}
glob = reusableBuffer.ToString();
return(true);
}
public GitIgnorePattern(string pattern, PatternFlags flags)
{
Pattern = pattern;
Flags = flags;
}
